reflexion 0.1.6 → 0.1.7

data/include/reflex/ruby/style.h

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

data/include/reflex/ruby/style_length.h

@@ -0,0 +1,37 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_RUBY_STYLE_LENGTH_H__
+#define __REFLEX_RUBY_STYLE_LENGTH_H__
+
+
+#include <rucy/rucy.h>
+#include <rucy/class.h>
+#include <rucy/extension.h>
+#include <reflex/style.h>
+
+
+namespace Reflex
+{
+
+
+	Rucy::Class style_length_class ();
+	// class Reflex::StyleLength
+
+	Rucy::Class style_length2_class ();
+	// class Reflex::StyleLength2
+
+	Rucy::Class style_length4_class ();
+	// class Reflex::StyleLength4
+
+
+}// Reflex
+
+
+RUCY_DECLARE_VALUE_FROM_TO(Reflex::StyleLength)
+
+RUCY_DECLARE_VALUE_FROM_TO(Reflex::StyleLength2)
+
+RUCY_DECLARE_VALUE_FROM_TO(Reflex::StyleLength4)
+
+
+#endif//EOH

data/include/reflex/ruby/view.h

@@ -7,11 +7,8 @@
 #include <rucy/rucy.h>
 #include <rucy/class.h>
 #include <rucy/extension.h>
-#include <rays/ruby/bounds.h>
-#include <rays/ruby/painter.h>
 #include <reflex/view.h>
-#include <reflex/ruby/key.h>
-#include <reflex/ruby/points.h>
+#include <reflex/ruby/event.h>
 
 
 namespace Reflex
@@ -28,70 +25,214 @@ namespace Reflex
 
 		public:
 
-			virtual bool show ()
+			RUCY_OVERRIDE_BEGIN(Rucy::ClassWrapper<T>)
+
+			RUCY_OVERRIDE_ID(content_size)
+			RUCY_OVERRIDE_ID(on_attach)
+			RUCY_OVERRIDE_ID(on_detach)
+			RUCY_OVERRIDE_ID(on_update)
+			RUCY_OVERRIDE_ID(on_draw)
+			RUCY_OVERRIDE_ID(on_move)
+			RUCY_OVERRIDE_ID(on_resize)
+			RUCY_OVERRIDE_ID(on_scroll)
+			RUCY_OVERRIDE_ID(on_focus)
+			RUCY_OVERRIDE_ID(on_blur)
+			RUCY_OVERRIDE_ID(on_key)
+			RUCY_OVERRIDE_ID(on_key_down)
+			RUCY_OVERRIDE_ID(on_key_up)
+			RUCY_OVERRIDE_ID(on_pointer)
+			RUCY_OVERRIDE_ID(on_pointer_down)
+			RUCY_OVERRIDE_ID(on_pointer_up)
+			RUCY_OVERRIDE_ID(on_pointer_move)
+			RUCY_OVERRIDE_ID(on_wheel)
+			RUCY_OVERRIDE_ID(on_capture)
+
+			RUCY_OVERRIDE_END
+
+			virtual void show ()
+			{
+				RUCY_SYM(show);
+				this->value.call(show);
+			}
+
+			virtual void hide ()
+			{
+				RUCY_SYM(hide);
+				this->value.call(hide);
+			}
+
+			virtual Point content_size () const
+			{
+				RUCY_SYM(content_size);
+				if (RUCY_IS_OVERRIDDEN(content_size, view_class()))
+				{
+					Rucy::Value ret = this->value.call(content_size);
+					return ret.is_nil() ? Super::content_size() : Rucy::to<Point>(ret);
+				}
+				else
+					return Super::content_size();
+			}
+
+			virtual void on_attach (Event* e)
+			{
+				RUCY_SYM(on_attach);
+				if (RUCY_IS_OVERRIDDEN(on_attach, view_class()))
+					this->value.call(on_attach, Rucy::value(e));
+				else
+					Super::on_attach(e);
+			}
+
+			virtual void on_detach (Event* e)
+			{
+				RUCY_SYM(on_detach);
+				if (RUCY_IS_OVERRIDDEN(on_detach, view_class()))
+					this->value.call(on_detach, Rucy::value(e));
+				else
+					Super::on_detach(e);
+			}
+
+			virtual void on_update (UpdateEvent* e)
+			{
+				RUCY_SYM(on_update);
+				if (RUCY_IS_OVERRIDDEN(on_update, view_class()))
+					this->value.call(on_update, Rucy::value(e));
+				else
+					Super::on_update(e);
+			}
+
+			virtual void on_draw (DrawEvent* e)
 			{
-				SYM(show);
-				return this->value.call(show);
+				RUCY_SYM(on_draw);
+				if (RUCY_IS_OVERRIDDEN(on_draw, view_class()))
+					this->value.call(on_draw, Rucy::value(e));
+				else
+					Super::on_draw(e);
 			}
 
-			virtual bool hide ()
+			virtual void on_move (FrameEvent* e)
 			{
-				SYM(hide);
-				return this->value.call(hide);
+				RUCY_SYM(on_move);
+				if (RUCY_IS_OVERRIDDEN(on_move, view_class()))
+					this->value.call(on_move, Rucy::value(e));
+				else
+					Super::on_move(e);
 			}
 
-			virtual void update (float dt)
+			virtual void on_resize (FrameEvent* e)
 			{
-				SYM(update);
-				this->value.call(update, dt);
+				RUCY_SYM(on_resize);
+				if (RUCY_IS_OVERRIDDEN(on_resize, view_class()))
+					this->value.call(on_resize, Rucy::value(e));
+				else
+					Super::on_resize(e);
 			}
 
-			virtual void draw (Painter* p, const Bounds& b)
+			virtual void on_scroll (ScrollEvent* e)
 			{
-				SYM(draw);
-				this->value.call(draw, Rucy::value(p), Rucy::value(b));
+				RUCY_SYM(on_scroll);
+				if (RUCY_IS_OVERRIDDEN(on_scroll, view_class()))
+					this->value.call(on_scroll, Rucy::value(e));
+				else
+					Super::on_scroll(e);
 			}
 
-			virtual void moved (coord dx, coord dy)
+			virtual void on_focus (FocusEvent* e)
 			{
-				SYM(moved);
-				this->value.call(moved, dx, dy);
+				RUCY_SYM(on_focus);
+				if (RUCY_IS_OVERRIDDEN(on_focus, view_class()))
+					this->value.call(on_focus, Rucy::value(e));
+				else
+					Super::on_focus(e);
 			}
 
-			virtual void resized (coord dwidth, coord dheight)
+			virtual void on_blur (FocusEvent* e)
 			{
-				SYM(resized);
-				this->value.call(resized, dwidth, dheight);
+				RUCY_SYM(on_blur);
+				if (RUCY_IS_OVERRIDDEN(on_blur, view_class()))
+					this->value.call(on_blur, Rucy::value(e));
+				else
+					Super::on_blur(e);
 			}
 
-			virtual void key_down (const Key& key)
+			virtual void on_key (KeyEvent* e)
 			{
-				SYM(key_down);
-				this->value.call(key_down, Rucy::value(key));
+				RUCY_SYM(on_key);
+				if (RUCY_IS_OVERRIDDEN(on_key, view_class()))
+					this->value.call(on_key, Rucy::value(e));
+				else
+					Super::on_key(e);
 			}
 
-			virtual void key_up (const Key& key)
+			virtual void on_key_down (KeyEvent* e)
 			{
-				SYM(key_up);
-				this->value.call(key_up, Rucy::value(key));
+				RUCY_SYM(on_key_down);
+				if (RUCY_IS_OVERRIDDEN(on_key_down, view_class()))
+					this->value.call(on_key_down, Rucy::value(e));
+				else
+					Super::on_key_down(e);
 			}
 
-			virtual void points_down (const Points& points)
+			virtual void on_key_up (KeyEvent* e)
 			{
-				SYM(points_down);
-				this->value.call(points_down, Rucy::value(points));
+				RUCY_SYM(on_key_up);
+				if (RUCY_IS_OVERRIDDEN(on_key_up, view_class()))
+					this->value.call(on_key_up, Rucy::value(e));
+				else
+					Super::on_key_up(e);
 			}
 
-			virtual void points_up (const Points& points)
+			virtual void on_pointer (PointerEvent* e)
 			{
-				SYM(points_up);
-				this->value.call(points_up, Rucy::value(points));
+				RUCY_SYM(on_pointer);
+				if (RUCY_IS_OVERRIDDEN(on_pointer, view_class()))
+					this->value.call(on_pointer, Rucy::value(e));
+				else
+					Super::on_pointer(e);
 			}
 
-			virtual void points_moved (const Points& points)
+			virtual void on_pointer_down (PointerEvent* e)
 			{
-				SYM(points_moved);
-				this->value.call(points_moved, Rucy::value(points));
+				RUCY_SYM(on_pointer_down);
+				if (RUCY_IS_OVERRIDDEN(on_pointer_down, view_class()))
+					this->value.call(on_pointer_down, Rucy::value(e));
+				else
+					Super::on_pointer_down(e);
+			}
+
+			virtual void on_pointer_up (PointerEvent* e)
+			{
+				RUCY_SYM(on_pointer_up);
+				if (RUCY_IS_OVERRIDDEN(on_pointer_up, view_class()))
+					this->value.call(on_pointer_up, Rucy::value(e));
+				else
+					Super::on_pointer_up(e);
+			}
+
+			virtual void on_pointer_move (PointerEvent* e)
+			{
+				RUCY_SYM(on_pointer_move);
+				if (RUCY_IS_OVERRIDDEN(on_pointer_move, view_class()))
+					this->value.call(on_pointer_move, Rucy::value(e));
+				else
+					Super::on_pointer_move(e);
+			}
+
+			virtual void on_wheel (WheelEvent* e)
+			{
+				RUCY_SYM(on_wheel);
+				if (RUCY_IS_OVERRIDDEN(on_wheel, view_class()))
+					this->value.call(on_wheel, Rucy::value(e));
+				else
+					Super::on_wheel(e);
+			}
+
+			virtual void on_capture (CaptureEvent* e)
+			{
+				RUCY_SYM(on_capture);
+				if (RUCY_IS_OVERRIDDEN(on_capture, view_class()))
+					this->value.call(on_capture, Rucy::value(e));
+				else
+					Super::on_capture(e);
 			}
 
 	};// RubyView
@@ -100,7 +241,21 @@ namespace Reflex
 }// Reflex
 
 
-RUCY_WRAPPER_VALUE_FROM_TO(Reflex::View, Reflex::view_class())
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(Reflex::View)
+
+
+namespace Rucy
+{
+
+
+	inline Value
+	value (Reflex::View::Ref& ref, Value klass = Reflex::view_class())
+	{
+		return value(ref.get(), klass);
+	}
+
+
+}// Rucy
 
 
 #endif//EOH

data/include/reflex/ruby/window.h

@@ -8,8 +8,7 @@
 #include <rucy/class.h>
 #include <rucy/extension.h>
 #include <reflex/window.h>
-#include <reflex/ruby/key.h>
-#include <reflex/ruby/points.h>
+#include <reflex/ruby/event.h>
 
 
 namespace Reflex
@@ -26,76 +25,147 @@ namespace Reflex
 
 		public:
 
-			virtual bool show ()
+			RUCY_OVERRIDE_BEGIN(Rucy::ClassWrapper<T>)
+
+			RUCY_OVERRIDE_ID(on_update)
+			RUCY_OVERRIDE_ID(on_draw)
+			RUCY_OVERRIDE_ID(on_move)
+			RUCY_OVERRIDE_ID(on_resize)
+			RUCY_OVERRIDE_ID(on_key)
+			RUCY_OVERRIDE_ID(on_key_down)
+			RUCY_OVERRIDE_ID(on_key_up)
+			RUCY_OVERRIDE_ID(on_pointer)
+			RUCY_OVERRIDE_ID(on_pointer_down)
+			RUCY_OVERRIDE_ID(on_pointer_up)
+			RUCY_OVERRIDE_ID(on_pointer_move)
+			RUCY_OVERRIDE_ID(on_wheel)
+
+			RUCY_OVERRIDE_END
+
+			virtual void show ()
+			{
+				RUCY_SYM(show);
+				this->value.call(show);
+			}
+
+			virtual void hide ()
+			{
+				RUCY_SYM(hide);
+				this->value.call(hide);
+			}
+
+			virtual void close ()
+			{
+				RUCY_SYM(close);
+				this->value.call(close);
+			}
+
+			virtual void on_update (UpdateEvent* e)
 			{
-				SYM(show);
-				return this->value.call(show);
+				RUCY_SYM(on_update);
+				if (RUCY_IS_OVERRIDDEN(on_update, window_class()))
+					this->value.call(on_update, Rucy::value(e));
+				else
+					Super::on_update(e);
 			}
 
-			virtual bool hide ()
+			virtual void on_draw (DrawEvent* e)
 			{
-				SYM(hide);
-				return this->value.call(hide);
+				RUCY_SYM(on_draw);
+				if (RUCY_IS_OVERRIDDEN(on_draw, window_class()))
+					this->value.call(on_draw, Rucy::value(e));
+				else
+					Super::on_draw(e);
 			}
 
-			virtual bool close ()
+			virtual void on_move (FrameEvent* e)
 			{
-				SYM(close);
-				return this->value.call(close);
+				RUCY_SYM(on_move);
+				if (RUCY_IS_OVERRIDDEN(on_move, window_class()))
+					this->value.call(on_move, Rucy::value(e));
+				else
+					Super::on_move(e);
 			}
 
-			virtual void update (float dt)
+			virtual void on_resize (FrameEvent* e)
 			{
-				SYM(update);
-				this->value.call(update, dt);
+				RUCY_SYM(on_resize);
+				if (RUCY_IS_OVERRIDDEN(on_resize, window_class()))
+					this->value.call(on_resize, Rucy::value(e));
+				else
+					Super::on_resize(e);
 			}
 
-			virtual void draw ()
+			virtual void on_key (KeyEvent* e)
 			{
-				SYM(draw);
-				this->value.call(draw);
+				RUCY_SYM(on_key);
+				if (RUCY_IS_OVERRIDDEN(on_key, window_class()))
+					this->value.call(on_key, Rucy::value(e));
+				else
+					Super::on_key(e);
 			}
 
-			virtual void moved (coord x, coord y)
+			virtual void on_key_down (KeyEvent* e)
 			{
-				SYM(moved);
-				this->value.call(moved, x, y);
+				RUCY_SYM(on_key_down);
+				if (RUCY_IS_OVERRIDDEN(on_key_down, window_class()))
+					this->value.call(on_key_down, Rucy::value(e));
+				else
+					Super::on_key_down(e);
 			}
 
-			virtual void resized (coord width, coord height)
+			virtual void on_key_up (KeyEvent* e)
 			{
-				SYM(resized);
-				this->value.call(resized, width, height);
+				RUCY_SYM(on_key_up);
+				if (RUCY_IS_OVERRIDDEN(on_key_up, window_class()))
+					this->value.call(on_key_up, Rucy::value(e));
+				else
+					Super::on_key_up(e);
 			}
 
-			virtual void key_down (const Key& key)
+			virtual void on_pointer (PointerEvent* e)
 			{
-				SYM(key_down);
-				this->value.call(key_down, Rucy::value(key));
+				RUCY_SYM(on_pointer);
+				if (RUCY_IS_OVERRIDDEN(on_pointer, window_class()))
+					this->value.call(on_pointer, Rucy::value(e));
+				else
+					Super::on_pointer(e);
 			}
 
-			virtual void key_up (const Key& key)
+			virtual void on_pointer_down (PointerEvent* e)
 			{
-				SYM(key_up);
-				this->value.call(key_up, Rucy::value(key));
+				RUCY_SYM(on_pointer_down);
+				if (RUCY_IS_OVERRIDDEN(on_pointer_down, window_class()))
+					this->value.call(on_pointer_down, Rucy::value(e));
+				else
+					Super::on_pointer_down(e);
 			}
 
-			virtual void points_down (const Points& points)
+			virtual void on_pointer_up (PointerEvent* e)
 			{
-				SYM(points_down);
-				this->value.call(points_down, Rucy::value(points));
+				RUCY_SYM(on_pointer_up);
+				if (RUCY_IS_OVERRIDDEN(on_pointer_up, window_class()))
+					this->value.call(on_pointer_up, Rucy::value(e));
+				else
+					Super::on_pointer_up(e);
 			}
 
-			virtual void points_up (const Points& points)
+			virtual void on_pointer_move (PointerEvent* e)
 			{
-				SYM(points_up);
-				this->value.call(points_up, Rucy::value(points));
+				RUCY_SYM(on_pointer_move);
+				if (RUCY_IS_OVERRIDDEN(on_pointer_move, window_class()))
+					this->value.call(on_pointer_move, Rucy::value(e));
+				else
+					Super::on_pointer_move(e);
 			}
 
-			virtual void points_moved (const Points& points)
+			virtual void on_wheel (WheelEvent* e)
 			{
-				SYM(points_moved);
-				this->value.call(points_moved, Rucy::value(points));
+				RUCY_SYM(on_wheel);
+				if (RUCY_IS_OVERRIDDEN(on_wheel, window_class()))
+					this->value.call(on_wheel, Rucy::value(e));
+				else
+					Super::on_wheel(e);
 			}
 
 	};// RubyWindow
@@ -104,7 +174,21 @@ namespace Reflex
 }// Reflex
 
 
-RUCY_WRAPPER_VALUE_FROM_TO(Reflex::Window, Reflex::window_class())
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(Reflex::Window)
+
+
+namespace Rucy
+{
+
+
+	inline Value
+	value (Reflex::Window::Ref& ref, Value klass = Reflex::window_class())
+	{
+		return value(ref.get(), klass);
+	}
+
+
+}// Rucy
 
 
 #endif//EOH

data/include/reflex/ruby.h

@@ -5,11 +5,12 @@
 
 
 #include <reflex/ruby/reflex.h>
-#include <reflex/ruby/key.h>
-#include <reflex/ruby/points.h>
 #include <reflex/ruby/application.h>
 #include <reflex/ruby/window.h>
 #include <reflex/ruby/view.h>
+#include <reflex/ruby/selector.h>
+#include <reflex/ruby/style.h>
+#include <reflex/ruby/event.h>
 
 
 #endif//EOH

data/include/reflex/selector.h

@@ -0,0 +1,64 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_SELECTOR_H__
+#define __REFLEX_SELECTOR_H__
+
+
+#include <set>
+#include <xot/pimpl.h>
+#include <xot/string.h>
+#include <reflex/defs.h>
+
+
+namespace Reflex
+{
+
+
+	class Selector
+	{
+
+		typedef Selector This;
+
+		public:
+
+			typedef std::set<String> TagSet;
+
+			typedef TagSet::      iterator       iterator;
+
+			typedef TagSet::const_iterator const_iterator;
+
+			Selector (const char* name = NULL);
+
+			void    set_name (const char* name);
+
+			const char* name () const;
+
+			void    add_tag (const char* tag);
+
+			void remove_tag (const char* tag);
+
+			      iterator begin ();
+
+			const_iterator begin () const;
+
+			      iterator end ();
+
+			const_iterator end () const;
+
+			bool match (const This& obj) const;
+
+			friend bool operator == (const This& lhs, const This& rhs);
+
+			friend bool operator != (const This& lhs, const This& rhs);
+
+			struct Data;
+
+			Xot::PImpl<Data, true> self;
+
+	};// Selector
+
+
+}// Reflex
+
+
+#endif//EOH