reflexion 0.1.19 → 0.1.23

data/.doc/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"
 
 
@@ -19,23 +21,18 @@ VALUE alloc(VALUE klass)
 }
 
 static
-VALUE initialize(VALUE self, VALUE type, VALUE pointer_type, VALUE modifiers, VALUE count, VALUE drag, VALUE positions)
+VALUE initialize(VALUE self)
 {
 	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);
 }
@@ -49,88 +46,48 @@ VALUE initialize_copy(VALUE self, VALUE obj)
 }
 
 static
-VALUE type(VALUE self)
+VALUE get_size(VALUE self)
 {
 	CHECK;
-	return value(THIS->type);
+	return value(THIS->size());
 }
 
 static
-VALUE pointer_type(VALUE self)
+VALUE is_empty(VALUE self)
 {
 	CHECK;
-	return value(THIS->pointer_type);
+	return value(THIS->empty());
 }
 
 static
-VALUE size(VALUE self)
+VALUE is_captured(VALUE self)
 {
 	CHECK;
-	return value(THIS->size);
+	return value(THIS->is_captured());
 }
 
 static
-VALUE modifiers(VALUE self)
-{
-	CHECK;
-	return value(THIS->modifiers);
-}
-
-static
-VALUE count(VALUE self)
-{
-	CHECK;
-	return value(THIS->count);
-}
-
-static
-VALUE drag(VALUE self)
-{
-	CHECK;
-	return value(THIS->drag);
-}
-
-static
-VALUE capture(VALUE self)
-{
-	CHECK;
-	return value(THIS->capture);
-}
-
-static
-VALUE x(VALUE self)
-{
-	CHECK;
-	return value(THIS->x);
-}
-
-static
-VALUE y(VALUE self)
+VALUE get_at(VALUE self, VALUE index)
 {
 	CHECK;
-	return value(THIS->y);
-}
 
-static
-VALUE position(VALUE self)
-{
-	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]);
 }
 
 static
-VALUE get_at(VALUE self, VALUE index)
+VALUE each(VALUE self)
 {
 	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;
 }
 
 
@@ -143,29 +100,13 @@ Init_pointer_event ()
 
 	cPointerEvent = mReflex.define_class("PointerEvent", Reflex::event_class());
 	rb_define_alloc_func(cPointerEvent, alloc);
-	rb_define_private_method(cPointerEvent, "initialize", RUBY_METHOD_FUNC(initialize), 6);
+	rb_define_private_method(cPointerEvent, "initialize", RUBY_METHOD_FUNC(initialize), -1);
 	rb_define_private_method(cPointerEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
-	rb_define_method(cPointerEvent, "type", RUBY_METHOD_FUNC(type), 0);
-	rb_define_method(cPointerEvent, "pointer_type", RUBY_METHOD_FUNC(pointer_type), 0);
-	rb_define_method(cPointerEvent, "size", RUBY_METHOD_FUNC(size), 0);
-	rb_define_method(cPointerEvent, "modifiers", RUBY_METHOD_FUNC(modifiers), 0);
-	rb_define_method(cPointerEvent, "count", RUBY_METHOD_FUNC(count), 0);
-	cPointerEvent.define_method("drag?", drag);
-	cPointerEvent.define_method("capture?", capture);
-	rb_define_method(cPointerEvent, "x", RUBY_METHOD_FUNC(x), 0);
-	rb_define_method(cPointerEvent, "y", RUBY_METHOD_FUNC(y), 0);
-	rb_define_method(cPointerEvent, "position", RUBY_METHOD_FUNC(position), -1);
-	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);
+	rb_define_method(cPointerEvent, "size", RUBY_METHOD_FUNC(get_size), 0);
+	cPointerEvent.define_method("empty?",    is_empty);
+	cPointerEvent.define_method("captured?", is_captured);
+	cPointerEvent.define_method("[]",        get_at);
+	rb_define_method(cPointerEvent, "each", RUBY_METHOD_FUNC(each), 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/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/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.19
+0.1.23

data/ext/reflex/contact_event.cpp

@@ -42,7 +42,7 @@ RUCY_DEF1(initialize_copy, obj)
 RUCY_END
 
 static
-RUCY_DEF0(type)
+RUCY_DEF0(get_type)
 {
 	CHECK;
 	return value(THIS->type);
@@ -50,7 +50,7 @@ RUCY_DEF0(type)
 RUCY_END
 
 static
-RUCY_DEF0(shape)
+RUCY_DEF0(get_shape)
 {
 	CHECK;
 	return value(THIS->shape);
@@ -58,7 +58,7 @@ RUCY_DEF0(shape)
 RUCY_END
 
 static
-RUCY_DEF0(view)
+RUCY_DEF0(get_view)
 {
 	CHECK;
 	return value(THIS->view);
@@ -77,9 +77,9 @@ 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_method("type",  get_type);
+	cContactEvent.define_method("shape", get_shape);
+	cContactEvent.define_method("view",  get_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);

data/ext/reflex/event.cpp

@@ -43,6 +43,14 @@ RUCY_DEF0(is_blocked)
 }
 RUCY_END
 
+static
+RUCY_DEF0(get_time)
+{
+	CHECK;
+	return value(THIS->time());
+}
+RUCY_END
+
 
 static Class cEvent;
 
@@ -54,8 +62,9 @@ Init_event ()
 	cEvent = mReflex.define_class("Event");
 	cEvent.define_alloc_func(alloc);
 	cEvent.define_private_method("initialize_copy", initialize_copy);
-	cEvent.define_method("block", block);
-	cEvent.define_method("block?", is_blocked);
+	cEvent.define_method("block",    block);
+	cEvent.define_method("blocked?", is_blocked);
+	cEvent.define_method("time",     get_time);
 }
 
 

data/ext/reflex/focus_event.cpp

@@ -42,7 +42,7 @@ RUCY_DEF1(initialize_copy, obj)
 RUCY_END
 
 static
-RUCY_DEF0(type)
+RUCY_DEF0(get_type)
 {
 	CHECK;
 	return value(THIS->type);
@@ -50,7 +50,7 @@ RUCY_DEF0(type)
 RUCY_END
 
 static
-RUCY_DEF0(current)
+RUCY_DEF0(get_current)
 {
 	CHECK;
 	return THIS->current ? value(THIS->current) : nil();
@@ -58,7 +58,7 @@ RUCY_DEF0(current)
 RUCY_END
 
 static
-RUCY_DEF0(last)
+RUCY_DEF0(get_last)
 {
 	CHECK;
 	return THIS->last ? value(THIS->last) : nil();
@@ -77,9 +77,9 @@ Init_focus_event ()
 	cFocusEvent.define_alloc_func(alloc);
 	cFocusEvent.define_private_method("initialize",      initialize);
 	cFocusEvent.define_private_method("initialize_copy", initialize_copy);
-	cFocusEvent.define_method("type", type);
-	cFocusEvent.define_method("current", current);
-	cFocusEvent.define_method("last", last);
+	cFocusEvent.define_method("type",    get_type);
+	cFocusEvent.define_method("current", get_current);
+	cFocusEvent.define_method("last",    get_last);
 	cFocusEvent.define_const("TYPE_NONE",  Reflex::FocusEvent::NONE);
 	cFocusEvent.define_const("TYPE_FOCUS", Reflex::FocusEvent::FOCUS);
 	cFocusEvent.define_const("TYPE_BLUR",  Reflex::FocusEvent::BLUR);