reflexion 0.1.3 → 0.1.4

data/include/reflex/application.h

@@ -4,22 +4,25 @@
 #define __REFLEX_APPLICATION_H__
 
 
+#include <xot/ref.h>
+#include <xot/pimpl.h>
 #include <reflex/defs.h>
-#include <reflex/helpers.h>
 
 
 namespace Reflex
 {
 
 
-	class Application
+	class Application : public Xot::RefCountable<>
 	{
 
+		typedef Application This;
+
 		public:
 
-			Application ();
+			typedef Xot::Ref<This> Ref;
 
-			virtual ~Application ();
+			Application ();
 
 			virtual bool run ();
 
@@ -29,9 +32,9 @@ namespace Reflex
 
 			virtual bool about ();
 
-			virtual bool get_name (String* name) const;
+			virtual bool    set_name (const char* name);
 
-			virtual bool set_name (const char* name);
+			virtual const char* name () const;
 
 			operator bool () const;
 
@@ -39,7 +42,11 @@ namespace Reflex
 
 			struct Data;
 
-			Impl<Data> self;
+			Xot::PImpl<Data, true> self;
+
+		protected:
+
+			virtual ~Application ();
 
 	};// Application
 

data/include/reflex/defs.h

@@ -4,20 +4,22 @@
 #define __REFLEX_DEFS_H__
 
 
-#include <xot/defs.h>
-#include <xot/string.h>
+#include <rays/defs.h>
 
 
-namespace Reflex
+namespace Rucy
 {
 
+	class Value;
+
+}// Rucy
 
-	using namespace Xot::Types;
 
-	using Xot::String;
+namespace Reflex
+{
 
 
-	typedef float coord;
+	using namespace Rays;
 
 
 	enum KeyCodes

data/include/reflex/exception.h

@@ -32,7 +32,7 @@ namespace Reflex
 	};// ReflexException
 
 
-	void error (const char* format = NULL, ...);
+	void reflex_error (const char* format = NULL, ...);
 
 
 }// Reflex

data/include/reflex/ruby/application.h

@@ -6,6 +6,7 @@
 
 #include <rucy/rucy.h>
 #include <rucy/class.h>
+#include <rucy/extension.h>
 #include <reflex/application.h>
 
 
@@ -17,23 +18,43 @@ namespace Reflex
 	// class Reflex::Application
 
 
-}// Reflex
+	template <typename T>
+	class RubyApplication : public Rucy::ClassWrapper<T>
+	{
 
+		public:
 
-namespace Rucy
-{
+			virtual bool run ()
+			{
+				SYM(run);
+				return this->value.call(run);
+			}
 
+			virtual bool quit ()
+			{
+				SYM(quit);
+				return this->value.call(quit);
+			}
 
-	Value value (const Reflex::Application& application);
+			virtual bool preference ()
+			{
+				SYM(preference);
+				return this->value.call(preference);
+			}
 
-	template <> inline Reflex::Application*
-	value_to<Reflex::Application*> (Value obj, bool convert)
-	{
-		return get_type<Reflex::Application>(obj, Reflex::application_class());
-	}
+			virtual bool about ()
+			{
+				SYM(about);
+				return this->value.call(about);
+			}
+
+	};// RubyApplication
+
+
+}// Reflex
 
 
-}// Rucy
+RUCY_WRAPPER_VALUE_FROM_TO(Reflex::Application, Reflex::application_class())
 
 
 #endif//EOH

data/include/reflex/ruby/key.h

@@ -24,12 +24,12 @@ namespace Rucy
 {
 
 
-	Value value (const Reflex::Key& key);
+	Value value (const Reflex::Key& obj);
 
 	template <> inline Reflex::Key*
-	value_to<Reflex::Key*> (Value obj, bool convert)
+	value_to<Reflex::Key*> (Value val, bool)
 	{
-		return get_type<Reflex::Key>(obj, Reflex::key_class());
+		return get_type_ptr<Reflex::Key>(val, Reflex::key_class());
 	}
 
 

data/include/reflex/ruby/points.h

@@ -24,12 +24,12 @@ namespace Rucy
 {
 
 
-	Value value (const Reflex::Points& points);
+	Value value (const Reflex::Points& obj);
 
 	template <> inline Reflex::Points*
-	value_to<Reflex::Points*> (Value obj, bool convert)
+	value_to<Reflex::Points*> (Value val, bool)
 	{
-		return get_type<Reflex::Points>(obj, Reflex::points_class());
+		return get_type_ptr<Reflex::Points>(val, Reflex::points_class());
 	}
 
 

data/include/reflex/ruby/view.h

@@ -0,0 +1,106 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_RUBY_VIEW_H__
+#define __REFLEX_RUBY_VIEW_H__
+
+
+#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>
+
+
+namespace Reflex
+{
+
+
+	Rucy::Class view_class ();
+	// class Reflex::View
+
+
+	template <typename T>
+	class RubyView : public Rucy::ClassWrapper<T>
+	{
+
+		public:
+
+			virtual bool show ()
+			{
+				SYM(show);
+				return this->value.call(show);
+			}
+
+			virtual bool hide ()
+			{
+				SYM(hide);
+				return this->value.call(hide);
+			}
+
+			virtual void update (float dt)
+			{
+				SYM(update);
+				this->value.call(update, dt);
+			}
+
+			virtual void draw (Painter* p, const Bounds& b)
+			{
+				SYM(draw);
+				this->value.call(draw, Rucy::value(p), Rucy::value(b));
+			}
+
+			virtual void moved (coord dx, coord dy)
+			{
+				SYM(moved);
+				this->value.call(moved, dx, dy);
+			}
+
+			virtual void resized (coord dwidth, coord dheight)
+			{
+				SYM(resized);
+				this->value.call(resized, dwidth, dheight);
+			}
+
+			virtual void key_down (const Key& key)
+			{
+				SYM(key_down);
+				this->value.call(key_down, Rucy::value(key));
+			}
+
+			virtual void key_up (const Key& key)
+			{
+				SYM(key_up);
+				this->value.call(key_up, Rucy::value(key));
+			}
+
+			virtual void points_down (const Points& points)
+			{
+				SYM(points_down);
+				this->value.call(points_down, Rucy::value(points));
+			}
+
+			virtual void points_up (const Points& points)
+			{
+				SYM(points_up);
+				this->value.call(points_up, Rucy::value(points));
+			}
+
+			virtual void points_moved (const Points& points)
+			{
+				SYM(points_moved);
+				this->value.call(points_moved, Rucy::value(points));
+			}
+
+	};// RubyView
+
+
+}// Reflex
+
+
+RUCY_WRAPPER_VALUE_FROM_TO(Reflex::View, Reflex::view_class())
+
+
+#endif//EOH

data/include/reflex/ruby/window.h

@@ -6,7 +6,10 @@
 
 #include <rucy/rucy.h>
 #include <rucy/class.h>
+#include <rucy/extension.h>
 #include <reflex/window.h>
+#include <reflex/ruby/key.h>
+#include <reflex/ruby/points.h>
 
 
 namespace Reflex
@@ -17,23 +20,91 @@ namespace Reflex
 	// class Reflex::Window
 
 
-}// Reflex
-
-
-namespace Rucy
-{
+	template <typename T>
+	class RubyWindow : public Rucy::ClassWrapper<T>
+	{
 
+		public:
+
+			virtual bool show ()
+			{
+				SYM(show);
+				return this->value.call(show);
+			}
+
+			virtual bool hide ()
+			{
+				SYM(hide);
+				return this->value.call(hide);
+			}
+
+			virtual bool close ()
+			{
+				SYM(close);
+				return this->value.call(close);
+			}
+
+			virtual void update (float dt)
+			{
+				SYM(update);
+				this->value.call(update, dt);
+			}
+
+			virtual void draw ()
+			{
+				SYM(draw);
+				this->value.call(draw);
+			}
+
+			virtual void moved (coord x, coord y)
+			{
+				SYM(moved);
+				this->value.call(moved, x, y);
+			}
+
+			virtual void resized (coord width, coord height)
+			{
+				SYM(resized);
+				this->value.call(resized, width, height);
+			}
+
+			virtual void key_down (const Key& key)
+			{
+				SYM(key_down);
+				this->value.call(key_down, Rucy::value(key));
+			}
+
+			virtual void key_up (const Key& key)
+			{
+				SYM(key_up);
+				this->value.call(key_up, Rucy::value(key));
+			}
+
+			virtual void points_down (const Points& points)
+			{
+				SYM(points_down);
+				this->value.call(points_down, Rucy::value(points));
+			}
+
+			virtual void points_up (const Points& points)
+			{
+				SYM(points_up);
+				this->value.call(points_up, Rucy::value(points));
+			}
+
+			virtual void points_moved (const Points& points)
+			{
+				SYM(points_moved);
+				this->value.call(points_moved, Rucy::value(points));
+			}
+
+	};// RubyWindow
 
-	Value value (const Reflex::Window& window);
 
-	template <> inline Reflex::Window*
-	value_to<Reflex::Window*> (Value obj, bool convert)
-	{
-		return get_type<Reflex::Window>(obj, Reflex::window_class());
-	}
+}// Reflex
 
 
-}// Rucy
+RUCY_WRAPPER_VALUE_FROM_TO(Reflex::Window, Reflex::window_class())
 
 
 #endif//EOH

data/include/reflex/ruby.h

@@ -5,10 +5,11 @@
 
 
 #include <reflex/ruby/reflex.h>
-#include <reflex/ruby/application.h>
-#include <reflex/ruby/window.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>
 
 
 #endif//EOH

data/include/reflex/view.h

@@ -0,0 +1,103 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_VIEW_H__
+#define __REFLEX_VIEW_H__
+
+
+#include <vector>
+#include <xot/ref.h>
+#include <xot/pimpl.h>
+#include <reflex/defs.h>
+
+
+namespace Rays
+{
+
+	struct Bounds;
+
+	class Painter;
+
+};// Rays
+
+
+namespace Reflex
+{
+
+
+	class Window;
+
+
+	class View : public Xot::RefCountable<>
+	{
+
+		typedef View This;
+
+		public:
+
+			typedef Xot::Ref<This> Ref;
+
+			View ();
+
+			virtual bool show ();
+
+			virtual bool hide ();
+
+			virtual bool redraw ();
+
+			virtual bool add_child (View* child);
+
+			virtual bool remove_child (View* child);
+
+			virtual       View* find_child (
+				const char* name, size_t index = 0, bool recursive = false);
+
+			virtual const View* find_child (
+				const char* name, size_t index = 0, bool recursive = false) const;
+
+			virtual bool    set_name (const char* name);
+
+			virtual const char* name () const;
+
+			virtual bool      set_bounds (coord x, coord y, coord width, coord height);
+
+			virtual bool      set_bounds (const Bounds& bounds);
+
+			virtual const Bounds& bounds () const;
+
+			virtual bool hidden () const;
+
+			virtual       View* parent ();
+
+			virtual const View* parent () const;
+
+			virtual       Window* window ();
+
+			virtual const Window* window () const;
+
+			virtual void update (float dt);
+
+			virtual void draw (Painter* p, const Bounds& b);
+
+			virtual void moved (coord dx, coord dy);
+
+			virtual void resized (coord dwidth, coord dheight);
+
+			virtual operator bool () const;
+
+			virtual bool operator ! () const;
+
+			struct Data;
+
+			Xot::PImpl<Data> self;
+
+		protected:
+
+			virtual ~View ();
+
+	};// View
+
+
+}// Reflex
+
+
+#endif//EOH

data/include/reflex/window.h

@@ -4,47 +4,68 @@
 #define __REFLEX_WINDOW_H__
 
 
+#include <xot/ref.h>
+#include <xot/pimpl.h>
 #include <reflex/defs.h>
-#include <reflex/helpers.h>
+
+
+namespace Rays
+{
+
+	class Bounds;
+
+	class Painter;
+
+}// Rays
 
 
 namespace Reflex
 {
 
 
-	class Window
+	class View;
+
+
+	class Window : public Xot::RefCountable<>
 	{
 
-		public:
+		typedef Window This;
 
-			Window ();
+		public:
 
-			virtual ~Window ();
+			typedef Xot::Ref<This> Ref;
 
-			virtual bool close ();
+			Window ();
 
 			virtual bool show ();
 
 			virtual bool hide ();
 
-			virtual bool hidden () const;
+			virtual bool close ();
 
 			virtual bool redraw ();
 
-			virtual bool get_title (String* title) const;
+			virtual bool    set_title (const char* title);
+
+			virtual const char* title () const;
 
-			virtual bool set_title (const char* title);
+			virtual bool set_bounds (coord x, coord y, coord width, coord height);
 
-			virtual bool get_bounds (
-				coord* x,
-				coord* y      = NULL,
-				coord* width  = NULL,
-				coord* height = NULL);
+			virtual bool set_bounds (const Bounds& bounds);
+
+			virtual Bounds   bounds () const;
+
+			virtual bool hidden () const;
 
-			virtual bool set_bounds (
-				coord x, coord y, coord width, coord height);
+			virtual       View* root ();
 
-			virtual void update ();
+			virtual const View* root () const;
+
+			virtual       Painter* painter ();
+
+			virtual const Painter* painter () const;
+
+			virtual void update (float dt);
 
 			virtual void draw ();
 
@@ -68,7 +89,11 @@ namespace Reflex
 
 			struct Data;
 
-			Impl<Data> self;
+			Xot::PImpl<Data, true> self;
+
+		protected:
+
+			virtual ~Window ();
 
 	};// Window
 

data/include/reflex.h

@@ -7,8 +7,9 @@
 #include <reflex/defs.h>
 #include <reflex/reflex.h>
 #include <reflex/exception.h>
+#include <reflex/application.h>
 #include <reflex/window.h>
-#include <reflex/helpers.h>
+#include <reflex/view.h>
 
 
 #endif//EOH

data/lib/reflex/application.rb

@@ -1,8 +1,9 @@
 # -*- coding: utf-8 -*-
 
 
-require 'reflex/native'
-require 'reflex/helpers'
+require 'xot/hookable'
+require 'xot/setter'
+require 'reflex/ext'
 
 
 module Reflex
@@ -10,13 +11,13 @@ module Reflex
 
   class Application
 
-    include Hookable
-    include Setter
+    include Xot::Hookable
+    include Xot::Setter
 
-    def initialize (opts = {}, &block)
-      super
+    def initialize (opts = {})
+      super()
       opts.each {|key, value| set key.intern, *value}
-      instance_eval &block if block
+      yield self if block_given?
     end
 
   end# Application

data/lib/reflex/autoinit.rb

@@ -1,8 +1,8 @@
 # -*- coding: utf-8 -*-
 
 
-require 'reflex/native'
 require 'rays/autoinit'
+require 'reflex/ext'
 
 
 unless $REFLEX_NOAUTOINIT

data/lib/reflex/bitmap.rb

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+
+
+require 'rays/bitmap'
+
+
+module Reflex
+
+
+  Bitmap = Rays::Bitmap
+
+
+end# Reflex