reflexion 0.1.12 → 0.1.13

data/ext/reflex/wheel_event.cpp

@@ -1,16 +1,10 @@
 #include "reflex/ruby/event.h"
 
 
-#include <rucy.h>
 #include "rays/ruby/point.h"
 #include "defs.h"
 
 
-using namespace Rucy;
-
-using Reflex::coord;
-
-
 RUCY_DEFINE_VALUE_FROM_TO(Reflex::WheelEvent)
 
 #define THIS  to<Reflex::WheelEvent*>(self)
@@ -104,22 +98,6 @@ RUCY_DEF0(modifiers)
 }
 RUCY_END
 
-static
-RUCY_DEF0(delta)
-{
-	CHECK;
-	return value(Rays::Point(THIS->dx, THIS->dy, THIS->dz));
-}
-RUCY_END
-
-static
-RUCY_DEF0(position)
-{
-	CHECK;
-	return value(Rays::Point(THIS->x, THIS->y, THIS->z));
-}
-RUCY_END
-
 
 static Class cWheelEvent;
 
@@ -130,7 +108,7 @@ Init_wheel_event ()
 
 	cWheelEvent = mReflex.define_class("WheelEvent", Reflex::event_class());
 	cWheelEvent.define_alloc_func(alloc);
-	cWheelEvent.define_private_method("initialize", initialize);
+	cWheelEvent.define_private_method("initialize",      initialize);
 	cWheelEvent.define_private_method("initialize_copy", initialize_copy);
 	cWheelEvent.define_method("dx", dx);
 	cWheelEvent.define_method("dy", dy);
@@ -139,8 +117,6 @@ Init_wheel_event ()
 	cWheelEvent.define_method("y", y);
 	cWheelEvent.define_method("z", z);
 	cWheelEvent.define_method("modifiers", modifiers);
-	cWheelEvent.define_method("delta", delta);
-	cWheelEvent.define_method("position", position);
 }
 
 

data/ext/reflex/window.cpp

@@ -1,15 +1,10 @@
 #include "reflex/ruby/window.h"
 
 
-#include <rucy.h>
 #include <rays/ruby/bounds.h>
 #include <rays/ruby/painter.h>
 #include "reflex/ruby/view.h"
-
-
-using namespace Rucy;
-
-using Reflex::coord;
+#include "defs.h"
 
 
 RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::Window)
@@ -18,7 +13,7 @@ RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::Window)
 
 #define CHECK     RUCY_CHECK_OBJECT(Reflex::Window, self)
 
-#define CALL(fun) RUCY_WRAPPER_CALL(Reflex::Window, THIS, fun)
+#define CALL(fun) RUCY_CALL_SUPER(THIS, fun)
 
 
 static
@@ -82,10 +77,11 @@ RUCY_DEF0(get_title)
 RUCY_END
 
 static
-RUCY_DEF1(set_frame, arg)
+RUCY_DEFN(set_frame)
 {
 	CHECK;
-	THIS->set_frame(to<Rays::Bounds>(arg));
+	THIS->set_frame(to<Rays::Bounds>(argc, argv));
+	return value(THIS->frame());
 }
 RUCY_END
 
@@ -253,9 +249,6 @@ RUCY_DEF1(on_wheel, event)
 }
 RUCY_END
 
-static
-RUCY_DEF_clear_override_flags(cof, Reflex::Window);
-
 
 static Class cWindow;
 
@@ -272,8 +265,8 @@ Init_window ()
 	cWindow.define_method("redraw", redraw);
 	cWindow.define_method("title=", set_title);
 	cWindow.define_method("title", get_title);
-	cWindow.define_private_method("set_frame", set_frame);
-	cWindow.define_private_method("get_frame", get_frame);
+	cWindow.define_method("frame=", set_frame);
+	cWindow.define_method("frame",  get_frame);
 	cWindow.define_method("hidden", hidden);
 	cWindow.define_method("root", root);
 	cWindow.define_method("focus", focus);
@@ -293,7 +286,6 @@ Init_window ()
 	cWindow.define_method("on_pointer_up",   on_pointer_up);
 	cWindow.define_method("on_pointer_move", on_pointer_move);
 	cWindow.define_method("on_wheel", on_wheel);
-	cWindow.define_clear_override_flags(cof);
 }
 
 

data/include/reflex/application.h

@@ -37,6 +37,8 @@ namespace Reflex
 
 			virtual void on_quit (Event* e);
 
+			virtual void on_motion (MotionEvent* e);
+
 			virtual void on_preference (Event* e);
 
 			virtual void on_about (Event* e);

data/include/reflex/debug.h

@@ -0,0 +1,22 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_DEBUG_H__
+#define __REFLEX_DEBUG_H__
+
+
+#include <xot/debug.h>
+
+
+namespace Reflex
+{
+
+
+	using Xot::dout;
+
+	using Xot::doutln;
+
+
+}// Reflex
+
+
+#endif//EOH

data/include/reflex/defs.h

@@ -7,6 +7,32 @@
 #include <rays/defs.h>
 
 
+namespace Rays
+{
+
+
+	struct Coord2;
+	struct Coord3;
+	struct Coord4;
+	struct Point;
+	struct Bounds;
+	struct Color;
+	struct Matrix;
+
+	class ColorSpace;
+	class Polyline;
+	class Polygon;
+	class Bitmap;
+	class Image;
+	class Font;
+	class Shader;
+
+	class Painter;
+
+
+}// Rays
+
+
 namespace Reflex
 {
 
@@ -15,8 +41,27 @@ namespace Reflex
 
 	using Rays::String;
 
+
 	using Rays::coord;
 
+	using Rays::Coord2;
+	using Rays::Coord3;
+	using Rays::Coord4;
+	using Rays::Point;
+	using Rays::Bounds;
+	using Rays::Color;
+	using Rays::Matrix;
+
+	using Rays::ColorSpace;
+	using Rays::Polyline;
+	using Rays::Polygon;
+	using Rays::Bitmap;
+	using Rays::Image;
+	using Rays::Font;
+	using Rays::Shader;
+
+	using Rays::Painter;
+
 
 	enum KeyCode
 	{

data/include/reflex/event.h

@@ -4,16 +4,18 @@
 #define __REFLEX_EVENT_H__
 
 
+#include <rays/point.h>
+#include <rays/bounds.h>
+#include <rays/painter.h>
 #include <reflex/defs.h>
-#include <reflex/point.h>
-#include <reflex/bounds.h>
-#include <reflex/painter.h>
+#include <reflex/timer.h>
 
 
 namespace Reflex
 {
 
 
+	class Shape;
 	class View;
 
 
@@ -35,12 +37,24 @@ namespace Reflex
 	};// Event
 
 
+	struct MotionEvent : public Event
+	{
+
+		Point gravity;
+
+		MotionEvent (const Point& gravity = Point(0, 9.8));
+
+	};// MotionEvent
+
+
 	struct UpdateEvent : public Event
 	{
 
+		double now;
+
 		float dt;
 
-		UpdateEvent (float dt = 0);
+		UpdateEvent (double now = 0, float dt = 0);
 
 	};// UpdateEvent
 
@@ -71,6 +85,7 @@ namespace Reflex
 		union
 		{
 			struct {coord dwidth, dheight;};
+
 			struct {coord dw,     dh;};
 		};
 
@@ -99,13 +114,15 @@ namespace Reflex
 		union
 		{
 			struct {coord x, y, z;};
-			Coord3 scroll_;
+
+			Rays::Coord3 scroll_;
 		};
 
 		union
 		{
 			struct {coord dx, dy, dz;};
-			Coord3 delta_;
+
+			Rays::Coord3 delta_;
 		};
 
 		ScrollEvent ();
@@ -130,11 +147,11 @@ namespace Reflex
 
 		Type type;
 
-		View *focus, *last;
+		View *current, *last;
 
 		FocusEvent ();
 
-		FocusEvent (Type type, View* focus, View* last);
+		FocusEvent (Type type, View* current, View* last);
 
 	};// FocusEvent
 
@@ -185,7 +202,8 @@ namespace Reflex
 		union
 		{
 			struct {coord x, y, z;};
-			Coord3 positions[MAX];
+
+			Rays::Coord3 positions[MAX];
 		};
 
 		PointerEvent ();
@@ -215,13 +233,15 @@ namespace Reflex
 		union
 		{
 			struct {coord dx, dy, dz;};
-			Coord3 delta_;
+
+			Rays::Coord3 delta_;
 		};
 
 		union
 		{
 			struct {coord x, y, z;};
-			Coord3 position_;
+
+			Rays::Coord3 position_;
 		};
 
 		uint modifiers;
@@ -232,14 +252,14 @@ namespace Reflex
 			coord dx, coord dy, coord dz, coord x = 0, coord y = 0, coord z = 0,
 			uint modifiers = 0);
 
-		      Point& delta ();
-
-		const Point& delta () const;
-
 		      Point& position ();
 
 		const Point& position () const;
 
+		      Point& delta ();
+
+		const Point& delta () const;
+
 	};// WheelEvent
 
 
@@ -255,6 +275,28 @@ namespace Reflex
 	};// CaptureEvent
 
 
+	struct TimerEvent : public Event
+	{
+
+		Timer::Ref timer;
+
+		TimerEvent (Timer* timer = NULL);
+
+		View* owner () const;
+
+		int id () const;
+
+		float interval () const;
+
+		void set_count (int count);
+
+		int      count () const;
+
+		bool is_finished () const;
+
+	};// TimerEvent
+
+
 	struct ContactEvent : public Event
 	{
 
@@ -262,11 +304,13 @@ namespace Reflex
 
 		Type type;
 
+		Shape* shape;
+
 		View* view;
 
 		ContactEvent ();
 
-		ContactEvent (Type type, View* view);
+		ContactEvent (Type type, Shape* shape);
 
 	};// ContactEvent
 

data/include/reflex/exception.h

@@ -26,6 +26,13 @@ namespace Reflex
 	};
 
 
+	class PhysicsError : public ReflexError
+	{
+		typedef ReflexError Super;
+		public: PhysicsError (const char* str = NULL);
+	};
+
+
 	namespace ErrorFunctions
 	{
 
@@ -35,6 +42,8 @@ namespace Reflex
 
 		void layout_error (const char* file, int line, const char* format = NULL, ...);
 
+		void physics_error (const char* file, int line, const char* format = NULL, ...);
+
 	}// ErrorFunctions
 
 

data/include/reflex/filter.h

@@ -0,0 +1,56 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_FILTER_H__
+#define __REFLEX_FILTER_H__
+
+
+#include <xot/ref.h>
+#include <xot/pimpl.h>
+#include <rays/image.h>
+#include <rays/shader.h>
+#include <rays/painter.h>
+#include <reflex/defs.h>
+
+
+namespace Reflex
+{
+
+
+	class Filter : public Xot::RefCountable<>
+	{
+
+		typedef Filter This;
+
+		public:
+
+			typedef Xot::Ref<This> Ref;
+
+			Filter ();
+
+			Filter (const Shader& shader);
+
+			virtual ~Filter ();
+
+			virtual void apply (Painter* painter, const Image& image) const;
+
+			virtual void      set_shader (const Shader& shader);
+
+			virtual       Shader& shader ();
+
+			virtual const Shader& shader () const;
+
+			virtual operator bool () const;
+
+			virtual bool operator ! () const;
+
+			struct Data;
+
+			Xot::PImpl<Data> self;
+
+	};// Filter
+
+
+}// Reflex
+
+
+#endif//EOH

data/include/reflex/image_view.h

@@ -28,7 +28,7 @@ namespace Reflex
 
 			virtual Image get_image () const;
 
-			virtual Point content_size () const;
+			virtual Bounds content_bounds () const;
 
 			virtual void on_draw (DrawEvent* e);
 

data/include/reflex/ruby/application.h

@@ -23,15 +23,14 @@ namespace Reflex
 	class RubyApplication : public Rucy::ClassWrapper<T>
 	{
 
-		public:
+		typedef Rucy::ClassWrapper<T> Super;
 
-			RUCY_OVERRIDE_BEGIN(Rucy::ClassWrapper<T>)
-			RUCY_OVERRIDE_END
+		public:
 
 			virtual void start ()
 			{
 				RUCY_SYM(start);
-				if (RUCY_IS_OVERRIDABLE())
+				if (this->is_overridable())
 					this->value.call(start);
 				else
 					return Super::start();
@@ -40,7 +39,7 @@ namespace Reflex
 			virtual void quit ()
 			{
 				RUCY_SYM(quit);
-				if (RUCY_IS_OVERRIDABLE())
+				if (this->is_overridable())
 					this->value.call(quit);
 				else
 					return Super::quit();
@@ -49,7 +48,7 @@ namespace Reflex
 			virtual void on_start (Event* e)
 			{
 				RUCY_SYM(on_start);
-				if (RUCY_IS_OVERRIDABLE())
+				if (this->is_overridable())
 					this->value.call(on_start, Rucy::value(e));
 				else
 					return Super::on_start(e);
@@ -58,16 +57,25 @@ namespace Reflex
 			virtual void on_quit (Event* e)
 			{
 				RUCY_SYM(on_quit);
-				if (RUCY_IS_OVERRIDABLE())
+				if (this->is_overridable())
 					this->value.call(on_quit, Rucy::value(e));
 				else
 					return Super::on_quit(e);
 			}
 
+			virtual void on_motion (MotionEvent* e)
+			{
+				RUCY_SYM(on_motion);
+				if (this->is_overridable())
+					this->value.call(on_motion, Rucy::value(e));
+				else
+					Super::on_motion(e);
+			}
+
 			virtual void on_preference (Event* e)
 			{
 				RUCY_SYM(on_preference);
-				if (RUCY_IS_OVERRIDABLE())
+				if (this->is_overridable())
 					this->value.call(on_preference, Rucy::value(e));
 				else
 					return Super::on_preference(e);
@@ -76,7 +84,7 @@ namespace Reflex
 			virtual void on_about (Event* e)
 			{
 				RUCY_SYM(on_about);
-				if (RUCY_IS_OVERRIDABLE())
+				if (this->is_overridable())
 					this->value.call(on_about, Rucy::value(e));
 				else
 					return Super::on_about(e);

data/include/reflex/ruby/event.h

@@ -17,6 +17,9 @@ namespace Reflex
 	Rucy::Class event_class ();
 	// class Reflex::Event
 
+	Rucy::Class motion_event_class ();
+	// class Reflex::MotionEvent
+
 	Rucy::Class update_event_class ();
 	// class Reflex::UpdateEvent
 
@@ -44,6 +47,9 @@ namespace Reflex
 	Rucy::Class capture_event_class ();
 	// class Reflex::CaptureEvent
 
+	Rucy::Class timer_event_class ();
+	// class Reflex::TimerEvent
+
 	Rucy::Class contact_event_class ();
 	// class Reflex::ContactEvent
 
@@ -53,6 +59,8 @@ namespace Reflex
 
 RUCY_DECLARE_VALUE_FROM_TO(Reflex::Event)
 
+RUCY_DECLARE_VALUE_FROM_TO(Reflex::MotionEvent)
+
 RUCY_DECLARE_VALUE_FROM_TO(Reflex::UpdateEvent)
 
 RUCY_DECLARE_VALUE_FROM_TO(Reflex::DrawEvent)
@@ -71,6 +79,8 @@ RUCY_DECLARE_VALUE_FROM_TO(Reflex::WheelEvent)
 
 RUCY_DECLARE_VALUE_FROM_TO(Reflex::CaptureEvent)
 
+RUCY_DECLARE_VALUE_FROM_TO(Reflex::TimerEvent)
+
 RUCY_DECLARE_VALUE_FROM_TO(Reflex::ContactEvent)
 
 
@@ -84,6 +94,12 @@ namespace Rucy
 		return Reflex::event_class();
 	}
 
+	template <> inline Class
+	get_ruby_class<Reflex::MotionEvent> ()
+	{
+		return Reflex::motion_event_class();
+	}
+
 	template <> inline Class
 	get_ruby_class<Reflex::UpdateEvent> ()
 	{
@@ -138,6 +154,12 @@ namespace Rucy
 		return Reflex::capture_event_class();
 	}
 
+	template <> inline Class
+	get_ruby_class<Reflex::TimerEvent> ()
+	{
+		return Reflex::timer_event_class();
+	}
+
 	template <> inline Class
 	get_ruby_class<Reflex::ContactEvent> ()
 	{

data/include/reflex/ruby/filter.h

@@ -0,0 +1,69 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_RUBY_FILTER_H__
+#define __REFLEX_RUBY_FILTER_H__
+
+
+#include <rucy/rucy.h>
+#include <rucy/class.h>
+#include <rucy/extension.h>
+#include <rays/ruby/image.h>
+#include <rays/ruby/painter.h>
+#include <reflex/filter.h>
+
+
+namespace Reflex
+{
+
+
+	Rucy::Class filter_class ();
+	// class Reflex::Filter
+
+
+	template <typename T>
+	class RubyFilter : public Rucy::ClassWrapper<T>
+	{
+
+		typedef Rucy::ClassWrapper<T> Super;
+
+		public:
+
+			virtual void apply (Painter* painter, const Image& image) const
+			{
+				RUCY_SYM(apply);
+				if (this->is_overridable())
+					this->value.call(apply, Rucy::value(painter), Rucy::value(image));
+				else
+					Super::apply(painter, image);
+			}
+
+	};// RubyFilter
+
+
+}// Reflex
+
+
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(Reflex::Filter)
+
+
+namespace Rucy
+{
+
+
+	template <> inline Class
+	get_ruby_class<Reflex::Filter> ()
+	{
+		return Reflex::filter_class();
+	}
+
+	inline Value
+	value (Reflex::Filter::Ref& ref, Value klass = Reflex::filter_class())
+	{
+		return value(ref.get(), klass);
+	}
+
+
+}// Rucy
+
+
+#endif//EOH

data/include/reflex/ruby/selector.h

@@ -21,7 +21,7 @@ namespace Reflex
 }// Reflex
 
 
-RUCY_DECLARE_VALUE_FROM_TO(Reflex::Selector)
+RUCY_DECLARE_VALUE_OR_ARRAY_FROM_TO(Reflex::Selector)
 
 
 namespace Rucy