reflexion 0.1.6 → 0.1.7

data/include/reflex/defs.h

@@ -7,14 +7,6 @@
 #include <rays/defs.h>
 
 
-namespace Rucy
-{
-
-	class Value;
-
-}// Rucy
-
-
 namespace Reflex
 {
 
@@ -22,7 +14,7 @@ namespace Reflex
 	using namespace Rays;
 
 
-	enum KeyCodes
+	enum KeyCode
 	{
 
 		KEY_NONE = 0,
@@ -156,32 +148,30 @@ namespace Reflex
 		KEY_F34,
 		KEY_F35,
 
-	};// KeyCodes
+	};// KeyCode
 
 
-	enum PointTypes
+	enum PointerType
 	{
 
-		POINT_NONE         = 0,
+		POINTER_NONE         = 0,
 
-		POINT_MOUSE_LEFT   = 0x1 << 0,
+		POINTER_MOUSE_LEFT   = 0x1 << 0,
 
-		POINT_MOUSE_RIGHT  = 0x1 << 1,
+		POINTER_MOUSE_RIGHT  = 0x1 << 1,
 
-		POINT_MOUSE_MIDDLE = 0x1 << 2,
+		POINTER_MOUSE_MIDDLE = 0x1 << 2,
 
-		POINT_TOUCH        = 0x1 << 3,
+		POINTER_TOUCH        = 0x1 << 3,
 
-		MOUSE_LEFT         = POINT_MOUSE_LEFT,
+		POINTER_PEN          = 0x1 << 4,
 
-		MOUSE_RIGHT        = POINT_MOUSE_RIGHT,
+		POINTER_TYPE_LAST    = POINTER_PEN,
 
-		MOUSE_MIDDLE       = POINT_MOUSE_MIDDLE
+	};// PointType
 
-	};// PointTypes
 
-
-	enum Modifiers
+	enum Modifier
 	{
 
 		MOD_NONE     = 0,
@@ -208,73 +198,7 @@ namespace Reflex
 
 		MOD_CAPS     = 0x1 << 7,
 
-	};// Modifiers
-
-
-	struct Key
-	{
-
-		String chars;
-
-		int code;
-
-		uint modifiers;
-
-		int repeat;
-
-		Key ();
-
-		Key (
-			const char* chars, int code,
-			uint modifiers = 0, int repeat = 0);
-
-	};// Key
-
-
-	struct Points
-	{
-
-		struct Point
-		{
-
-			coord x, y;
-
-		};// Point
-
-		enum {MAX = 10};
-
-		int type;
-
-		size_t size;
-
-		uint modifiers, count;
-
-		bool drag;
-
-		union
-		{
-
-			struct {coord x, y;};
-
-			Point points[MAX];
-
-		};
-
-		Points ();
-
-		Points (
-			int type, coord x, coord y,
-			uint modifiers = 0, uint count = 1, bool drag = false);
-
-		Points (
-			int type, const Point* points, size_t size,
-			uint modifiers = 0, uint count = 1, bool drag = false);
-
-		      Point& operator [] (size_t i)       {return points[i];}
-
-		const Point& operator [] (size_t i) const {return points[i];}
-
-	};// Points
+	};// Modifier
 
 
 }// Reflex

data/include/reflex/event.h

@@ -0,0 +1,260 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_EVENT_H__
+#define __REFLEX_EVENT_H__
+
+
+#include <rays/point.h>
+#include <rays/bounds.h>
+#include <reflex/defs.h>
+
+
+namespace Rays
+{
+
+	class Painter;
+
+}// Rays
+
+
+namespace Reflex
+{
+
+
+	class View;
+
+
+	class Event
+	{
+
+		public:
+
+			struct Coord3 {coord x, y, z;};
+
+			Event ();
+
+			void block ();
+
+			bool is_blocked () const;
+
+		private:
+
+			bool blocked;
+
+	};// Event
+
+
+	struct UpdateEvent : public Event
+	{
+
+		float dt;
+
+		UpdateEvent (float dt = 0);
+
+	};// UpdateEvent
+
+
+	struct DrawEvent : public Event
+	{
+
+		View* view;
+
+		Painter* painter;
+
+		Bounds bounds;
+
+		float dt, fps;
+
+		DrawEvent (float dt = 0, float fps = 0);
+
+	};// DrawEvent
+
+
+	struct FrameEvent : public Event
+	{
+
+		Bounds frame;
+
+		coord dx, dy;
+
+		union
+		{
+			struct {coord dwidth, dheight;};
+			struct {coord dw,     dh;};
+		};
+
+		FrameEvent (const Bounds& frame = 0, coord dx = 0, coord dy = 0, coord dwidth = 0, coord dheight = 0);
+
+		bool is_move () const;
+
+		bool is_resize () const;
+
+	};// FrameEvent
+
+
+	struct ScrollEvent : public Event
+	{
+
+		union
+		{
+			struct {coord x, y, z;};
+			Coord3 scroll_;
+		};
+
+		union
+		{
+			struct {coord dx, dy, dz;};
+			Coord3 delta_;
+		};
+
+		ScrollEvent ();
+
+		ScrollEvent (coord x, coord y, coord z, coord dx, coord dy, coord dz);
+
+		      Rays::Point& scroll ();
+
+		const Rays::Point& scroll () const;
+
+		      Rays::Point& delta ();
+
+		const Rays::Point& delta () const;
+
+	};// ScrollEvent
+
+
+	struct FocusEvent : public Event
+	{
+
+		enum Type {NONE = 0, FOCUS, BLUR};
+
+		Type type;
+
+		View *focus, *last;
+
+		FocusEvent ();
+
+		FocusEvent (Type type, View* focus, View* last);
+
+	};// FocusEvent
+
+
+	struct KeyEvent : public Event
+	{
+
+		enum Type {NONE = 0, DOWN, UP};
+
+		Type type;
+
+		String chars;
+
+		int code;
+
+		uint modifiers;
+
+		int repeat;
+
+		bool capture;
+
+		KeyEvent ();
+
+		KeyEvent (
+			Type type, const char* chars, int code,
+			uint modifiers = 0, int repeat = 0);
+
+	};// KeyEvent
+
+
+	struct PointerEvent : public Event
+	{
+
+		enum Type {NONE = 0, DOWN, UP, MOVE};
+
+		enum {MAX = 10};
+
+		Type type;
+
+		uint pointer_type;
+
+		size_t size;
+
+		uint modifiers, count;
+
+		bool drag, capture;
+
+		union
+		{
+			struct {coord x, y, z;};
+			Coord3 positions[MAX];
+		};
+
+		PointerEvent ();
+
+		PointerEvent (
+			Type type, uint pointer_type, coord x, coord y,
+			uint modifiers = 0, uint count = 1, bool drag = false);
+
+		PointerEvent (
+			Type type, uint pointer_type, const Rays::Point* positions, size_t size,
+			uint modifiers = 0, uint count = 1, bool drag = false);
+
+		      Rays::Point& position (size_t i = 0);
+
+		const Rays::Point& position (size_t i = 0) const;
+
+		      Rays::Point& operator [] (size_t i);
+
+		const Rays::Point& operator [] (size_t i) const;
+
+	};// PointerEvent
+
+
+	struct WheelEvent : public Event
+	{
+
+		union
+		{
+			struct {coord dx, dy, dz;};
+			Coord3 delta_;
+		};
+
+		union
+		{
+			struct {coord x, y, z;};
+			Coord3 position_;
+		};
+
+		uint modifiers;
+
+		WheelEvent ();
+
+		WheelEvent (
+			coord dx, coord dy, coord dz, coord x = 0, coord y = 0, coord z = 0,
+			uint modifiers = 0);
+
+		      Rays::Point& delta ();
+
+		const Rays::Point& delta () const;
+
+		      Rays::Point& position ();
+
+		const Rays::Point& position () const;
+
+	};// WheelEvent
+
+
+	struct CaptureEvent : public Event
+	{
+
+		uint begin, end;
+
+		CaptureEvent ();
+
+		CaptureEvent (uint begin, uint end);
+
+	};// CaptureEvent
+
+
+}// Reflex
+
+
+#endif//EOH

data/include/reflex/exception.h

@@ -4,7 +4,7 @@
 #define __REFLEX_EXCEPTION_H__
 
 
-#include <stdexcept>
+#include <xot/exception.h>
 #include <reflex/defs.h>
 
 
@@ -12,27 +12,33 @@ namespace Reflex
 {
 
 
-	class ReflexException : public std::runtime_error
+	class ReflexError : public Xot::XotError
 	{
+		typedef Xot::XotError Super;
+		public: ReflexError (const char* str = NULL);
+	};
 
-		typedef std::runtime_error Super;
 
-		public:
+	class LayoutError : public ReflexError
+	{
+		typedef ReflexError Super;
+		public: LayoutError (const char* str = NULL);
+	};
 
-			ReflexException (const char* format = NULL, ...);
 
-			~ReflexException () throw();
+	namespace ErrorFunctions
+	{
 
-			const char* what () const throw();
+		using namespace Xot::ErrorFunctions;
 
-		private:
+		void reflex_error (const char* file, int line, const char* format = NULL, ...);
 
-			String text;
+		void layout_error (const char* file, int line, const char* format = NULL, ...);
 
-	};// ReflexException
+	}// ErrorFunctions
 
 
-	void reflex_error (const char* format = NULL, ...);
+	using namespace ErrorFunctions;
 
 
 }// Reflex

data/include/reflex/image_view.h

@@ -0,0 +1,45 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_IMAGE_VIEW_H__
+#define __REFLEX_IMAGE_VIEW_H__
+
+
+#include <xot/pimpl.h>
+#include <rays/image.h>
+#include <reflex/view.h>
+
+
+namespace Reflex
+{
+
+
+	class ImageView : public View
+	{
+
+		typedef View Super;
+
+		public:
+
+			ImageView (const char* name = NULL);
+
+			~ImageView ();
+
+			void  set_image (Image image);
+
+			Image get_image () const;
+
+			Rays::Point content_size () const;
+
+			void on_draw (DrawEvent* e);
+
+			struct Data;
+
+			Xot::PImpl<Data> self;
+
+	};// ImageView
+
+
+}// Reflex
+
+
+#endif//EOH

data/include/reflex/reflex.h

@@ -11,13 +11,9 @@ namespace Reflex
 {
 
 
-	bool init ();
+	void init ();
 
-	bool fin ();
-
-	bool run (const char* name = NULL);
-
-	bool quit ();
+	void fin ();
 
 
 }// Reflex

data/include/reflex/ruby/application.h

@@ -8,6 +8,7 @@
 #include <rucy/class.h>
 #include <rucy/extension.h>
 #include <reflex/application.h>
+#include <reflex/ruby/event.h>
 
 
 namespace Reflex
@@ -24,28 +25,40 @@ namespace Reflex
 
 		public:
 
-			virtual bool run ()
+			virtual void start ()
 			{
-				SYM(run);
-				return this->value.call(run);
+				RUCY_SYM(start);
+				this->value.call(start);
 			}
 
-			virtual bool quit ()
+			virtual void quit ()
 			{
-				SYM(quit);
-				return this->value.call(quit);
+				RUCY_SYM(quit);
+				this->value.call(quit);
 			}
 
-			virtual bool preference ()
+			virtual void on_start (Event* e)
 			{
-				SYM(preference);
-				return this->value.call(preference);
+				RUCY_SYM(on_start);
+				this->value.call(on_start, Rucy::value(e));
 			}
 
-			virtual bool about ()
+			virtual void on_quit (Event* e)
 			{
-				SYM(about);
-				return this->value.call(about);
+				RUCY_SYM(on_quit);
+				this->value.call(on_quit, Rucy::value(e));
+			}
+
+			virtual void on_preference (Event* e)
+			{
+				RUCY_SYM(on_preference);
+				this->value.call(on_preference, Rucy::value(e));
+			}
+
+			virtual void on_about (Event* e)
+			{
+				RUCY_SYM(on_about);
+				this->value.call(on_about, Rucy::value(e));
 			}
 
 	};// RubyApplication
@@ -54,7 +67,21 @@ namespace Reflex
 }// Reflex
 
 
-RUCY_WRAPPER_VALUE_FROM_TO(Reflex::Application, Reflex::application_class())
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(Reflex::Application)
+
+
+namespace Rucy
+{
+
+
+	inline Value
+	value (Reflex::Application::Ref& ref, Value klass = Reflex::application_class())
+	{
+		return value(ref.get(), klass);
+	}
+
+
+}// Rucy
 
 
 #endif//EOH

data/include/reflex/ruby/event.h

@@ -0,0 +1,72 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_RUBY_EVENT_H__
+#define __REFLEX_RUBY_EVENT_H__
+
+
+#include <rucy/rucy.h>
+#include <rucy/class.h>
+#include <rucy/extension.h>
+#include <reflex/event.h>
+
+
+namespace Reflex
+{
+
+
+	Rucy::Class event_class ();
+	// class Reflex::Event
+
+	Rucy::Class update_event_class ();
+	// class Reflex::UpdateEvent
+
+	Rucy::Class draw_event_class ();
+	// class Reflex::DrawEvent
+
+	Rucy::Class frame_event_class ();
+	// class Reflex::FrameEvent
+
+	Rucy::Class scroll_event_class ();
+	// class Reflex::ScrollEvent
+
+	Rucy::Class focus_event_class ();
+	// class Reflex::FocusEvent
+
+	Rucy::Class key_event_class ();
+	// class Reflex::KeyEvent
+
+	Rucy::Class pointer_event_class ();
+	// class Reflex::PointerEvent
+
+	Rucy::Class wheel_event_class ();
+	// class Reflex::WheelEvent
+
+	Rucy::Class capture_event_class ();
+	// class Reflex::CaptureEvent
+
+
+}// Reflex
+
+
+RUCY_DECLARE_VALUE_FROM_TO(Reflex::Event)
+
+RUCY_DECLARE_VALUE_FROM_TO(Reflex::UpdateEvent)
+
+RUCY_DECLARE_VALUE_FROM_TO(Reflex::DrawEvent)
+
+RUCY_DECLARE_VALUE_FROM_TO(Reflex::FrameEvent)
+
+RUCY_DECLARE_VALUE_FROM_TO(Reflex::ScrollEvent)
+
+RUCY_DECLARE_VALUE_FROM_TO(Reflex::FocusEvent)
+
+RUCY_DECLARE_VALUE_FROM_TO(Reflex::KeyEvent)
+
+RUCY_DECLARE_VALUE_FROM_TO(Reflex::PointerEvent)
+
+RUCY_DECLARE_VALUE_FROM_TO(Reflex::WheelEvent)
+
+RUCY_DECLARE_VALUE_FROM_TO(Reflex::CaptureEvent)
+
+
+#endif//EOH

data/include/reflex/ruby/image_view.h

@@ -0,0 +1,25 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_RUBY_IMAGE_VIEW_H__
+#define __REFLEX_RUBY_IMAGE_VIEW_H__
+
+
+#include <reflex/image_view.h>
+#include <reflex/ruby/view.h>
+
+
+namespace Reflex
+{
+
+
+	Rucy::Class image_view_class ();
+	// class Reflex::ImageView
+
+
+}// Reflex
+
+
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(Reflex::ImageView)
+
+
+#endif//EOH

data/include/reflex/ruby/selector.h

@@ -0,0 +1,27 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_RUBY_SELECTOR_H__
+#define __REFLEX_RUBY_SELECTOR_H__
+
+
+#include <rucy/rucy.h>
+#include <rucy/class.h>
+#include <rucy/extension.h>
+#include <reflex/selector.h>
+
+
+namespace Reflex
+{
+
+
+	Rucy::Class selector_class ();
+	// class Reflex::Selector
+
+
+}// Reflex
+
+
+RUCY_DECLARE_VALUE_FROM_TO(Reflex::Selector)
+
+
+#endif//EOH