reflexion 0.1.2 → 0.1.3

data/.doc/ext/reflex/application.cpp

@@ -0,0 +1,150 @@
+#include "reflex/ruby/application.h"
+
+
+#include <rucy.h>
+#include "defs.h"
+
+
+using namespace Rucy;
+
+
+namespace Reflex
+{
+
+
+	static Class cApplication;
+
+	Class
+	application_class ()
+	{
+		return cApplication;
+	}
+
+
+}// Reflex
+
+
+namespace Rucy
+{
+
+
+	Value
+	value (const Reflex::Application& application)
+	{
+		return new_type<Reflex::Application>(
+			Reflex::application_class(), new Reflex::Application(application));
+	}
+
+
+}// Rucy
+
+
+class RubyApplication : public Reflex::Application
+{
+
+	public:
+
+		typedef Reflex::Application Super;
+
+		Value self;
+
+		void mark ()
+		{
+			self.mark();
+		}
+
+		virtual bool run ()
+		{
+			SYM(run);
+			return self.call(run);
+		}
+
+		virtual bool quit ()
+		{
+			SYM(quit);
+			return self.call(quit);
+		}
+
+		virtual bool about ()
+		{
+			SYM(about);
+			return self.call(about);
+		}
+
+};// RubyApplication
+
+
+#define this ((RubyApplication*) to<Reflex::Application*>(self))
+
+#define CHECK CHECK_OBJECT(self, RubyApplication, Reflex::application_class())
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	RubyApplication* app = new RubyApplication;
+	return app->self = new_type<RubyApplication>(klass, app, mark_type<RubyApplication>);
+}
+
+static
+VALUE run(VALUE self)
+{
+	CHECK;
+	if (!this->Super::run())
+		system_error("failed to run application.");
+	return self;
+}
+
+static
+VALUE quit(VALUE self)
+{
+	CHECK;
+	if (!this->Super::quit())
+		system_error("failed to quit application.");
+	return self;
+}
+
+static
+VALUE about(VALUE self)
+{
+	CHECK;
+	if (!this->Super::about())
+		system_error("failed to show about application.");
+	return self;
+}
+
+static
+VALUE get_name(VALUE self)
+{
+	CHECK;
+	String s;
+	if (!this->get_name(&s))
+		system_error("failed to get name of application.");
+	return Value(s.c_str());
+}
+
+static
+VALUE set_name(VALUE self, VALUE name)
+{
+	CHECK;
+	if (!this->set_name(name.c_str()))
+		system_error("failed to set name of application.");
+	return name;
+}
+
+
+void
+Init_application ()
+{
+	Module m = rb_define_module("Reflex");
+
+	Class c = rb_define_class_under(m, "Application", rb_cObject);
+	Reflex::cApplication = c;
+
+	rb_define_alloc_func(c, alloc);
+	rb_define_method(c, "run", RUBY_METHOD_FUNC(run), 0);
+	rb_define_method(c, "quit", RUBY_METHOD_FUNC(quit), 0);
+	rb_define_method(c, "about", RUBY_METHOD_FUNC(about), 0);
+	rb_define_method(c, "name", RUBY_METHOD_FUNC(get_name), 0);
+	rb_define_method(c, "name=", RUBY_METHOD_FUNC(set_name), 1);
+}

data/.doc/ext/reflex/key.cpp

@@ -0,0 +1,127 @@
+#include "reflex/ruby/key.h"
+
+
+#include <rucy.h>
+#include "defs.h"
+
+
+using namespace Rucy;
+
+
+namespace Reflex
+{
+
+
+	static Class cKey;
+
+	Class
+	key_class ()
+	{
+		return cKey;
+	}
+
+
+}// Reflex
+
+
+namespace Rucy
+{
+
+
+	Value
+	value (const Reflex::Key& key)
+	{
+		return new_type<Reflex::Key>(
+			Reflex::key_class(), new Reflex::Key(key));
+	}
+
+
+}// Rucy
+
+
+struct RubyKey : public Reflex::Key
+{
+
+	operator bool () const
+	{
+		return true;
+	}
+
+	bool operator ! () const
+	{
+		return !operator bool();
+	}
+
+};// RubyKey
+
+
+#define this ((RubyKey*) to<Reflex::Key*>(self))
+
+#define CHECK CHECK_OBJECT(self, RubyKey, Reflex::key_class())
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<RubyKey>(klass, new RubyKey);
+}
+
+static
+VALUE initialize(VALUE self)
+{
+	CHECK_OBJ(self, RubyKey, Reflex::key_class());
+	if (argc < 0 || 4 < argc)
+		argument_error("Key#initialize", argc, 0, 1, 2);
+
+	this->chars     = (argc >= 1) ? argv[0].c_str()   : NULL;
+	this->code      = (argc >= 2) ? to<int>(argv[1])  : Reflex::KEY_NONE;
+	this->repeat    = (argc >= 3) ? to<int>(argv[2])  : 1;
+	this->modifiers = (argc >= 4) ? to<uint>(argv[3]) : (uint) Reflex::MOD_NONE;
+
+	return self;
+}
+
+static
+VALUE chars(VALUE self)
+{
+	CHECK;
+	return value(this->chars.c_str());
+}
+
+static
+VALUE code(VALUE self)
+{
+	CHECK;
+	return value(this->code);
+}
+
+static
+VALUE repeat(VALUE self)
+{
+	CHECK;
+	return value(this->repeat);
+}
+
+static
+VALUE modifiers(VALUE self)
+{
+	CHECK;
+	return value(this->modifiers);
+}
+
+
+void
+Init_key ()
+{
+	Module m = rb_define_module("Reflex");
+
+	Class c = rb_define_class_under(m, "Key", rb_cObject);
+	Reflex::cKey = c;
+
+	rb_define_alloc_func(c, alloc);
+	rb_define_method(c, "initialize", RUBY_METHOD_FUNC(initialize), -1);
+	rb_define_method(c, "chars", RUBY_METHOD_FUNC(chars), 0);
+	rb_define_method(c, "code", RUBY_METHOD_FUNC(code), 0);
+	rb_define_method(c, "repeat", RUBY_METHOD_FUNC(repeat), 0);
+	rb_define_method(c, "modifiers", RUBY_METHOD_FUNC(modifiers), 0);
+}

data/.doc/ext/reflex/native.cpp

@@ -0,0 +1,26 @@
+#include <rucy.h>
+#include "defs.h"
+
+
+using namespace Rucy;
+
+
+void Init_reflex ();
+void Init_application ();
+void Init_window ();
+void Init_key ();
+void Init_points ();
+
+
+extern "C" void
+Init_native ()
+{
+	if (!Rucy::init())
+		raise(rb_eLoadError, "Rucy::init() failed.");
+
+	Init_reflex();
+	Init_application();
+	Init_window();
+	Init_key();
+	Init_points();
+}

data/.doc/ext/reflex/points.cpp

@@ -0,0 +1,156 @@
+#include "reflex/ruby/points.h"
+
+
+#include <rucy.h>
+#include "defs.h"
+
+
+using namespace Rucy;
+
+using Reflex::coord;
+
+
+namespace Reflex
+{
+
+
+	static Class cPoints;
+
+	Class
+	points_class ()
+	{
+		return cPoints;
+	}
+
+
+}// Reflex
+
+
+namespace Rucy
+{
+
+
+	Value
+	value (const Reflex::Points& points)
+	{
+		return new_type<Reflex::Points>(
+			Reflex::points_class(), new Reflex::Points(points));
+	}
+
+
+}// Rucy
+
+
+struct RubyPoints : public Reflex::Points
+{
+
+	operator bool () const
+	{
+		return true;
+	}
+
+	bool operator ! () const
+	{
+		return !operator bool();
+	}
+
+};// RubyPoints
+
+
+#define this ((RubyPoints*) to<Reflex::Points*>(self))
+
+#define CHECK CHECK_OBJECT(self, RubyPoints, Reflex::points_class())
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<RubyPoints>(klass, new RubyPoints);
+}
+
+static
+VALUE initialize(VALUE self)
+{
+	CHECK_OBJ(self, RubyPoints, Reflex::points_class());
+	if (argc < 0 || 6 < argc)
+		arg_count_error("Points#initialize", argc, 0, 1, 2, 3, 4, 5, 6);
+
+	this->type      = (argc >= 1) ? to<int>(argv[0])   : Reflex::POINT_NONE;
+	this->x         = (argc >= 2) ? to<coord>(argv[1]) : 0;
+	this->y         = (argc >= 3) ? to<coord>(argv[2]) : 0;
+	this->size      = 1;
+	this->modifiers = (argc >= 4) ? to<uint>(argv[3])  : (uint) Reflex::MOD_NONE;
+	this->count     = (argc >= 5) ? to<uint>(argv[4])  : 0;
+	this->drag      = (argc >= 6) ? to<bool>(argv[5])  : false;
+
+	return self;
+}
+
+static
+VALUE type(VALUE self)
+{
+	CHECK;
+	return value(this->type);
+}
+
+static
+VALUE x(VALUE self)
+{
+	CHECK;
+	return value(this->x);
+}
+
+static
+VALUE y(VALUE self)
+{
+	CHECK;
+	return value(this->y);
+}
+
+static
+VALUE size(VALUE self)
+{
+	CHECK;
+	return value(this->size);
+}
+
+static
+VALUE modifiers(VALUE self)
+{
+	CHECK;
+	return value(this->modifiers);
+}
+
+static
+VALUE count(VALUE self)
+{
+	CHECK;
+	return value(this->count);
+}
+
+static
+VALUE drag(VALUE self)
+{
+	CHECK;
+	return value(this->drag);
+}
+
+
+void
+Init_points ()
+{
+	Module m = rb_define_module("Reflex");
+
+	Class c = rb_define_class_under(m, "Points", rb_cObject);
+	Reflex::cPoints = c;
+
+	rb_define_alloc_func(c, alloc);
+	rb_define_method(c, "initialize", RUBY_METHOD_FUNC(initialize), -1);
+	rb_define_method(c, "type", RUBY_METHOD_FUNC(type), 0);
+	rb_define_method(c, "x", RUBY_METHOD_FUNC(x), 0);
+	rb_define_method(c, "y", RUBY_METHOD_FUNC(y), 0);
+	rb_define_method(c, "size", RUBY_METHOD_FUNC(size), 0);
+	rb_define_method(c, "modifiers", RUBY_METHOD_FUNC(modifiers), 0);
+	rb_define_method(c, "count", RUBY_METHOD_FUNC(count), 0);
+	rb_define_method(c, "drag", RUBY_METHOD_FUNC(drag), 0);
+}

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

@@ -0,0 +1,72 @@
+#include <rucy.h>
+#include <reflex/reflex.h>
+#include "defs.h"
+
+
+using namespace Rucy;
+
+
+namespace Reflex
+{
+
+
+	static Module mReflex;
+
+	Module
+	reflex_module ()
+	{
+		return mReflex;
+	}
+
+
+}// Reflex
+
+
+static
+VALUE init(VALUE self)
+{
+	if (!Reflex::init())
+		error("Reflex::init() failed.");
+
+	return self;
+}
+
+static
+VALUE fin(VALUE self)
+{
+	if (!Reflex::fin())
+		error("Reflex::fin() failed.");
+
+	return self;
+}
+
+static
+VALUE run(VALUE self, VALUE name)
+{
+	if (!Reflex::run(name ? name.c_str() : NULL))
+		error("Reflex::run() failed.");
+
+	return self;
+}
+
+static
+VALUE quit(VALUE self)
+{
+	if (!Reflex::quit())
+		error("Reflex::quit() failed.");
+
+	return self;
+}
+
+
+void
+Init_reflex ()
+{
+	Module m = rb_define_module("Reflex");
+	Reflex::mReflex = m;
+
+	m.define_singleton_method("init!", init);
+	m.define_singleton_method("fin!", fin);
+	m.define_singleton_method("run!", run);
+	rb_define_singleton_method(m, "quit", RUBY_METHOD_FUNC(quit), 0);
+}