reflexion 0.1.11 → 0.1.16

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.h

@@ -5,16 +5,18 @@
 
 
 #include <reflex/ruby/reflex.h>
+
 #include <reflex/ruby/selector.h>
-#include <reflex/ruby/style.h>
 #include <reflex/ruby/event.h>
-#include <reflex/ruby/body.h>
-#include <reflex/ruby/fixture.h>
+#include <reflex/ruby/timer.h>
+#include <reflex/ruby/style.h>
+#include <reflex/ruby/shape.h>
+
 #include <reflex/ruby/application.h>
 #include <reflex/ruby/window.h>
 #include <reflex/ruby/view.h>
+
 #include <reflex/ruby/image_view.h>
-#include <reflex/ruby/shape_view.h>
 
 
 #endif//EOH

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

@@ -44,9 +44,15 @@ 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
 
+	Rucy::Class motion_event_class ();
+	// class Reflex::MotionEvent
+
 
 }// Reflex
 
@@ -71,8 +77,12 @@ 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)
 
+RUCY_DECLARE_VALUE_FROM_TO(Reflex::MotionEvent)
+
 
 namespace Rucy
 {
@@ -138,12 +148,24 @@ 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> ()
 	{
 		return Reflex::contact_event_class();
 	}
 
+	template <> inline Class
+	get_ruby_class<Reflex::MotionEvent> ()
+	{
+		return Reflex::motion_event_class();
+	}
+
 
 }// Rucy
 

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/reflex.h

@@ -5,6 +5,7 @@
 
 
 #include <rucy/module.h>
+#include <reflex/reflex.h>
 
 
 namespace Reflex

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

data/include/reflex/ruby/shape.h

@@ -0,0 +1,140 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_RUBY_SHAPE_H__
+#define __REFLEX_RUBY_SHAPE_H__
+
+
+#include <rucy/rucy.h>
+#include <rucy/class.h>
+#include <rucy/extension.h>
+#include <reflex/shape.h>
+#include <reflex/ruby/event.h>
+
+
+namespace Reflex
+{
+
+
+	Rucy::Class shape_class ();
+	// class Reflex::Shape
+
+	Rucy::Class polygon_shape_class ();
+	// class Reflex::PolygonShape
+
+	Rucy::Class line_shape_class ();
+	// class Reflex::LineShape
+
+	Rucy::Class rect_shape_class ();
+	// class Reflex::RectShape
+
+	Rucy::Class ellipse_shape_class ();
+	// class Reflex::EllipseShape
+
+
+	template <typename T>
+	class RubyShape : public Rucy::ClassWrapper<T>
+	{
+
+		typedef Rucy::ClassWrapper<T> Super;
+
+		public:
+
+			virtual void on_draw (DrawEvent* e)
+			{
+				RUCY_SYM(on_draw);
+				if (this->is_overridable())
+					this->value.call(on_draw, Rucy::value(e));
+				else
+					Super::on_draw(e);
+			}
+
+			virtual void on_contact (ContactEvent* e)
+			{
+				RUCY_SYM_B(on_contact);
+				if (this->is_overridable())
+					this->value.call(on_contact, Rucy::value(e));
+				else
+					Super::on_contact(e);
+			}
+
+			virtual void on_contact_begin (ContactEvent* e)
+			{
+				RUCY_SYM_B(on_contact_begin);
+				if (this->is_overridable())
+					this->value.call(on_contact_begin, Rucy::value(e));
+				else
+					Super::on_contact_begin(e);
+			}
+
+			virtual void on_contact_end (ContactEvent* e)
+			{
+				RUCY_SYM_B(on_contact_end);
+				if (this->is_overridable())
+					this->value.call(on_contact_end, Rucy::value(e));
+				else
+					Super::on_contact_end(e);
+			}
+
+	};// RubyShape
+
+
+}// Reflex
+
+
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(Reflex::Shape)
+
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(Reflex::PolygonShape)
+
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(Reflex::LineShape)
+
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(Reflex::RectShape)
+
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(Reflex::EllipseShape)
+
+
+namespace Rucy
+{
+
+
+	template <> inline Class
+	get_ruby_class<Reflex::Shape> ()
+	{
+		return Reflex::shape_class();
+	}
+
+	template <> inline Class
+	get_ruby_class<Reflex::PolygonShape> ()
+	{
+		return Reflex::polygon_shape_class();
+	}
+
+	template <> inline Class
+	get_ruby_class<Reflex::LineShape> ()
+	{
+		return Reflex::line_shape_class();
+	}
+
+	template <> inline Class
+	get_ruby_class<Reflex::RectShape> ()
+	{
+		return Reflex::rect_shape_class();
+	}
+
+	template <> inline Class
+	get_ruby_class<Reflex::EllipseShape> ()
+	{
+		return Reflex::ellipse_shape_class();
+	}
+
+
+	inline Value
+	value (Reflex::Shape::Ref& ref, Value klass = Reflex::shape_class())
+	{
+		return value(ref.get(), klass);
+	}
+
+
+}// Rucy
+
+
+#endif//EOH

data/include/reflex/ruby/style.h

@@ -24,7 +24,7 @@ namespace Reflex
 }// Reflex
 
 
-RUCY_DECLARE_VALUE_FROM_TO(Reflex::StyleLength)
+RUCY_DECLARE_VALUE_OR_ARRAY_FROM_TO(Reflex::StyleLength)
 
 RUCY_DECLARE_VALUE_FROM_TO(Reflex::Style)