reflexion 0.1.1

data/include/reflex/ruby/application.h

@@ -0,0 +1,39 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_RUBY_APPLICATION_H__
+#define __REFLEX_RUBY_APPLICATION_H__
+
+
+#include <rucy/rucy.h>
+#include <rucy/class.h>
+#include <reflex/application.h>
+
+
+namespace Reflex
+{
+
+
+	Rucy::Class application_class ();
+	// class Reflex::Application
+
+
+}// Reflex
+
+
+namespace Rucy
+{
+
+
+	Value value (const Reflex::Application& application);
+
+	template <> inline Reflex::Application*
+	value_to<Reflex::Application*> (Value obj, bool convert)
+	{
+		return get_type<Reflex::Application>(obj, Reflex::application_class());
+	}
+
+
+}// Rucy
+
+
+#endif//EOH

data/include/reflex/ruby/key.h

@@ -0,0 +1,39 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_RUBY_KEY_H__
+#define __REFLEX_RUBY_KEY_H__
+
+
+#include <rucy/rucy.h>
+#include <rucy/class.h>
+#include <reflex/defs.h>
+
+
+namespace Reflex
+{
+
+
+	Rucy::Class key_class ();
+	// class Reflex::Key
+
+
+}// Reflex
+
+
+namespace Rucy
+{
+
+
+	Value value (const Reflex::Key& key);
+
+	template <> inline Reflex::Key*
+	value_to<Reflex::Key*> (Value obj, bool convert)
+	{
+		return get_type<Reflex::Key>(obj, Reflex::key_class());
+	}
+
+
+}// Rucy
+
+
+#endif//EOH

data/include/reflex/ruby/points.h

@@ -0,0 +1,39 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_RUBY_POINTS_H__
+#define __REFLEX_RUBY_POINTS_H__
+
+
+#include <rucy/rucy.h>
+#include <rucy/class.h>
+#include <reflex/defs.h>
+
+
+namespace Reflex
+{
+
+
+	Rucy::Class points_class ();
+	// class Reflex::Points
+
+
+}// Reflex
+
+
+namespace Rucy
+{
+
+
+	Value value (const Reflex::Points& points);
+
+	template <> inline Reflex::Points*
+	value_to<Reflex::Points*> (Value obj, bool convert)
+	{
+		return get_type<Reflex::Points>(obj, Reflex::points_class());
+	}
+
+
+}// Rucy
+
+
+#endif//EOH

data/include/reflex/ruby/reflex.h

@@ -0,0 +1,21 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_RUBY_REFLEX_H__
+#define __REFLEX_RUBY_REFLEX_H__
+
+
+#include <rucy/module.h>
+
+
+namespace Reflex
+{
+
+
+	Rucy::Module reflex_module ();
+	// module Reflex
+
+
+}// Reflex
+
+
+#endif//EOH

data/include/reflex/ruby/window.h

@@ -0,0 +1,39 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_RUBY_WINDOW_H__
+#define __REFLEX_RUBY_WINDOW_H__
+
+
+#include <rucy/rucy.h>
+#include <rucy/class.h>
+#include <reflex/window.h>
+
+
+namespace Reflex
+{
+
+
+	Rucy::Class window_class ();
+	// class Reflex::Window
+
+
+}// Reflex
+
+
+namespace Rucy
+{
+
+
+	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());
+	}
+
+
+}// Rucy
+
+
+#endif//EOH

data/include/reflex/ruby.h

@@ -0,0 +1,14 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_RUBY_H__
+#define __REFLEX_RUBY_H__
+
+
+#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>
+
+
+#endif//EOH

data/include/reflex/window.h

@@ -0,0 +1,79 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_WINDOW_H__
+#define __REFLEX_WINDOW_H__
+
+
+#include <reflex/defs.h>
+#include <reflex/helpers.h>
+
+
+namespace Reflex
+{
+
+
+	class Window
+	{
+
+		public:
+
+			Window ();
+
+			virtual ~Window ();
+
+			virtual bool close ();
+
+			virtual bool show ();
+
+			virtual bool hide ();
+
+			virtual bool hidden () const;
+
+			virtual bool redraw ();
+
+			virtual bool get_title (String* title) const;
+
+			virtual bool set_title (const char* title);
+
+			virtual bool get_bounds (
+				coord* x,
+				coord* y      = NULL,
+				coord* width  = NULL,
+				coord* height = NULL);
+
+			virtual bool set_bounds (
+				coord x, coord y, coord width, coord height);
+
+			virtual void update ();
+
+			virtual void draw ();
+
+			virtual void moved (coord x, coord y);
+
+			virtual void resized (coord width, coord height);
+
+			virtual void key_down (const Key& key);
+
+			virtual void key_up (const Key& key);
+
+			virtual void points_down (const Points& points);
+
+			virtual void points_up (const Points& points);
+
+			virtual void points_moved (const Points& points);
+
+			operator bool () const;
+
+			bool operator ! () const;
+
+			struct Data;
+
+			Impl<Data> self;
+
+	};// Window
+
+
+}// Reflex
+
+
+#endif//EOH

data/include/reflex.h

@@ -0,0 +1,13 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_H__
+#define __REFLEX_H__
+
+
+#include <reflex/defs.h>
+#include <reflex/reflex.h>
+#include <reflex/window.h>
+#include <reflex/helpers.h>
+
+
+#endif//EOH

data/lib/reflex/application.rb

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+
+
+require 'reflex/native'
+require 'reflex/helpers'
+
+
+module Reflex
+
+
+  class Application
+
+    include Hookable
+    include Setter
+
+    def initialize (opts = {}, &block)
+      super
+      opts.each {|key, value| set key.intern, *value}
+      instance_eval &block if block
+    end
+
+  end# Application
+
+
+end# Reflex

data/lib/reflex/autoinit.rb

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+
+
+require 'reflex/native'
+require 'rays/autoinit'
+
+
+unless $REFLEX_NOAUTOINIT
+  Reflex.init!
+  at_exit {Reflex.fin!}
+end

data/lib/reflex/bounds.rb

@@ -0,0 +1,133 @@
+# -*- coding: utf-8 -*-
+
+
+require 'reflex/point'
+
+
+module Reflex
+
+
+  class Bounds
+
+    include Comparable
+
+    attr_accessor :x, :y, :width, :height
+
+    def initialize (*args)
+      case args.size
+      when 0 then @x = @y = @width = @height = 0
+      when 1 then @x = @y = 0; @width = @height = args[0]
+      when 2 then @x = @y = 0; @width, @height = args
+      when 4 then @x, @y, @width, @height = args
+      else raise ArgumentError
+      end
+    end
+
+    def right ()
+      @x + @width - 1
+    end
+
+    def right= (right)
+      @width = right + 1 - @x
+    end
+
+    def bottom ()
+      @y + @height - 1
+    end
+
+    def bottom= (bottom)
+      @height = bottom + 1 - @y
+    end
+
+    alias w  width
+    alias w= width=
+
+    alias h  height
+    alias h= height=
+
+    alias left  x
+    alias left= x=
+
+    alias top   y
+    alias top=  y=
+
+    alias l  left
+    alias l= left=
+
+    alias t  top
+    alias t= top=
+
+    alias r  right
+    alias r= right=
+
+    alias b  bottom
+    alias b= bottom=
+
+    def offset_to! (*args)
+      @x, @y = case args.size
+      when 1 then args * 2
+      when 2 then args
+      else raise ArgumentError
+      end
+      self
+    end
+
+    def offset_to (*args)
+      dup.offset_to! *args
+    end
+
+    def offset_by! (*args)
+      dx, dy = case args.size
+      when 1 then args * 2
+      when 2 then args
+      else raise ArgumentError
+      end
+      @x += dx
+      @y += dy
+      self
+    end
+
+    def offset_by (*args)
+      dup.offset_by! *args
+    end
+
+    def inset_by! (*args)
+      dx, dy = case args.size
+      when 1 then args * 2
+      when 2 then args
+      else raise ArgumentError
+      end
+      @x      += dx
+      @y      += dy
+      @width  -= dx * 2
+      @height -= dy * 2
+      self
+    end
+
+    def inset_by (*args)
+      dup.inset_by! *args
+    end
+
+    def to_a ()
+      [@x, @y, @width, @height]
+    end
+
+    def [] (index)
+      case index
+      when 0 then Point.new(left,  top)
+      when 1 then Point.new(right, bottom)
+      else raise IndexError
+      end
+    end
+
+    def <=> (o)
+      ret = @x    <=> o.x;     return ret if ret != 0
+      ret = @y    <=> o.y;     return ret if ret != 0
+      ret = right <=> o.right; return ret if ret != 0
+      bottom <=> o.bottom
+    end
+
+  end# Bounds
+
+
+end# Reflex

data/lib/reflex/helpers.rb

@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*-
+
+
+module Reflex
+
+
+  module Hookable
+
+    def hook (name, &hookblock)
+      klass = class << self; self; end
+      original = klass.instance_method(name).bind self
+      obj = self
+      klass.__send__ :define_method, name do |*args, &methodblock|
+        hookblock.call self, original, *args, &methodblock
+      end
+      self
+    end
+
+    def before (name, &beforeblock)
+      hook name do |obj, org, *args, &methodblock|
+        beforeblock.call(obj, *args, &methodblock)
+        org.call(*args, &methodblock)
+      end
+    end
+
+    def after (name, &afterblock)
+      hook name do |obj, org, *args, &methodblock|
+        ret = org.call(*args, &methodblock)
+        afterblock.call(obj, *args, &methodblock)
+        ret
+      end
+    end
+
+    def on (name, &onblock)
+      hook name do |obj, org, *args, &methodblock|
+        onblock.call(obj, *args, &methodblock)
+      end
+    end
+
+  end# Hookable
+
+
+  module Setter
+
+    def set (name, *value)
+      __send__ name.to_s + '=', *value
+    end
+
+  end# Setter
+
+
+end# Helpers

data/lib/reflex/module.rb

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+
+
+module Reflex
+
+
+  extend module ClassMethods
+
+    def root_dir ()
+      File.expand_path(File.join File.dirname(__FILE__), '..', '..')
+    end
+
+    def include_dirs ()
+      [File.join(root_dir, 'include')]
+    end
+
+    def library_dirs ()
+      [File.join(root_dir, 'lib')]
+    end
+
+    def version ()
+      open(File.join root_dir, 'VERSION') {|f| f.readline.chomp}
+    end
+
+    self
+
+  end# ClassMethods
+
+
+end# Reflex

data/lib/reflex/point.rb

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+
+
+module Reflex
+
+
+  class Point
+
+    include Comparable
+
+    attr_accessor :x, :y
+
+    def initialize (*args)
+      case args.size
+      when 0 then @x = @y = 0
+      when 1 then @x = @y = args[0]
+      when 2 then @x, @y = args
+      else raise ArgumentError
+      end
+    end
+
+    def offset_to! (*args)
+      case args.size
+      when 1 then @x = @y = args[0]
+      when 2 then @x, @y = args
+      else raise ArgumentError
+      end
+      self
+    end
+
+    def offset_to (*args)
+      dup.offset_to! *args
+    end
+
+    def offset_by! (*args)
+      case args.size
+      when 1 then @x += args[0]; @y += args[0]
+      when 2 then @x += args[0]; @y += args[1]
+      else raise ArgumentError
+      end
+      self
+    end
+
+    def offset_by (*args)
+      dup.offset_by! *args
+    end
+
+    def to_a ()
+      [@x, @y]
+    end
+
+    def [] (index)
+      case index
+      when 0 then @x
+      when 1 then @y
+      else raise IndexError
+      end
+    end
+
+    def <=> (o)
+      ret = @x <=> o.x
+      return ret if ret != 0
+      @y <=> o.y
+    end
+
+  end# Point
+
+
+end# Reflex

data/lib/reflex/reflex.rb

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+
+
+require 'reflex/native'
+
+
+module Reflex
+
+
+  extend module ClassMethods
+
+    def run (name = nil)
+      run! name
+    end
+
+    self
+
+  end# ClassMethods
+
+
+end# Reflex

data/lib/reflex/window.rb

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+
+
+require 'reflex/native'
+require 'reflex/bounds'
+require 'reflex/helpers'
+require 'rays/painter'
+
+
+module Reflex
+
+
+  class Window
+
+    include Hookable
+    include Setter
+
+    attr_reader :painter
+
+    def initialize (opts = {}, &block)
+      @painter = Rays::Painter.new.canvas 0, 0, 1, 1
+      opts.each {|key, value| set key.intern, *value}
+      instance_eval &block if block
+    end
+
+    def paint ()
+      @painter.begin
+      yield @painter if block_given?
+      @painter.end
+    end
+
+    def bounds (*args)
+      b = Bounds.new *get_bounds
+      b.offset_to! *args unless args.empty?
+      b
+    end
+
+    def bounds= (*args)
+      case args[0]
+      when Bounds
+        set_bounds *args[0].to_a
+      when Point
+        set_bounds *args.map{|p| p.to_a}.flatten
+      when Array
+        set_bounds *args[0]
+      when Integer, Float
+        set_bounds *args
+      end
+    end
+
+    def draw ()
+      paint
+    end
+
+    alias org_resized resized
+
+    def resized (width, height)
+      @painter.canvas 0, 0, width, height
+      org_resized width, height
+    end
+
+  end# Window
+
+
+end# Reflex

data/lib/reflex.rb

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+
+
+require 'reflex/autoinit'
+require 'reflex/module'
+require 'reflex/reflex'
+require 'reflex/point'
+require 'reflex/bounds'
+require 'reflex/application'
+require 'reflex/window'
+require 'reflex/helpers'