reflexion 0.1.22 → 0.1.23

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);
 }
@@ -51,99 +48,53 @@ RUCY_DEF1(initialize_copy, obj)
 }
 RUCY_END
 
-static
-RUCY_DEF0(get_type)
-{
-	CHECK;
-	return value(THIS->type);
-}
-RUCY_END
-
-static
-RUCY_DEF0(get_pointer_type)
-{
-	CHECK;
-	return value(THIS->pointer_type);
-}
-RUCY_END
-
 static
 RUCY_DEF0(get_size)
 {
 	CHECK;
-	return value(THIS->size);
-}
-RUCY_END
-
-static
-RUCY_DEF0(get_modifiers)
-{
-	CHECK;
-	return value(THIS->modifiers);
-}
-RUCY_END
-
-static
-RUCY_DEF0(get_count)
-{
-	CHECK;
-	return value(THIS->count);
+	return value(THIS->size());
 }
 RUCY_END
 
 static
-RUCY_DEF0(is_drag)
+RUCY_DEF0(is_empty)
 {
 	CHECK;
-	return value(THIS->drag);
+	return value(THIS->empty());
 }
 RUCY_END
 
 static
-RUCY_DEF0(is_capture)
+RUCY_DEF0(is_captured)
 {
 	CHECK;
-	return value(THIS->capture);
+	return value(THIS->is_captured());
 }
 RUCY_END
 
 static
-RUCY_DEF0(get_x)
-{
-	CHECK;
-	return value(THIS->x);
-}
-RUCY_END
-
-static
-RUCY_DEF0(get_y)
+RUCY_DEF1(get_at, index)
 {
 	CHECK;
-	return value(THIS->y);
-}
-RUCY_END
 
-static
-RUCY_DEFN(get_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",         get_type);
-	cPointerEvent.define_method("pointer_type", get_pointer_type);
-	cPointerEvent.define_method("size",         get_size);
-	cPointerEvent.define_method("modifiers",    get_modifiers);
-	cPointerEvent.define_method("count",        get_count);
-	cPointerEvent.define_method("drag?",        is_drag);
-	cPointerEvent.define_method("capture?",     is_capture);
-	cPointerEvent.define_method("x",            get_x);
-	cPointerEvent.define_method("y",            get_y);
-	cPointerEvent.define_method("position",     get_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/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/view.cpp

@@ -130,6 +130,54 @@ RUCY_DEF0(update_layout)
 }
 RUCY_END
 
+static
+RUCY_DEF1(from_parent, point)
+{
+	CHECK;
+	return value(THIS->from_parent(to<Rays::Point>(point)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(to_parent, point)
+{
+	CHECK;
+	return value(THIS->to_parent(to<Rays::Point>(point)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(from_window, point)
+{
+	CHECK;
+	return value(THIS->from_window(to<Rays::Point>(point)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(to_window, point)
+{
+	CHECK;
+	return value(THIS->to_window(to<Rays::Point>(point)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(from_screen, point)
+{
+	CHECK;
+	return value(THIS->from_screen(to<Rays::Point>(point)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(to_screen, point)
+{
+	CHECK;
+	return value(THIS->to_screen(to<Rays::Point>(point)));
+}
+RUCY_END
+
 static
 RUCY_DEF1(add_child, child)
 {
@@ -1034,6 +1082,14 @@ RUCY_DEF1(on_pointer_move, event)
 }
 RUCY_END
 
+static
+RUCY_DEF1(on_pointer_cancel, event)
+{
+	CHECK;
+	CALL(on_pointer_cancel(to<Reflex::PointerEvent*>(event)));
+}
+RUCY_END
+
 static
 RUCY_DEF1(on_wheel, event)
 {
@@ -1102,6 +1158,13 @@ Init_view ()
 	cView.define_private_method("start_timer", start_timer);
 	cView.define_method("update_layout", update_layout);
 
+	cView.define_method("from_parent", from_parent);
+	cView.define_method(  "to_parent",   to_parent);
+	cView.define_method("from_window", from_window);
+	cView.define_method(  "to_window",   to_window);
+	cView.define_method("from_screen", from_screen);
+	cView.define_method(  "to_screen",   to_screen);
+
 	cView.define_method("add_child",      add_child);
 	cView.define_method("remove_child",   remove_child);
 	cView.define_method("clear_children", clear_children);
@@ -1201,9 +1264,10 @@ Init_view ()
 	cView.define_method("on_key_down", on_key_down);
 	cView.define_method("on_key_up",   on_key_up);
 	cView.define_method("on_pointer",      on_pointer);
-	cView.define_method("on_pointer_down", on_pointer_down);
-	cView.define_method("on_pointer_up",   on_pointer_up);
-	cView.define_method("on_pointer_move", on_pointer_move);
+	cView.define_method("on_pointer_down",   on_pointer_down);
+	cView.define_method("on_pointer_up",     on_pointer_up);
+	cView.define_method("on_pointer_move",   on_pointer_move);
+	cView.define_method("on_pointer_cancel", on_pointer_cancel);
 	cView.define_method("on_wheel", on_wheel);
 	cView.define_method("on_capture", on_capture);
 	cView.define_method("on_timer", on_timer);

data/ext/reflex/window.cpp

@@ -59,6 +59,22 @@ RUCY_DEF0(redraw)
 }
 RUCY_END
 
+static
+RUCY_DEF1(from_screen, point)
+{
+	CHECK;
+	return value(THIS->from_screen(to<Rays::Point>(point)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(to_screen, point)
+{
+	CHECK;
+	return value(THIS->to_screen(to<Rays::Point>(point)));
+}
+RUCY_END
+
 static
 RUCY_DEF1(set_title, title)
 {
@@ -258,6 +274,14 @@ RUCY_DEF1(on_pointer_move, event)
 }
 RUCY_END
 
+static
+RUCY_DEF1(on_pointer_cancel, event)
+{
+	CHECK;
+	CALL(on_pointer_cancel(to<Reflex::PointerEvent*>(event)));
+}
+RUCY_END
+
 static
 RUCY_DEF1(on_wheel, event)
 {
@@ -280,6 +304,8 @@ Init_window ()
 	cWindow.define_method("hide", hide);
 	cWindow.define_method("close", close);
 	cWindow.define_method("redraw", redraw);
+	cWindow.define_method("from_screen", from_screen);
+	cWindow.define_method(  "to_screen",   to_screen);
 	cWindow.define_method("title=", set_title);
 	cWindow.define_method("title", get_title);
 	cWindow.define_method("frame=", set_frame);
@@ -301,9 +327,10 @@ Init_window ()
 	cWindow.define_method("on_key_down", on_key_down);
 	cWindow.define_method("on_key_up",   on_key_up);
 	cWindow.define_method("on_pointer",      on_pointer);
-	cWindow.define_method("on_pointer_down", on_pointer_down);
-	cWindow.define_method("on_pointer_up",   on_pointer_up);
-	cWindow.define_method("on_pointer_move", on_pointer_move);
+	cWindow.define_method("on_pointer_down",   on_pointer_down);
+	cWindow.define_method("on_pointer_up",     on_pointer_up);
+	cWindow.define_method("on_pointer_move",   on_pointer_move);
+	cWindow.define_method("on_pointer_cancel", on_pointer_cancel);
 	cWindow.define_method("on_wheel", on_wheel);
 }
 

data/include/reflex/defs.h

@@ -252,24 +252,6 @@ namespace Reflex
 	};// KeyCode
 
 
-	enum PointerType
-	{
-
-		POINTER_NONE         = 0,
-
-		POINTER_MOUSE_LEFT   = 0x1 << 0,
-
-		POINTER_MOUSE_RIGHT  = 0x1 << 1,
-
-		POINTER_MOUSE_MIDDLE = 0x1 << 2,
-
-		POINTER_TOUCH        = 0x1 << 3,
-
-		POINTER_PEN          = 0x1 << 4,
-
-	};// PointType
-
-
 	enum Modifier
 	{
 

data/include/reflex/event.h

@@ -4,10 +4,12 @@
 #define __REFLEX_EVENT_H__
 
 
+#include <xot/pimpl.h>
 #include <rays/point.h>
 #include <rays/bounds.h>
 #include <rays/painter.h>
 #include <reflex/defs.h>
+#include <reflex/pointer.h>
 #include <reflex/timer.h>
 
 
@@ -30,10 +32,14 @@ namespace Reflex
 
 			bool is_blocked () const;
 
+			double time () const;
+
 		private:
 
 			bool blocked;
 
+			double time_;
+
 	};// Event
 
 
@@ -161,7 +167,7 @@ namespace Reflex
 
 		int repeat;
 
-		bool capture;
+		bool captured;
 
 		KeyEvent ();
 
@@ -172,47 +178,40 @@ namespace Reflex
 	};// KeyEvent
 
 
-	struct PointerEvent : public Event
+	class PointerEvent : public Event
 	{
 
-		enum Type {NONE = 0, DOWN, UP, MOVE};
-
-		enum {MAX = 10};
-
-		Type type;
+		typedef PointerEvent This;
 
-		uint pointer_type;
+		public:
 
-		size_t size;
+			PointerEvent (bool captured = false);
 
-		uint modifiers, count;
+			PointerEvent (
+				const Pointer& pointer,
+				bool captured = false);
 
-		bool drag, capture;
+			PointerEvent (
+				const Pointer* pointers, size_t size,
+				bool captured = false);
 
-		union
-		{
-			struct {coord x, y, z;};
+			PointerEvent (const This& obj);
 
-			Coord3 positions[MAX];
-		};
+			PointerEvent& operator = (const This& obj);
 
-		PointerEvent ();
+			~PointerEvent ();
 
-		PointerEvent (
-			Type type, uint pointer_type, coord x, coord y,
-			uint modifiers = 0, uint count = 1, bool drag = false);
+			size_t size () const;
 
-		PointerEvent (
-			Type type, uint pointer_type, const Point* positions, size_t size,
-			uint modifiers = 0, uint count = 1, bool drag = false);
+			bool empty () const;
 
-		      Point& position (size_t i = 0);
+			bool is_captured () const;
 
-		const Point& position (size_t i = 0) const;
+			const Pointer& operator [] (size_t index) const;
 
-		      Point& operator [] (size_t i);
+			struct Data;
 
-		const Point& operator [] (size_t i) const;
+			Xot::PImpl<Data> self;
 
 	};// PointerEvent