reflexion 0.1.22 → 0.1.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3ddbc019fc036a931bdef9ec81872663f375a2e440003ef18b638666e61f7ed7
-  data.tar.gz: 6a803b54ac97bbe773c432f2089383983b95e2f5187891e5fd79aaca375fa9d4
+  metadata.gz: 5c9de459b494d9ab8e2e94e53a26b0fd9d363a1c66dd442894d0385827634849
+  data.tar.gz: 26858625a7e25d0cbba85d7a054ab9426c526997d0eb2ed704b125ee93ba436c
 SHA512:
-  metadata.gz: de9b87fd54230c33385b5e252ea39aae91b395e6f9aa2d2ef5b8dfcb9aead804831c7b6f8614b296df041914cf0a69e998e41e518d955d644ccec3e225a21c9d
-  data.tar.gz: c2072f7e2fa3c76e3d4a6aece31a6fa9c90f838bb7d96c2cc636def5c375b1c90f702634558363e0f282c0c79fc6adecd0484baa85c1d2c6c29a43e52118caad
+  metadata.gz: 6c0e16849f3de4b39cfe8270f8208b0e6e1f2cae808e3a678f4b79bad2d9a397f741e78474670350de327e54c91fe64f199f6b2dc437635950147a0f91610e5a
+  data.tar.gz: 2c38f9a17ec2a0d8a81f067b3326c0dca5bc970d86735ac503238eb458ac8ed8c452bc32042ee96f4a109e78742a8b3107d48237775e4090a08885905e378709

data/.doc/ext/reflex/event.cpp

@@ -39,6 +39,13 @@ VALUE is_blocked(VALUE self)
 	return value(THIS->is_blocked());
 }
 
+static
+VALUE get_time(VALUE self)
+{
+	CHECK;
+	return value(THIS->time());
+}
+
 
 static Class cEvent;
 
@@ -51,7 +58,8 @@ Init_event ()
 	rb_define_alloc_func(cEvent, alloc);
 	rb_define_private_method(cEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
 	rb_define_method(cEvent, "block", RUBY_METHOD_FUNC(block), 0);
-	cEvent.define_method("block?", is_blocked);
+	cEvent.define_method("blocked?", is_blocked);
+	rb_define_method(cEvent, "time", RUBY_METHOD_FUNC(get_time), 0);
 }
 
 

data/.doc/ext/reflex/key_event.cpp

@@ -272,10 +272,10 @@ VALUE get_repeat(VALUE self)
 }
 
 static
-VALUE is_capture(VALUE self)
+VALUE is_captured(VALUE self)
 {
 	CHECK;
-	return value(THIS->capture);
+	return value(THIS->captured);
 }
 
 
@@ -296,7 +296,7 @@ Init_key_event ()
 	rb_define_method(cKeyEvent, "code", RUBY_METHOD_FUNC(get_code), 0);
 	rb_define_method(cKeyEvent, "modifiers", RUBY_METHOD_FUNC(get_modifiers), 0);
 	rb_define_method(cKeyEvent, "repeat", RUBY_METHOD_FUNC(get_repeat), 0);
-	cKeyEvent.define_method("capture?",  is_capture);
+	cKeyEvent.define_method("captured?", is_captured);
 	cKeyEvent.define_const("TYPE_NONE", Reflex::KeyEvent::NONE);
 	cKeyEvent.define_const("TYPE_DOWN", Reflex::KeyEvent::DOWN);
 	cKeyEvent.define_const("TYPE_UP",   Reflex::KeyEvent::UP);

data/.doc/ext/reflex/native.cpp

@@ -17,6 +17,7 @@ void Init_frame_event ();
 void Init_scroll_event ();
 void Init_focus_event ();
 void Init_key_event ();
+void Init_pointer ();
 void Init_pointer_event ();
 void Init_wheel_event ();
 void Init_capture_event ();
@@ -63,6 +64,7 @@ extern "C" void
 	Init_scroll_event();
 	Init_focus_event();
 	Init_key_event();
+	Init_pointer();
 	Init_pointer_event();
 	Init_wheel_event();
 	Init_capture_event();

data/.doc/ext/reflex/pointer.cpp

@@ -0,0 +1,158 @@
+#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
+VALUE alloc(VALUE klass)
+{
+	return new_type<Reflex::Pointer>(klass);
+}
+
+static
+VALUE initialize(VALUE self, VALUE
+	id, VALUE type, VALUE action, VALUE position, VALUE modifiers, VALUE click_count, VALUE drag, VALUE 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;
+}
+
+static
+VALUE initialize_copy(VALUE self, VALUE obj)
+{
+	CHECK;
+	*THIS = to<Reflex::Pointer&>(obj);
+	return self;
+}
+
+static
+VALUE get_id(VALUE self)
+{
+	CHECK;
+	return value(THIS->id());
+}
+
+static
+VALUE get_type(VALUE self)
+{
+	CHECK;
+	return value(THIS->type());
+}
+
+static
+VALUE get_action(VALUE self)
+{
+	CHECK;
+	return value(THIS->action());
+}
+
+static
+VALUE get_position(VALUE self)
+{
+	CHECK;
+	return value(THIS->position());
+}
+
+static
+VALUE get_modifiers(VALUE self)
+{
+	CHECK;
+	return value(THIS->modifiers());
+}
+
+static
+VALUE get_click_count(VALUE self)
+{
+	CHECK;
+	return value(THIS->click_count());
+}
+
+static
+VALUE is_drag(VALUE self)
+{
+	CHECK;
+	return value(THIS->is_drag());
+}
+
+static
+VALUE get_time(VALUE self)
+{
+	CHECK;
+	return value(THIS->time());
+}
+
+static
+VALUE get_prev(VALUE self)
+{
+	CHECK;
+	return value(THIS->prev());
+}
+
+
+static Class cPointer;
+
+void
+Init_pointer ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cPointer = rb_define_class_under(mReflex, "Pointer", rb_cObject);
+	rb_define_alloc_func(cPointer, alloc);
+	rb_define_private_method(cPointer, "initialize", RUBY_METHOD_FUNC(initialize), 8);
+	rb_define_private_method(cPointer, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+	rb_define_method(cPointer, "id", RUBY_METHOD_FUNC(get_id), 0);
+	rb_define_private_method(cPointer, "get_type", RUBY_METHOD_FUNC(get_type), 0);
+	rb_define_private_method(cPointer, "get_action", RUBY_METHOD_FUNC(get_action), 0);
+	rb_define_method(cPointer, "position", RUBY_METHOD_FUNC(get_position), 0);
+	rb_define_method(cPointer, "modifiers", RUBY_METHOD_FUNC(get_modifiers), 0);
+	rb_define_method(cPointer, "click_count", RUBY_METHOD_FUNC(get_click_count), 0);
+	cPointer.define_method("drag?",              is_drag);
+	rb_define_method(cPointer, "time", RUBY_METHOD_FUNC(get_time), 0);
+	rb_define_method(cPointer, "prev", RUBY_METHOD_FUNC(get_prev), 0);
+	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/.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);
 }
@@ -48,89 +45,49 @@ VALUE initialize_copy(VALUE self, VALUE obj)
 	return self;
 }
 
-static
-VALUE get_type(VALUE self)
-{
-	CHECK;
-	return value(THIS->type);
-}
-
-static
-VALUE get_pointer_type(VALUE self)
-{
-	CHECK;
-	return value(THIS->pointer_type);
-}
-
 static
 VALUE get_size(VALUE self)
 {
 	CHECK;
-	return value(THIS->size);
-}
-
-static
-VALUE get_modifiers(VALUE self)
-{
-	CHECK;
-	return value(THIS->modifiers);
-}
-
-static
-VALUE get_count(VALUE self)
-{
-	CHECK;
-	return value(THIS->count);
-}
-
-static
-VALUE is_drag(VALUE self)
-{
-	CHECK;
-	return value(THIS->drag);
+	return value(THIS->size());
 }
 
 static
-VALUE is_capture(VALUE self)
+VALUE is_empty(VALUE self)
 {
 	CHECK;
-	return value(THIS->capture);
+	return value(THIS->empty());
 }
 
 static
-VALUE get_x(VALUE self)
+VALUE is_captured(VALUE self)
 {
 	CHECK;
-	return value(THIS->x);
+	return value(THIS->is_captured());
 }
 
 static
-VALUE get_y(VALUE self)
+VALUE get_at(VALUE self, VALUE index)
 {
 	CHECK;
-	return value(THIS->y);
-}
 
-static
-VALUE get_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(get_type), 0);
-	rb_define_method(cPointerEvent, "pointer_type", RUBY_METHOD_FUNC(get_pointer_type), 0);
 	rb_define_method(cPointerEvent, "size", RUBY_METHOD_FUNC(get_size), 0);
-	rb_define_method(cPointerEvent, "modifiers", RUBY_METHOD_FUNC(get_modifiers), 0);
-	rb_define_method(cPointerEvent, "count", RUBY_METHOD_FUNC(get_count), 0);
-	cPointerEvent.define_method("drag?",        is_drag);
-	cPointerEvent.define_method("capture?",     is_capture);
-	rb_define_method(cPointerEvent, "x", RUBY_METHOD_FUNC(get_x), 0);
-	rb_define_method(cPointerEvent, "y", RUBY_METHOD_FUNC(get_y), 0);
-	rb_define_method(cPointerEvent, "position", RUBY_METHOD_FUNC(get_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);
+	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)
 {
@@ -229,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)
 {
@@ -250,6 +271,8 @@ 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);
@@ -274,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.22
+0.1.23

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/key_event.cpp

@@ -281,10 +281,10 @@ RUCY_DEF0(get_repeat)
 RUCY_END
 
 static
-RUCY_DEF0(is_capture)
+RUCY_DEF0(is_captured)
 {
 	CHECK;
-	return value(THIS->capture);
+	return value(THIS->captured);
 }
 RUCY_END
 
@@ -306,7 +306,7 @@ Init_key_event ()
 	cKeyEvent.define_method("code",      get_code);
 	cKeyEvent.define_method("modifiers", get_modifiers);
 	cKeyEvent.define_method("repeat",    get_repeat);
-	cKeyEvent.define_method("capture?",  is_capture);
+	cKeyEvent.define_method("captured?", is_captured);
 	cKeyEvent.define_const("TYPE_NONE", Reflex::KeyEvent::NONE);
 	cKeyEvent.define_const("TYPE_DOWN", Reflex::KeyEvent::DOWN);
 	cKeyEvent.define_const("TYPE_UP",   Reflex::KeyEvent::UP);

data/ext/reflex/native.cpp

@@ -17,6 +17,7 @@ void Init_frame_event ();
 void Init_scroll_event ();
 void Init_focus_event ();
 void Init_key_event ();
+void Init_pointer ();
 void Init_pointer_event ();
 void Init_wheel_event ();
 void Init_capture_event ();
@@ -63,6 +64,7 @@ extern "C" void
 	Init_scroll_event();
 	Init_focus_event();
 	Init_key_event();
+	Init_pointer();
 	Init_pointer_event();
 	Init_wheel_event();
 	Init_capture_event();