reflexion 0.1.1

data/ext/reflex/key.cpp

@@ -0,0 +1,128 @@
+#include "reflex/ruby/key.h"
+
+
+#include <rucy.h>
+#include "reflex.h"
+
+
+using namespace Rucy;
+
+
+namespace Reflex
+{
+
+
+	Class
+	key_class ()
+	{
+		static Class c = reflex_module().define_class("Key");
+		return c;
+	}
+
+
+}// 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
+RUBY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<RubyKey>(klass, new RubyKey);
+}
+RUBY_END
+
+static
+RUBY_DEFN(initialize)
+{
+	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;
+}
+RUBY_END
+
+static
+RUBY_DEF0(chars)
+{
+	CHECK;
+	return value(this->chars.c_str());
+}
+RUBY_END
+
+static
+RUBY_DEF0(code)
+{
+	CHECK;
+	return value(this->code);
+}
+RUBY_END
+
+static
+RUBY_DEF0(repeat)
+{
+	CHECK;
+	return value(this->repeat);
+}
+RUBY_END
+
+static
+RUBY_DEF0(modifiers)
+{
+	CHECK;
+	return value(this->modifiers);
+}
+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);
+}

data/ext/reflex/native.cpp

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

data/ext/reflex/points.cpp

@@ -0,0 +1,160 @@
+#include "reflex/ruby/points.h"
+
+
+#include <rucy.h>
+#include "reflex.h"
+
+
+using namespace Rucy;
+
+using Reflex::coord;
+
+
+namespace Reflex
+{
+
+
+	Class
+	points_class ()
+	{
+		static Class c = reflex_module().define_class("Points");
+		return c;
+	}
+
+
+}// 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
+RUBY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<RubyPoints>(klass, new RubyPoints);
+}
+RUBY_END
+
+static
+RUBY_DEFN(initialize)
+{
+	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;
+}
+RUBY_END
+
+static
+RUBY_DEF0(type)
+{
+	CHECK;
+	return value(this->type);
+}
+RUBY_END
+
+static
+RUBY_DEF0(x)
+{
+	CHECK;
+	return value(this->x);
+}
+RUBY_END
+
+static
+RUBY_DEF0(y)
+{
+	CHECK;
+	return value(this->y);
+}
+RUBY_END
+
+static
+RUBY_DEF0(size)
+{
+	CHECK;
+	return value(this->size);
+}
+RUBY_END
+
+static
+RUBY_DEF0(modifiers)
+{
+	CHECK;
+	return value(this->modifiers);
+}
+RUBY_END
+
+static
+RUBY_DEF0(count)
+{
+	CHECK;
+	return value(this->count);
+}
+RUBY_END
+
+static
+RUBY_DEF0(drag)
+{
+	CHECK;
+	return value(this->drag);
+}
+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);
+}

data/ext/reflex/reflex.cpp

@@ -0,0 +1,83 @@
+#include <rucy.h>
+#include <reflex/reflex.h>
+#include "reflex.h"
+
+
+using namespace Rucy;
+
+
+namespace Reflex
+{
+
+
+	Module
+	reflex_module ()
+	{
+		static Module m = define_module("Reflex");
+		return m;
+	}
+
+	Class
+	reflex_error_class ()
+	{
+		static Class c =
+			reflex_module().define_class("ReflexError", native_error_class());
+		return c;
+	}
+
+
+}// Reflex
+
+
+static
+RUBY_DEF0(init)
+{
+	if (!Reflex::init())
+		error("Reflex::init() failed.");
+
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF0(fin)
+{
+	if (!Reflex::fin())
+		error("Reflex::fin() failed.");
+
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF1(run, name)
+{
+	if (!Reflex::run(name ? name.c_str() : NULL))
+		error("Reflex::run() failed.");
+
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF0(quit)
+{
+	if (!Reflex::quit())
+		error("Reflex::quit() failed.");
+
+	return self;
+}
+RUBY_END
+
+
+void
+Init_reflex ()
+{
+	Reflex::reflex_error_class();
+
+	Reflex::reflex_module()
+		.define_singleton_method("init!", init)
+		.define_singleton_method("fin!", fin)
+		.define_singleton_method("run!", run)
+		.define_singleton_method("quit", quit);
+}

data/ext/reflex/reflex.h

@@ -0,0 +1,39 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_EXT_REFLEX_H__
+#define __REFLEX_EXT_REFLEX_H__
+
+
+#include <rucy/class.h>
+#include "reflex/ruby/reflex.h"
+
+
+namespace Reflex
+{
+
+
+	Rucy::Class reflex_error_class ();
+	// class Reflex::ReflexError < Rucy::NativeError
+
+
+}// Reflex
+
+
+#define CHECK_OBJ(obj, type, klass) \
+	do \
+	{ \
+		type* p = Rucy::get_type<type>(obj, klass); \
+		if (!p) Rucy::invalid_object_error(); \
+	} \
+	while(0)
+
+#define CHECK_OBJECT(obj, type, klass) \
+	do \
+	{ \
+		type* p = Rucy::get_type<type>(obj, klass); \
+		if (!p || !*p) Rucy::invalid_object_error(); \
+	} \
+	while(0)
+
+
+#endif//EOH