reflexion 0.1.2 → 0.1.3

data/.doc/ext/reflex/window.cpp

@@ -0,0 +1,343 @@
+#include "reflex/ruby/window.h"
+
+
+#include <rucy.h>
+#include <reflex/ruby/key.h>
+#include <reflex/ruby/points.h>
+#include "defs.h"
+
+
+using namespace Rucy;
+
+using Reflex::coord;
+
+
+namespace Reflex
+{
+
+
+	static Class cWindow;
+
+	Class
+	window_class ()
+	{
+		return cWindow;
+	}
+
+
+}// Reflex
+
+
+namespace Rucy
+{
+
+
+	Value
+	value (const Reflex::Window& window)
+	{
+		return new_type<Reflex::Window>(
+			Reflex::window_class(), new Reflex::Window(window));
+	}
+
+
+}// Rucy
+
+
+class RubyWindow : public Reflex::Window
+{
+
+	public:
+
+		typedef Reflex::Window Super;
+
+		Value self;
+
+		void mark ()
+		{
+			self.mark();
+		}
+
+		virtual bool close ()
+		{
+			SYM(close);
+			return self.call(close);
+		}
+
+		virtual bool show ()
+		{
+			SYM(show);
+			return self.call(show);
+		}
+
+		virtual bool hide ()
+		{
+			SYM(hide);
+			return self.call(hide);
+		}
+
+		virtual void update ()
+		{
+			SYM(update);
+			self.call(update);
+		}
+
+		virtual void draw ()
+		{
+			SYM(draw);
+			self.call(draw);
+		}
+
+		virtual void moved (coord x, coord y)
+		{
+			SYM(moved);
+			self.call(moved, x, y);
+		}
+
+		virtual void resized (coord width, coord height)
+		{
+			SYM(resized);
+			self.call(resized, width, height);
+		}
+
+		virtual void key_down (const Reflex::Key& key)
+		{
+			SYM(key_down);
+			self.call(key_down, value(key));
+		}
+
+		virtual void key_up (const Reflex::Key& key)
+		{
+			SYM(key_up);
+			self.call(key_up, value(key));
+		}
+
+		virtual void points_down (const Reflex::Points& points)
+		{
+			SYM(points_down);
+			self.call(points_down, value(points));
+		}
+
+		virtual void points_up (const Reflex::Points& points)
+		{
+			SYM(points_up);
+			self.call(points_up, value(points));
+		}
+
+		virtual void points_moved (const Reflex::Points& points)
+		{
+			SYM(points_moved);
+			self.call(points_moved, value(points));
+		}
+
+};// RubyWindow
+
+
+#define this ((RubyWindow*) to<Reflex::Window*>(self))
+
+#define CHECK CHECK_OBJECT(self, RubyWindow, Reflex::window_class())
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	RubyWindow* win = new RubyWindow;
+	return win->self = new_type<RubyWindow>(klass, win, mark_type<RubyWindow>);
+}
+
+static
+VALUE close(VALUE self)
+{
+	CHECK;
+	if (!this->Super::close())
+		system_error("failed to close window.");
+	return self;
+}
+
+static
+VALUE show(VALUE self)
+{
+	CHECK;
+	if (!this->Super::show())
+		system_error("failed to show window.");
+	return self;
+}
+
+static
+VALUE hide(VALUE self)
+{
+	CHECK;
+	if (!this->Super::hide())
+		system_error("failed to hide window.");
+	return self;
+}
+
+static
+VALUE hidden(VALUE self)
+{
+	CHECK;
+	return value(this->hidden());
+}
+
+static
+VALUE update(VALUE self)
+{
+	CHECK;
+	this->Super::update();
+	return self;
+}
+
+static
+VALUE draw(VALUE self)
+{
+	CHECK;
+	this->Super::draw();
+	return self;
+}
+
+static
+VALUE redraw(VALUE self)
+{
+	CHECK;
+	if (!this->Super::redraw())
+		system_error("failed to redraw window.");
+	return self;
+}
+
+static
+VALUE get_title(VALUE self)
+{
+	CHECK;
+	String s;
+	if (!this->get_title(&s))
+		system_error("failed to get title of window.");
+	return value(s.c_str());
+}
+
+static
+VALUE set_title(VALUE self, VALUE title)
+{
+	CHECK;
+	if (!this->set_title(title.c_str()))
+		system_error("failed to set title of window.");
+	return title;
+}
+
+static
+VALUE get_bounds(VALUE self)
+{
+	CHECK;
+	coord x = 0, y = 0, width = 0, height = 0;
+	if (!this->get_bounds(&x, &y, &width, &height))
+		system_error("failed to get bounds of window.");
+	Value ret[] = {x, y, width, height};
+	return value(4, ret);
+}
+
+static
+VALUE set_bounds(VALUE self, VALUE x, VALUE y, VALUE width, VALUE height)
+{
+	CHECK;
+	if (!this->set_bounds(
+		to<coord>(x), to<coord>(y), to<coord>(width), to<coord>(height)))
+	{
+		system_error("failed to set bounds of window.");
+	}
+	Value ret[] = {x, y, width, height};
+	return value(4, ret);
+}
+
+static
+VALUE moved(VALUE self, VALUE x, VALUE y)
+{
+	CHECK;
+	this->Super::moved(to<coord>(x), to<coord>(y));
+	return self;
+}
+
+static
+VALUE resized(VALUE self, VALUE width, VALUE height)
+{
+	CHECK;
+	this->Super::resized(to<coord>(width), to<coord>(height));
+	return self;
+}
+
+static
+VALUE key_down(VALUE self, VALUE key)
+{
+	CHECK;
+	Reflex::Key* k = to<Reflex::Key*>(key);
+	if (!k) argument_error();
+	this->Super::key_down(*k);
+	return self;
+}
+
+static
+VALUE key_up(VALUE self, VALUE key)
+{
+	CHECK;
+	Reflex::Key* k = to<Reflex::Key*>(key);
+	if (!k) argument_error();
+	this->Super::key_up(*k);
+	return self;
+}
+
+static
+VALUE points_down(VALUE self, VALUE points)
+{
+	CHECK;
+	Reflex::Points* p = to<Reflex::Points*>(points);
+	if (!p) argument_error();
+	this->Super::points_down(*p);
+	return self;
+}
+
+static
+VALUE points_up(VALUE self, VALUE points)
+{
+	CHECK;
+	Reflex::Points* p = to<Reflex::Points*>(points);
+	if (!p) argument_error();
+	this->Super::points_up(*p);
+	return self;
+}
+
+static
+VALUE points_moved(VALUE self, VALUE points)
+{
+	CHECK;
+	Reflex::Points* p = to<Reflex::Points*>(points);
+	if (!p) argument_error();
+	this->Super::points_moved(*p);
+	return self;
+}
+
+
+void
+Init_window ()
+{
+	Module m = rb_define_module("Reflex");
+
+	Class c = rb_define_class_under(m, "Window", rb_cObject);
+	Reflex::cWindow = c;
+
+	rb_define_alloc_func(c, alloc);
+	rb_define_method(c, "close", RUBY_METHOD_FUNC(close), 0);
+	rb_define_method(c, "show", RUBY_METHOD_FUNC(show), 0);
+	rb_define_method(c, "hide", RUBY_METHOD_FUNC(hide), 0);
+	rb_define_method(c, "hidden", RUBY_METHOD_FUNC(hidden), 0);
+	rb_define_method(c, "update", RUBY_METHOD_FUNC(update), 0);
+	rb_define_method(c, "draw", RUBY_METHOD_FUNC(draw), 0);
+	rb_define_method(c, "redraw", RUBY_METHOD_FUNC(redraw), 0);
+	rb_define_method(c, "title", RUBY_METHOD_FUNC(get_title), 0);
+	rb_define_method(c, "title=", RUBY_METHOD_FUNC(set_title), 1);
+	rb_define_private_method(c, "get_bounds", RUBY_METHOD_FUNC(get_bounds), 0);
+	rb_define_private_method(c, "set_bounds", RUBY_METHOD_FUNC(set_bounds), 4);
+	rb_define_method(c, "moved", RUBY_METHOD_FUNC(moved), 2);
+	rb_define_method(c, "resized", RUBY_METHOD_FUNC(resized), 2);
+	rb_define_method(c, "key_down", RUBY_METHOD_FUNC(key_down), 1);
+	rb_define_method(c, "key_up", RUBY_METHOD_FUNC(key_up), 1);
+	rb_define_method(c, "points_down", RUBY_METHOD_FUNC(points_down), 1);
+	rb_define_method(c, "points_up", RUBY_METHOD_FUNC(points_up), 1);
+	rb_define_method(c, "points_moved", RUBY_METHOD_FUNC(points_moved), 1);
+}

data/Rakefile

@@ -1,48 +1,23 @@
 # -*- mode: ruby; coding: utf-8 -*-
 
 
-%w[. ./lib ../rucy/lib ../rays/lib].each do |path|
+%w[. ../xot ../rucy ../rays].map {|s| "#{s}/lib"}.each do |path|
   $: << File.expand_path(File.join File.dirname(__FILE__), *path.split('/'))
 end
 
 require 'rubygems'
-require 'rbconfig'
-require 'support'
+require 'xot/rake/helpers'
+require 'xot/module'
+require 'rucy/module'
 require 'rays/module'
 require 'reflex/module'
 
+include Xot::Rake
 
-MODULE = Reflex
-NAME   = MODULE.name.downcase
 
-SRCDIR  = 'src'
-INCDIR  = 'include'
-LIBDIR  = 'lib'
-EXTDIR  = 'ext'
-TASKDIR = 'task'
-
-EXTEXT = RbConfig::CONFIG['DLEXT'] || 'so'
-
-DEFS  = %w[]
-DEFS << 'WIN32' if win32?
-DEFS << 'COCOA' if cocoa?
-
-incroot = RbConfig::CONFIG['rubyhdrdir']
-INCDIRS = Reflex.include_dirs + Rays.include_dirs + [
-  incroot,
-  "#{incroot}/#{RUBY_PLATFORM}",
-  '/opt/local/include',
-  '/opt/include'
-]
-
-RUBY    = ENV['RUBY'] || 'ruby'
-GEM     = ENV['GEM']  || 'gem'
-GIT     = ENV['GIT']  || 'git'
-MAKE    = ENV['MAKE'] || 'make'
-CC      = RbConfig::CONFIG['CC'] || ENV['CC'] || 'g++'
-CFLAGS  = '-Wall -O' + DEFS.map{|s| " -D#{s}"}.join
-AR      = ENV['AR'] || 'ar'
-ARFLAGS = 'crs'
+MODULE  = Reflex
+GEMNAME = 'reflexion'
+INCDIRS = [Reflex, Rays, Rucy].map {|m| m.include_dirs}.flatten
 
 
 task :default => :build
@@ -55,6 +30,8 @@ task :lib => 'lib:build'
 
 task :ext => 'ext:build'
 
+task :doc => 'ext:doc'
+
 task :gem => 'gem:build'
 
 task :install => 'gem:install'
@@ -70,4 +47,4 @@ task :test => :ext do
 end
 
 
-Dir["#{TASKDIR}/**/*.rake"].each {|path| load path}
+[Xot, Rucy, Rays, Reflex].each {|m| m.load_tasks}

data/VERSION

@@ -1 +1 @@
-0.1.2
+0.1.3

data/ext/reflex/application.cpp

@@ -2,7 +2,7 @@
 
 
 #include <rucy.h>
-#include "reflex.h"
+#include "defs.h"
 
 
 using namespace Rucy;
@@ -12,11 +12,12 @@ namespace Reflex
 {
 
 
+	static Class cApplication;
+
 	Class
 	application_class ()
 	{
-		static Class c = reflex_module().define_class("Application");
-		return c;
+		return cApplication;
 	}
 
 
@@ -141,11 +142,15 @@ RUBY_END
 void
 Init_application ()
 {
-	Reflex::application_class()
-		.define_alloc_func(alloc)
-		.define_method("run", run)
-		.define_method("quit", quit)
-		.define_method("about", about)
-		.define_method("name",  get_name)
-		.define_method("name=", set_name);
+	Module m = define_module("Reflex");
+
+	Class c = m.define_class("Application");
+	Reflex::cApplication = c;
+
+	c.define_alloc_func(alloc);
+	c.define_method("run", run);
+	c.define_method("quit", quit);
+	c.define_method("about", about);
+	c.define_method("name",  get_name);
+	c.define_method("name=", set_name);
 }

data/ext/reflex/{reflex.h → defs.h}

@@ -1,22 +1,13 @@
 // -*- c++ -*-
 #pragma once
-#ifndef __REFLEX_EXT_REFLEX_H__
-#define __REFLEX_EXT_REFLEX_H__
+#ifndef __REFLEX_EXT_DEFS_H__
+#define __REFLEX_EXT_DEFS_H__
 
 
-#include <rucy/class.h>
-#include "reflex/ruby/reflex.h"
+#include <reflex/exception.h>
 
 
-namespace Reflex
-{
-
-
-	Rucy::Class reflex_error_class ();
-	// class Reflex::ReflexError < Rucy::NativeError
-
-
-}// Reflex
+using Reflex::error;
 
 
 #define CHECK_OBJ(obj, type, klass) \

data/ext/reflex/extconf.rb

@@ -1,41 +1,52 @@
 # -*- coding: utf-8 -*-
 
 
-%w[../../../rucy/lib ../../lib].each do |path|
+%w[. ../xot ../rucy].map {|s| "../../#{s}/lib"}.each do |path|
   $: << File.expand_path(File.join File.dirname(__FILE__), *path.split('/'))
 end
 
 require 'rubygems'
 require 'mkmf'
+require 'xot/rake/helpers'
+require 'xot/module'
 require 'rucy/module'
 require 'reflex/module'
 
+include Xot::Rake
 
-DEBUG = ENV['DEBUG'] || false
+
+DEBUG = env :DEBUG, false
 
 DEFS    = []
-INCDIRS = %w[/opt/local/include /opt/include] +
-  Rucy.include_dirs + Reflex.include_dirs
-LIBDIRS = %w[] +
-  Rucy.library_dirs + Reflex.library_dirs
+INCDIRS = %w[
+  /opt/local/include
+  /opt/include
+]
+LIBDIRS = []
 
 HEADERS    = %w[
   boost/shared_ptr.hpp
+  boost/scoped_array.hpp
   ruby.h
+  xot.h
   rucy.h
   reflex.h
 ]
-LIBS       = %w[stdc++ rucy reflex]
-FRAMEWORKS = %w[]
+LIBS = %w[
+  stdc++
+  xot
+  rucy
+  reflex
+]
+FRAMEWORKS = []
 
 
 DEFS << '_DEBUG' if DEBUG
-
-case RUBY_PLATFORM
-when /mswin|ming|cygwin/
-  DEFS << 'WINDOWS' << 'WIN32' << $~[0].upcase
+DEFS << $~[0].upcase if RUBY_PLATFORM =~ /mswin|ming|cygwin|darwin/i
+if win32?
+  DEFS << 'WINDOWS' << 'WIN32'
   LIBS.unshift 'gdi32', 'opengl32'
-when /darwin/
+elsif cocoa?
   DEFS << 'COCOA'
   FRAMEWORKS << 'Cocoa'# << 'OpenGL'
 end
@@ -46,12 +57,13 @@ $LDFLAGS    << LIBDIRS.map    {|s| " -L#{s}"}.join
 $LDFLAGS    << FRAMEWORKS.map {|s| " -framework #{s}"}.join
 $LOCAL_LIBS << ' -lrucy'
 
-dir_config 'boost'
-dir_config 'rucy', Rucy.root_dir
-dir_config 'reflex', Reflex.root_dir
+Config::CONFIG.each {|key, val| val.gsub!(/gcc/, 'g++')}
 
 
-Config::CONFIG.each {|key, val| val.gsub!(/gcc/, 'g++')}
+dir_config 'boost'
+dir_config 'xot',    Xot.root_dir
+dir_config 'rucy',   Rucy.root_dir
+dir_config 'reflex', Reflex.root_dir
 
 exit 1 unless HEADERS.all? {|s| have_header(s)}
 exit 1 unless LIBS.all?    {|s| have_library(s)}

data/ext/reflex/key.cpp

@@ -2,7 +2,7 @@
 
 
 #include <rucy.h>
-#include "reflex.h"
+#include "defs.h"
 
 
 using namespace Rucy;
@@ -12,11 +12,12 @@ namespace Reflex
 {
 
 
+	static Class cKey;
+
 	Class
 	key_class ()
 	{
-		static Class c = reflex_module().define_class("Key");
-		return c;
+		return cKey;
 	}
 
 
@@ -118,11 +119,15 @@ RUBY_END
 void
 Init_key ()
 {
-	Reflex::key_class()
-		.define_alloc_func(alloc)
-		.define_method("initialize", initialize)
-		.define_method("chars", chars)
-		.define_method("code", code)
-		.define_method("repeat", repeat)
-		.define_method("modifiers", modifiers);
+	Module m = define_module("Reflex");
+
+	Class c = m.define_class("Key");
+	Reflex::cKey = c;
+
+	c.define_alloc_func(alloc);
+	c.define_method("initialize", initialize);
+	c.define_method("chars", chars);
+	c.define_method("code", code);
+	c.define_method("repeat", repeat);
+	c.define_method("modifiers", modifiers);
 }

data/ext/reflex/native.cpp

@@ -1,4 +1,8 @@
 #include <rucy.h>
+#include "defs.h"
+
+
+using namespace Rucy;
 
 
 void Init_reflex ();
@@ -12,7 +16,7 @@ extern "C" void
 Init_native ()
 {
 	if (!Rucy::init())
-		Rucy::raise(rb_eLoadError, "Rucy::init() failed.");
+		raise(rb_eLoadError, "Rucy::init() failed.");
 
 	Init_reflex();
 	Init_application();

data/ext/reflex/points.cpp

@@ -2,7 +2,7 @@
 
 
 #include <rucy.h>
-#include "reflex.h"
+#include "defs.h"
 
 
 using namespace Rucy;
@@ -14,11 +14,12 @@ namespace Reflex
 {
 
 
+	static Class cPoints;
+
 	Class
 	points_class ()
 	{
-		static Class c = reflex_module().define_class("Points");
-		return c;
+		return cPoints;
 	}
 
 
@@ -147,14 +148,18 @@ RUBY_END
 void
 Init_points ()
 {
-	Reflex::points_class()
-		.define_alloc_func(alloc)
-		.define_method("initialize", initialize)
-		.define_method("type", type)
-		.define_method("x", x)
-		.define_method("y", y)
-		.define_method("size", size)
-		.define_method("modifiers", modifiers)
-		.define_method("count", count)
-		.define_method("drag", drag);
+	Module m = define_module("Reflex");
+
+	Class c = m.define_class("Points");
+	Reflex::cPoints = c;
+
+	c.define_alloc_func(alloc);
+	c.define_method("initialize", initialize);
+	c.define_method("type", type);
+	c.define_method("x", x);
+	c.define_method("y", y);
+	c.define_method("size", size);
+	c.define_method("modifiers", modifiers);
+	c.define_method("count", count);
+	c.define_method("drag", drag);
 }