reflexion 0.1.8 → 0.1.9

data/ext/reflex/window.cpp

@@ -133,6 +133,10 @@ static
 RUCY_DEF1(on_show, event)
 {
 	CHECK;
+
+	RUCY_SYM(call_show_block);
+	self.call(call_show_block);
+
 	CALL(on_show(to<Reflex::Event*>(event)));
 }
 RUCY_END
@@ -274,7 +278,7 @@ Init_window ()
 	cWindow.define_method("root", root);
 	cWindow.define_method("focus", focus);
 	cWindow.define_method("painter", painter);
-	cWindow.define_method("on_show!", on_show);
+	cWindow.define_method("on_show",  on_show);
 	cWindow.define_method("on_hide",  on_hide);
 	cWindow.define_method("on_close", on_close);
 	cWindow.define_method("on_update", on_update);

data/include/reflex/body.h

@@ -4,6 +4,7 @@
 #define __REFLEX_BODY_H__
 
 
+#include <reflex/defs.h>
 #include <reflex/point.h>
 #include <reflex/fixture.h>
 
@@ -19,13 +20,20 @@ namespace Reflex
 
 			typedef void* Handle;
 
-			typedef FixtureIterator<      Fixture>       iterator;
+			typedef FixtureIterator<      Fixture, Fixture>       iterator;
 
-			typedef FixtureIterator<const Fixture> const_iterator;
+			typedef FixtureIterator<const Fixture, Fixture> const_iterator;
 
-			Fixture add_box (float width, float height);
+			Fixture add_box (coord width, coord height);
 
-			Fixture add_circle (float size);
+			Fixture add_ellipse (
+				coord width, coord height,
+				coord radius_min = 0, uint nsegment = 0);
+
+			Fixture add_arc (
+				coord width, coord height,
+				float angle_from = 0, float angle_to = 360,
+				coord radius_min = 0, uint nsegment = 0);
 
 			Fixture add_edge (const Point& begin, const Point& end);
 
@@ -35,24 +43,42 @@ namespace Reflex
 
 			void clear_fixtures ();
 
-			Point position () const;
-
-			float angle () const;
+			float meter2pixel (float meter = 1) const;
 
 			void set_static (bool state);
 
 			bool  is_static () const;
 
-			void set_dynamic (bool state);
+			void set_dynamic (bool state = true);
 
 			bool  is_dynamic () const;
 
+			Point position () const;
+
+			float angle () const;
+
+			void set_linear_velocity (coord x, coord y);
+
+			void set_linear_velocity (const Point& velocity);
+
+			Point    linear_velocity () const;
+
+			void set_angular_velocity (float velocity);
+
+			float    angular_velocity () const;
+
 			void set_density (float density);
 
+			float    density () const;
+
 			void set_friction (float friction);
 
+			float    friction () const;
+
 			void set_restitution (float restitution);
 
+			float    restitution () const;
+
 			      iterator begin ();
 
 			const_iterator begin () const;
@@ -63,15 +89,19 @@ namespace Reflex
 
 		protected:
 
-			Body (Handle h, float scale);
+			Body (Handle h, float pixels_per_meter);
 
 		private:
 
-			friend class World;
-
 			Handle handle;
 
-			float scale;
+			float ppm;
+
+			void set_transform (coord x, coord y, float degree);
+
+			friend class World;
+
+			friend class View;
 
 	};// Body
 

data/include/reflex/event.h

@@ -74,12 +74,22 @@ namespace Reflex
 			struct {coord dw,     dh;};
 		};
 
-		FrameEvent (const Bounds& frame = 0, coord dx = 0, coord dy = 0, coord dwidth = 0, coord dheight = 0);
+		float angle, dangle;
+
+		FrameEvent (
+			const Bounds& frame = 0, coord dx = 0, coord dy = 0, coord dwidth = 0, coord dheight = 0,
+			float angle = 0, float dangle = 0);
+
+		FrameEvent (
+			const Bounds& frame, const Bounds& prev_frame,
+			float angle = 0, float prev_angle = 0);
 
 		bool is_move () const;
 
 		bool is_resize () const;
 
+		bool is_rotate () const;
+
 	};// FrameEvent
 
 
@@ -245,6 +255,22 @@ namespace Reflex
 	};// CaptureEvent
 
 
+	struct ContactEvent : public Event
+	{
+
+		enum Type {NONE = 0, BEGIN, END};
+
+		Type type;
+
+		View* view;
+
+		ContactEvent ();
+
+		ContactEvent (Type type, View* view);
+
+	};// ContactEvent
+
+
 }// Reflex
 
 

data/include/reflex/fixture.h

@@ -53,8 +53,9 @@ namespace Reflex
 	};// Fixture
 
 
-	template <typename FIXTURE>
-	class FixtureIterator : public std::iterator<std::forward_iterator_tag, FIXTURE>
+	template <typename FIXTURE, typename RAW_FIXTURE>
+	class FixtureIterator :
+		public std::iterator<std::forward_iterator_tag, FIXTURE>
 	{
 
 		typedef FixtureIterator This;
@@ -95,17 +96,17 @@ namespace Reflex
 
 			friend bool operator == (const This& lhs, const This& rhs)
 			{
-				return lhs == rhs;
+				return lhs.fixture == rhs.fixture;
 			}
 
 			friend bool operator != (const This& lhs, const This& rhs)
 			{
-				return lhs != rhs;
+				return !(lhs == rhs);
 			}
 
 		private:
 
-			FIXTURE fixture;
+			RAW_FIXTURE fixture;
 
 	};// FixtureIterator
 

data/include/reflex/image_view.h

@@ -22,15 +22,15 @@ namespace Reflex
 
 			ImageView (const char* name = NULL);
 
-			~ImageView ();
+			virtual ~ImageView ();
 
-			void  set_image (Image image);
+			virtual void  set_image (Image image);
 
-			Image get_image () const;
+			virtual Image get_image () const;
 
-			Point content_size () const;
+			virtual Point content_size () const;
 
-			void on_draw (DrawEvent* e);
+			virtual void on_draw (DrawEvent* e);
 
 			struct Data;
 

data/include/reflex/ruby/application.h

@@ -25,40 +25,61 @@ namespace Reflex
 
 		public:
 
+			RUCY_OVERRIDE_BEGIN(Rucy::ClassWrapper<T>)
+			RUCY_OVERRIDE_END
+
 			virtual void start ()
 			{
 				RUCY_SYM(start);
-				this->value.call(start);
+				if (RUCY_IS_OVERRIDABLE())
+					this->value.call(start);
+				else
+					return Super::start();
 			}
 
 			virtual void quit ()
 			{
 				RUCY_SYM(quit);
-				this->value.call(quit);
+				if (RUCY_IS_OVERRIDABLE())
+					this->value.call(quit);
+				else
+					return Super::quit();
 			}
 
 			virtual void on_start (Event* e)
 			{
 				RUCY_SYM(on_start);
-				this->value.call(on_start, Rucy::value(e));
+				if (RUCY_IS_OVERRIDABLE())
+					this->value.call(on_start, Rucy::value(e));
+				else
+					return Super::on_start(e);
 			}
 
 			virtual void on_quit (Event* e)
 			{
 				RUCY_SYM(on_quit);
-				this->value.call(on_quit, Rucy::value(e));
+				if (RUCY_IS_OVERRIDABLE())
+					this->value.call(on_quit, Rucy::value(e));
+				else
+					return Super::on_quit(e);
 			}
 
 			virtual void on_preference (Event* e)
 			{
 				RUCY_SYM(on_preference);
-				this->value.call(on_preference, Rucy::value(e));
+				if (RUCY_IS_OVERRIDABLE())
+					this->value.call(on_preference, Rucy::value(e));
+				else
+					return Super::on_preference(e);
 			}
 
 			virtual void on_about (Event* e)
 			{
 				RUCY_SYM(on_about);
-				this->value.call(on_about, Rucy::value(e));
+				if (RUCY_IS_OVERRIDABLE())
+					this->value.call(on_about, Rucy::value(e));
+				else
+					return Super::on_about(e);
 			}
 
 	};// RubyApplication

data/include/reflex/ruby/event.h

@@ -44,6 +44,9 @@ namespace Reflex
 	Rucy::Class capture_event_class ();
 	// class Reflex::CaptureEvent
 
+	Rucy::Class contact_event_class ();
+	// class Reflex::ContactEvent
+
 
 }// Reflex
 
@@ -68,6 +71,8 @@ RUCY_DECLARE_VALUE_FROM_TO(Reflex::WheelEvent)
 
 RUCY_DECLARE_VALUE_FROM_TO(Reflex::CaptureEvent)
 
+RUCY_DECLARE_VALUE_FROM_TO(Reflex::ContactEvent)
+
 
 namespace Rucy
 {
@@ -133,6 +138,12 @@ namespace Rucy
 		return Reflex::capture_event_class();
 	}
 
+	template <> inline Class
+	get_ruby_class<Reflex::ContactEvent> ()
+	{
+		return Reflex::contact_event_class();
+	}
+
 
 }// Rucy
 

data/include/reflex/ruby/shape_view.h

@@ -0,0 +1,96 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_RUBY_SHAPE_VIEW_H__
+#define __REFLEX_RUBY_SHAPE_VIEW_H__
+
+
+#include <reflex/shape_view.h>
+#include <reflex/ruby/view.h>
+
+
+namespace Reflex
+{
+
+
+	Rucy::Class shape_view_class ();
+	// class Reflex::ShapeView
+
+	Rucy::Class rect_shape_class ();
+	// class Reflex::RectShape
+
+	Rucy::Class ellipse_shape_class ();
+	// class Reflex::EllipseShape
+
+	Rucy::Class arc_shape_class ();
+	// class Reflex::ArcShape
+
+
+	template <typename T>
+	class RubyShapeView : public RubyView<T>
+	{
+
+		public:
+
+			RUCY_OVERRIDE_BEGIN(RubyView<T>)
+
+			RUCY_OVERRIDE_ID(on_draw_shape)
+
+			RUCY_OVERRIDE_END
+
+			virtual void on_draw_shape (DrawEvent* e)
+			{
+				RUCY_SYM(on_draw_shape);
+				if (RUCY_IS_OVERRIDDEN(on_draw_shape))
+					this->value.call(on_draw_shape, Rucy::value(e));
+				else
+					Super::on_draw_shape(e);
+			}
+
+	};// RubyShapeView
+
+
+}// Reflex
+
+
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(Reflex::ShapeView)
+
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(Reflex::RectShape)
+
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(Reflex::EllipseShape)
+
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(Reflex::ArcShape)
+
+
+namespace Rucy
+{
+
+
+	template <> inline Class
+	get_ruby_class<Reflex::ShapeView> ()
+	{
+		return Reflex::shape_view_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();
+	}
+
+	template <> inline Class
+	get_ruby_class<Reflex::ArcShape> ()
+	{
+		return Reflex::arc_shape_class();
+	}
+
+
+}// Rucy
+
+
+#endif//EOH

data/include/reflex/ruby/view.h

@@ -32,6 +32,7 @@ namespace Reflex
 			RUCY_OVERRIDE_ID(on_draw)
 			RUCY_OVERRIDE_ID(on_move)
 			RUCY_OVERRIDE_ID(on_resize)
+			RUCY_OVERRIDE_ID(on_rotate)
 			RUCY_OVERRIDE_ID(on_scroll)
 			RUCY_OVERRIDE_ID(on_focus)
 			RUCY_OVERRIDE_ID(on_blur)
@@ -44,6 +45,9 @@ namespace Reflex
 			RUCY_OVERRIDE_ID(on_pointer_move)
 			RUCY_OVERRIDE_ID(on_wheel)
 			RUCY_OVERRIDE_ID(on_capture)
+			RUCY_OVERRIDE_ID(on_contact)
+			RUCY_OVERRIDE_ID(on_contact_begin)
+			RUCY_OVERRIDE_ID(on_contact_end)
 
 			RUCY_OVERRIDE_END
 
@@ -62,31 +66,46 @@ namespace Reflex
 			virtual void make_body ()
 			{
 				RUCY_SYM(make_body);
-				this->value.call(make_body);
+				if (RUCY_IS_OVERRIDABLE())
+					this->value.call(make_body);
+				else
+					Super::make_body();
 			}
 
 			virtual void on_attach (Event* e)
 			{
 				RUCY_SYM(on_attach);
-				this->value.call(on_attach, Rucy::value(e));
+				if (RUCY_IS_OVERRIDABLE())
+					this->value.call(on_attach, Rucy::value(e));
+				else
+					Super::on_attach(e);
 			}
 
 			virtual void on_detach (Event* e)
 			{
 				RUCY_SYM(on_detach);
-				this->value.call(on_detach, Rucy::value(e));
+				if (RUCY_IS_OVERRIDABLE())
+					this->value.call(on_detach, Rucy::value(e));
+				else
+					Super::on_detach(e);
 			}
 
 			virtual void on_show (Event* e)
 			{
 				RUCY_SYM(on_show);
-				this->value.call(on_show, Rucy::value(e));
+				if (RUCY_IS_OVERRIDABLE())
+					this->value.call(on_show, Rucy::value(e));
+				else
+					Super::on_show(e);
 			}
 
 			virtual void on_hide (Event* e)
 			{
 				RUCY_SYM(on_hide);
-				this->value.call(on_hide, Rucy::value(e));
+				if (RUCY_IS_OVERRIDABLE())
+					this->value.call(on_hide, Rucy::value(e));
+				else
+					Super::on_hide(e);
 			}
 
 			virtual void on_update (UpdateEvent* e)
@@ -125,6 +144,15 @@ namespace Reflex
 					Super::on_resize(e);
 			}
 
+			virtual void on_rotate (FrameEvent* e)
+			{
+				RUCY_SYM(on_rotate);
+				if (RUCY_IS_OVERRIDDEN(on_rotate))
+					this->value.call(on_rotate, Rucy::value(e));
+				else
+					Super::on_rotate(e);
+			}
+
 			virtual void on_scroll (ScrollEvent* e)
 			{
 				RUCY_SYM(on_scroll);
@@ -233,6 +261,33 @@ namespace Reflex
 					Super::on_capture(e);
 			}
 
+			virtual void on_contact (ContactEvent* e)
+			{
+				RUCY_SYM(on_contact);
+				if (RUCY_IS_OVERRIDDEN(on_contact))
+					this->value.call(on_contact, Rucy::value(e));
+				else
+					Super::on_contact(e);
+			}
+
+			virtual void on_contact_begin (ContactEvent* e)
+			{
+				RUCY_SYM(on_contact_begin);
+				if (RUCY_IS_OVERRIDDEN(on_contact_begin))
+					this->value.call(on_contact_begin, Rucy::value(e));
+				else
+					Super::on_contact_begin(e);
+			}
+
+			virtual void on_contact_end (ContactEvent* e)
+			{
+				RUCY_SYM(on_contact_end);
+				if (RUCY_IS_OVERRIDDEN(on_contact_end))
+					this->value.call(on_contact_end, Rucy::value(e));
+				else
+					Super::on_contact_end(e);
+			}
+
 	};// RubyView
 
 

data/include/reflex/ruby/window.h

@@ -45,19 +45,28 @@ namespace Reflex
 			virtual void on_show (Event* e)
 			{
 				RUCY_SYM(on_show);
-				this->value.call(on_show, Rucy::value(e));
+				if (RUCY_IS_OVERRIDABLE())
+					this->value.call(on_show, Rucy::value(e));
+				else
+					return Super::on_show(e);
 			}
 
 			virtual void on_hide (Event* e)
 			{
 				RUCY_SYM(on_hide);
-				this->value.call(on_hide, Rucy::value(e));
+				if (RUCY_IS_OVERRIDABLE())
+					this->value.call(on_hide, Rucy::value(e));
+				else
+					return Super::on_hide(e);
 			}
 
 			virtual void on_close (Event* e)
 			{
 				RUCY_SYM(on_close);
-				this->value.call(on_close, Rucy::value(e));
+				if (RUCY_IS_OVERRIDABLE())
+					this->value.call(on_close, Rucy::value(e));
+				else
+					return Super::on_close(e);
 			}
 
 			virtual void on_update (UpdateEvent* e)