reflexion 0.1.20 → 0.1.24

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>
 
 
@@ -26,74 +28,129 @@ namespace Reflex
 
 			Event ();
 
+			~Event ();
+
 			void block ();
 
 			bool is_blocked () const;
 
-		private:
+			double time () const;
+
+			struct Data;
 
-			bool blocked;
+			Xot::PSharedImpl<Data> self;
+
+		protected:
+
+			Event (const Event* src);
 
 	};// Event
 
 
-	struct UpdateEvent : public Event
+	class UpdateEvent : public Event
 	{
 
-		double now;
+		public:
+
+			UpdateEvent ();
+
+			UpdateEvent (double now, float dt);
+
+			UpdateEvent dup () const;
 
-		float dt;
+			double now () const;
 
-		UpdateEvent (double now = 0, float dt = 0);
+			float dt () const;
+
+			struct Data;
+
+			Xot::PSharedImpl<Data> self;
+
+		private:
+
+			UpdateEvent (const UpdateEvent* src);
 
 	};// UpdateEvent
 
 
-	struct DrawEvent : public Event
+	class DrawEvent : public Event
 	{
 
-		View* view;
+		public:
+
+			DrawEvent ();
+
+			DrawEvent (float dt, float fps);
+
+			DrawEvent dup () const;
 
-		Painter* painter;
+			      Painter* painter ();
 
-		Bounds bounds;
+			const Painter* painter () const;
 
-		float dt, fps;
+			const Bounds& bounds () const;
 
-		DrawEvent (float dt = 0, float fps = 0);
+			float dt () const;
+
+			float fps () const;
+
+			struct Data;
+
+			Xot::PSharedImpl<Data> self;
+
+		private:
+
+			DrawEvent (const DrawEvent* src);
 
 	};// DrawEvent
 
 
-	struct FrameEvent : public Event
+	class FrameEvent : public Event
 	{
 
-		Bounds frame;
+		public:
+
+			FrameEvent ();
+
+			FrameEvent (
+				const Bounds& frame,
+				coord dx,     coord dy,
+				coord dwidth, coord dheight,
+				float angle,  float dangle);
+
+			FrameEvent (
+				const Bounds& frame, const Bounds& prev_frame,
+				float angle, float prev_angle);
+
+			FrameEvent dup () const;
+
+			const Bounds& frame () const;
+
+			coord dx () const;
+
+			coord dy () const;
+
+			coord dwidth () const;
+
+			coord dheight () const;
 
-		coord dx, dy;
+			float angle () const;
 
-		union
-		{
-			struct {coord dwidth, dheight;};
+			float dangle () const;
 
-			struct {coord dw,     dh;};
-		};
+			bool is_move () const;
 
-		float angle, dangle;
+			bool is_resize () const;
 
-		FrameEvent (
-			const Bounds& frame = 0, coord dx = 0, coord dy = 0, coord dwidth = 0, coord dheight = 0,
-			float angle = 0, float dangle = 0);
+			bool is_rotate () const;
 
-		FrameEvent (
-			const Bounds& frame, const Bounds& prev_frame,
-			float angle = 0, float prev_angle = 0);
+			struct Data;
 
-		bool is_move () const;
+			Xot::PSharedImpl<Data> self;
 
-		bool is_resize () const;
+		private:
 
-		bool is_rotate () const;
+			FrameEvent (const FrameEvent* src);
 
 	};// FrameEvent
 
@@ -101,31 +158,29 @@ namespace Reflex
 	struct ScrollEvent : public Event
 	{
 
-		union
-		{
-			struct {coord x, y, z;};
+		public:
+
+			ScrollEvent ();
 
-			Coord3 scroll_;
-		};
+			ScrollEvent (coord x, coord y, coord z, coord dx, coord dy, coord dz);
 
-		union
-		{
-			struct {coord dx, dy, dz;};
+			ScrollEvent dup () const;
 
-			Coord3 delta_;
-		};
+			      Point& scroll ();
 
-		ScrollEvent ();
+			const Point& scroll () const;
 
-		ScrollEvent (coord x, coord y, coord z, coord dx, coord dy, coord dz);
+			      Point& dscroll ();
 
-		      Point& scroll ();
+			const Point& dscroll () const;
 
-		const Point& scroll () const;
+			struct Data;
 
-		      Point& delta ();
+			Xot::PSharedImpl<Data> self;
 
-		const Point& delta () const;
+		private:
+
+			ScrollEvent (const ScrollEvent* src);
 
 	};// ScrollEvent
 
@@ -133,15 +188,29 @@ namespace Reflex
 	struct FocusEvent : public Event
 	{
 
-		enum Type {NONE = 0, FOCUS, BLUR};
+		public:
+
+			enum Action {ACTION_NONE = 0, FOCUS, BLUR};
+
+			FocusEvent ();
+
+			FocusEvent (Action action, View* current, View* last);
+
+			FocusEvent dup () const;
+
+			Action action () const;
 
-		Type type;
+			View* current () const;
 
-		View *current, *last;
+			View* last () const;
 
-		FocusEvent ();
+			struct Data;
 
-		FocusEvent (Type type, View* current, View* last);
+			Xot::PSharedImpl<Data> self;
+
+		private:
+
+			FocusEvent (const FocusEvent* src);
 
 	};// FocusEvent
 
@@ -149,70 +218,67 @@ namespace Reflex
 	struct KeyEvent : public Event
 	{
 
-		enum Type {NONE = 0, DOWN, UP};
+		public:
 
-		Type type;
+			enum Action {ACTION_NONE = 0, DOWN, UP};
 
-		String chars;
+			KeyEvent ();
 
-		int code;
+			KeyEvent (
+				Action action, const char* chars, int code,
+				uint modifiers = 0, int repeat = 0);
 
-		uint modifiers;
+			KeyEvent dup () const;
 
-		int repeat;
+			Action action () const;
 
-		bool capture;
+			const char* chars () const;
 
-		KeyEvent ();
+			int code () const;
 
-		KeyEvent (
-			Type type, const char* chars, int code,
-			uint modifiers = 0, int repeat = 0);
+			uint modifiers () const;
 
-	};// KeyEvent
+			int repeat () const;
 
+			bool is_captured () const;
 
-	struct PointerEvent : public Event
-	{
+			struct Data;
 
-		enum Type {NONE = 0, DOWN, UP, MOVE};
+			Xot::PSharedImpl<Data> self;
 
-		enum {MAX = 10};
+		private:
+
+			KeyEvent (const KeyEvent* src);
 
-		Type type;
+	};// KeyEvent
 
-		uint pointer_type;
 
-		size_t size;
+	class PointerEvent : public Event
+	{
 
-		uint modifiers, count;
+		public:
 
-		bool drag, capture;
+			PointerEvent ();
 
-		union
-		{
-			struct {coord x, y, z;};
+			PointerEvent (const Pointer* pointers, size_t size);
 
-			Coord3 positions[MAX];
-		};
+			PointerEvent dup () const;
 
-		PointerEvent ();
+			size_t size () const;
 
-		PointerEvent (
-			Type type, uint pointer_type, coord x, coord y,
-			uint modifiers = 0, uint count = 1, bool drag = false);
+			bool empty () const;
 
-		PointerEvent (
-			Type type, uint pointer_type, const Point* positions, size_t size,
-			uint modifiers = 0, uint count = 1, bool drag = false);
+			bool is_captured () const;
 
-		      Point& position (size_t i = 0);
+			const Pointer& operator [] (size_t index) const;
 
-		const Point& position (size_t i = 0) const;
+			struct Data;
 
-		      Point& operator [] (size_t i);
+			Xot::PSharedImpl<Data> self;
 
-		const Point& operator [] (size_t i) const;
+		private:
+
+			PointerEvent (const PointerEvent* src);
 
 	};// PointerEvent
 
@@ -220,35 +286,33 @@ namespace Reflex
 	struct WheelEvent : public Event
 	{
 
-		union
-		{
-			struct {coord dx, dy, dz;};
+		public:
+
+			WheelEvent ();
 
-			Coord3 delta_;
-		};
+			WheelEvent (
+				coord x, coord y, coord z, coord dx, coord dy, coord dz,
+				uint modifiers = 0);
 
-		union
-		{
-			struct {coord x, y, z;};
+			WheelEvent dup () const;
 
-			Coord3 position_;
-		};
+			      Point& position ();
 
-		uint modifiers;
+			const Point& position () const;
 
-		WheelEvent ();
+			      Point& dposition ();
 
-		WheelEvent (
-			coord dx, coord dy, coord dz, coord x = 0, coord y = 0, coord z = 0,
-			uint modifiers = 0);
+			const Point& dposition () const;
 
-		      Point& position ();
+			uint modifiers () const;
 
-		const Point& position () const;
+			struct Data;
 
-		      Point& delta ();
+			Xot::PSharedImpl<Data> self;
 
-		const Point& delta () const;
+		private:
+
+			WheelEvent (const WheelEvent* src);
 
 	};// WheelEvent
 
@@ -256,11 +320,25 @@ namespace Reflex
 	struct CaptureEvent : public Event
 	{
 
-		uint begin, end;
+		public:
+
+			CaptureEvent ();
+
+			CaptureEvent (uint begin, uint end);
+
+			CaptureEvent dup () const;
+
+			uint begin () const;
+
+			uint end () const;
 
-		CaptureEvent ();
+			struct Data;
 
-		CaptureEvent (uint begin, uint end);
+			Xot::PSharedImpl<Data> self;
+
+		private:
+
+			CaptureEvent (const CaptureEvent* src);
 
 	};// CaptureEvent
 
@@ -268,21 +346,35 @@ namespace Reflex
 	struct TimerEvent : public Event
 	{
 
-		Timer::Ref timer;
+		public:
+
+			TimerEvent ();
+
+			TimerEvent (Timer* timer);
+
+			TimerEvent dup () const;
+
+			      Timer* timer ();
+
+			const Timer* timer () const;
+
+			View* owner () const;
+
+			int id () const;
 
-		TimerEvent (Timer* timer = NULL);
+			float interval () const;
 
-		View* owner () const;
+			int count () const;
 
-		int id () const;
+			bool is_finished () const;
 
-		float interval () const;
+			struct Data;
 
-		void set_count (int count);
+			Xot::PSharedImpl<Data> self;
 
-		int      count () const;
+		private:
 
-		bool is_finished () const;
+			TimerEvent (const TimerEvent* src);
 
 	};// TimerEvent
 
@@ -290,17 +382,33 @@ namespace Reflex
 	struct ContactEvent : public Event
 	{
 
-		enum Type {NONE = 0, BEGIN, END};
+		public:
+
+			enum Action {ACTION_NONE = 0, BEGIN, END};
+
+			ContactEvent ();
+
+			ContactEvent (Action action, Shape* shape);
+
+			ContactEvent dup () const;
 
-		Type type;
+			Action action () const;
 
-		Shape* shape;
+			      Shape* shape ();
 
-		View* view;
+			const Shape* shape () const;
 
-		ContactEvent ();
+			      View* view ();
+
+			const View* view () const;
+
+			struct Data;
+
+			Xot::PSharedImpl<Data> self;
+
+		private:
 
-		ContactEvent (Type type, Shape* shape);
+			ContactEvent (const ContactEvent* src);
 
 	};// ContactEvent
 

data/include/reflex/pointer.h

@@ -0,0 +1,107 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_POINTER_H__
+#define __REFLEX_POINTER_H__
+
+
+#include <xot/pimpl.h>
+#include <xot/util.h>
+#include <rays/point.h>
+#include <reflex/defs.h>
+
+
+namespace Reflex
+{
+
+
+	class Pointer
+	{
+
+		typedef Pointer This;
+
+		public:
+
+			typedef int ID;
+
+			enum Type
+			{
+
+				TYPE_NONE    = 0,
+
+				MOUSE        = Xot::bit(0),
+
+				MOUSE_LEFT   = Xot::bit(1),
+
+				MOUSE_RIGHT  = Xot::bit(2),
+
+				MOUSE_MIDDLE = Xot::bit(3),
+
+				TOUCH        = Xot::bit(4),
+
+				PEN          = Xot::bit(5),
+
+			};// Type
+
+			enum Action
+			{
+
+				ACTION_NONE = 0,
+
+				DOWN,
+
+				UP,
+
+				MOVE,
+
+				CANCEL,
+
+				STAY
+
+			};// Action
+
+			Pointer ();
+
+			Pointer (
+				ID id, uint type, Action action,
+				const Point& position, uint modifiers, uint click_count, bool drag,
+				double time);
+
+			Pointer (const This& obj);
+
+			Pointer& operator = (const This& obj);
+
+			~Pointer ();
+
+			ID id () const;
+
+			uint type () const;
+
+			Action action () const;
+
+			const Point& position () const;
+
+			uint modifiers () const;
+
+			uint click_count () const;
+
+			bool is_drag () const;
+
+			double time () const;
+
+			const Pointer* prev () const;
+
+			operator bool () const;
+
+			bool operator ! () const;
+
+			struct Data;
+
+			Xot::PImpl<Data> self;
+
+	};// Pointer
+
+
+}// Reflex
+
+
+#endif//EOH

data/include/reflex/ruby/pointer.h

@@ -0,0 +1,41 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_RUBY_POINTER_H__
+#define __REFLEX_RUBY_POINTER_H__
+
+
+#include <rucy/rucy.h>
+#include <rucy/class.h>
+#include <rucy/extension.h>
+#include <reflex/pointer.h>
+
+
+namespace Reflex
+{
+
+
+	Rucy::Class pointer_class ();
+	// class Reflex::Pointer
+
+
+}// Reflex
+
+
+RUCY_DECLARE_VALUE_FROM_TO(Reflex::Pointer)
+
+
+namespace Rucy
+{
+
+
+	template <> inline Class
+	get_ruby_class<Reflex::Pointer> ()
+	{
+		return Reflex::pointer_class();
+	}
+
+
+}// Rucy
+
+
+#endif//EOH

data/include/reflex/ruby/view.h

@@ -201,6 +201,15 @@ namespace Reflex
 					Super::on_pointer_move(e);
 			}
 
+			virtual void on_pointer_cancel (PointerEvent* e)
+			{
+				RUCY_SYM(on_pointer_cancel);
+				if (this->is_overridable())
+					this->value.call(on_pointer_cancel, Rucy::value(e));
+				else
+					Super::on_pointer_cancel(e);
+			}
+
 			virtual void on_wheel (WheelEvent* e)
 			{
 				RUCY_SYM(on_wheel);

data/include/reflex/ruby/window.h

@@ -153,6 +153,15 @@ namespace Reflex
 					Super::on_pointer_move(e);
 			}
 
+			virtual void on_pointer_cancel (PointerEvent* e)
+			{
+				RUCY_SYM(on_pointer_cancel);
+				if (this->is_overridable())
+					this->value.call(on_pointer_cancel, Rucy::value(e));
+				else
+					Super::on_pointer_cancel(e);
+			}
+
 			virtual void on_wheel (WheelEvent* e)
 			{
 				RUCY_SYM(on_wheel);

data/include/reflex/selector.h

@@ -55,7 +55,7 @@ namespace Reflex
 
 			const_iterator end () const;
 
-			bool is_empty () const;
+			bool empty () const;
 
 			friend bool operator == (const This& lhs, const This& rhs);