reflexion 0.1.3 → 0.1.4

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

@@ -8,12 +8,13 @@
 using namespace Rucy;
 
 
+static Class cApplication;
+
+
 namespace Reflex
 {
 
 
-	static Class cApplication;
-
 	Class
 	application_class ()
 	{
@@ -24,73 +25,27 @@ namespace Reflex
 }// 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();
-		}
+typedef Reflex::RubyApplication<Reflex::Application> RubyApplication;
 
-		virtual bool run ()
-		{
-			SYM(run);
-			return self.call(run);
-		}
 
-		virtual bool quit ()
-		{
-			SYM(quit);
-			return self.call(quit);
-		}
+#define THIS      to<Reflex::Application*>(self)
 
-		virtual bool about ()
-		{
-			SYM(about);
-			return self.call(about);
-		}
+#define CHECK     RUCY_CHECK_OBJECT(self, Reflex::Application, cApplication)
 
-};// RubyApplication
-
-
-#define this ((RubyApplication*) to<Reflex::Application*>(self))
-
-#define CHECK CHECK_OBJECT(self, RubyApplication, Reflex::application_class())
+#define CALL(fun) RUCY_WRAPPER_CALL(RubyApplication, THIS, fun)
 
 
 static
 VALUE alloc(VALUE klass)
 {
-	RubyApplication* app = new RubyApplication;
-	return app->self = new_type<RubyApplication>(klass, app, mark_type<RubyApplication>);
+	return value(new RubyApplication, klass);
 }
 
 static
 VALUE run(VALUE self)
 {
 	CHECK;
-	if (!this->Super::run())
+	if (!CALL(run()))
 		system_error("failed to run application.");
 	return self;
 }
@@ -99,7 +54,7 @@ static
 VALUE quit(VALUE self)
 {
 	CHECK;
-	if (!this->Super::quit())
+	if (!CALL(quit()))
 		system_error("failed to quit application.");
 	return self;
 }
@@ -108,43 +63,47 @@ static
 VALUE about(VALUE self)
 {
 	CHECK;
-	if (!this->Super::about())
+	if (!CALL(about()))
 		system_error("failed to show about application.");
 	return self;
 }
 
 static
-VALUE get_name(VALUE self)
+VALUE set_name(VALUE self, VALUE name)
 {
 	CHECK;
-	String s;
-	if (!this->get_name(&s))
-		system_error("failed to get name of application.");
-	return Value(s.c_str());
+	if (!THIS->set_name(name.c_str()))
+		system_error("failed to set name of application.");
+	return name;
 }
 
 static
-VALUE set_name(VALUE self, VALUE name)
+VALUE get_name(VALUE self)
 {
 	CHECK;
-	if (!this->set_name(name.c_str()))
-		system_error("failed to set name of application.");
-	return name;
+	const char* s = THIS->name();
+	if (!s) system_error("failed to get name of application.");
+	return value(s);
+}
+
+static
+VALUE instance(VALUE self)
+{
+	return value(Reflex::app());
 }
 
 
 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);
+	Module mReflex = rb_define_module("Reflex");
+
+	cApplication = rb_define_class_under(mReflex, "Application", rb_cObject);
+	rb_define_alloc_func(cApplication, alloc);
+	rb_define_method(cApplication, "run", RUBY_METHOD_FUNC(run), 0);
+	rb_define_method(cApplication, "quit", RUBY_METHOD_FUNC(quit), 0);
+	rb_define_method(cApplication, "about", RUBY_METHOD_FUNC(about), 0);
+	rb_define_method(cApplication, "name=", RUBY_METHOD_FUNC(set_name), 1);
+	rb_define_method(cApplication, "name", RUBY_METHOD_FUNC(get_name), 0);
+	rb_define_singleton_method(cApplication, "instance", RUBY_METHOD_FUNC(instance), 0);
 }

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

@@ -0,0 +1,8 @@
+#include "defs.h"
+
+
+#include <rucy/value.h>
+#include <reflex/defs.h>
+
+
+using namespace Rucy;

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

@@ -8,12 +8,13 @@
 using namespace Rucy;
 
 
+static Class cKey;
+
+
 namespace Reflex
 {
 
 
-	static Class cKey;
-
 	Class
 	key_class ()
 	{
@@ -31,97 +32,91 @@ namespace Rucy
 	Value
 	value (const Reflex::Key& key)
 	{
-		return new_type<Reflex::Key>(
-			Reflex::key_class(), new Reflex::Key(key));
+		return new_type(cKey, 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 THIS to<Reflex::Key*>(self)
 
-#define CHECK CHECK_OBJECT(self, RubyKey, Reflex::key_class())
+#define CHECK RUCY_CHECK_OBJ(self, Reflex::Key, cKey)
 
 
 static
 VALUE alloc(VALUE klass)
 {
-	return new_type<RubyKey>(klass, new RubyKey);
+	return new_type<Reflex::Key>(klass);
 }
 
 static
 VALUE initialize(VALUE self)
 {
-	CHECK_OBJ(self, RubyKey, Reflex::key_class());
+	RUCY_CHECK_OBJ(self, Reflex::Key, cKey);
 	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;
+	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 initialize_copy(VALUE self, VALUE obj)
+{
+	RUCY_CHECK_OBJ(self, Reflex::Key, cKey);
+
+	Reflex::Key* key = to<Reflex::Key*>(obj);
+	if (!key) argument_error();
+
+	*THIS = *key;
+	return self;
+}
+
 static
 VALUE chars(VALUE self)
 {
 	CHECK;
-	return value(this->chars.c_str());
+	return value(THIS->chars.c_str());
 }
 
 static
 VALUE code(VALUE self)
 {
 	CHECK;
-	return value(this->code);
+	return value(THIS->code);
 }
 
 static
 VALUE repeat(VALUE self)
 {
 	CHECK;
-	return value(this->repeat);
+	return value(THIS->repeat);
 }
 
 static
 VALUE modifiers(VALUE self)
 {
 	CHECK;
-	return value(this->modifiers);
+	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);
+	Module mReflex = rb_define_module("Reflex");
+
+	cKey = rb_define_class_under(mReflex, "Key", rb_cObject);
+	rb_define_alloc_func(cKey, alloc);
+	rb_define_private_method(cKey, "initialize", RUBY_METHOD_FUNC(initialize), -1);
+	rb_define_private_method(cKey, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+	rb_define_method(cKey, "chars", RUBY_METHOD_FUNC(chars), 0);
+	rb_define_method(cKey, "code", RUBY_METHOD_FUNC(code), 0);
+	rb_define_method(cKey, "repeat", RUBY_METHOD_FUNC(repeat), 0);
+	rb_define_method(cKey, "modifiers", RUBY_METHOD_FUNC(modifiers), 0);
 }

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

@@ -6,10 +6,11 @@ using namespace Rucy;
 
 
 void Init_reflex ();
-void Init_application ();
-void Init_window ();
 void Init_key ();
 void Init_points ();
+void Init_application ();
+void Init_window ();
+void Init_view ();
 
 
 extern "C" void
@@ -19,8 +20,9 @@ Init_native ()
 		raise(rb_eLoadError, "Rucy::init() failed.");
 
 	Init_reflex();
-	Init_application();
-	Init_window();
 	Init_key();
 	Init_points();
+	Init_application();
+	Init_window();
+	Init_view();
 }

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

@@ -10,12 +10,13 @@ using namespace Rucy;
 using Reflex::coord;
 
 
+static Class cPoints;
+
+
 namespace Reflex
 {
 
 
-	static Class cPoints;
-
 	Class
 	points_class ()
 	{
@@ -33,56 +34,51 @@ namespace Rucy
 	Value
 	value (const Reflex::Points& points)
 	{
-		return new_type<Reflex::Points>(
-			Reflex::points_class(), new Reflex::Points(points));
+		return new_type(cPoints, 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 THIS to<Reflex::Points*>(self)
 
-#define CHECK CHECK_OBJECT(self, RubyPoints, Reflex::points_class())
+#define CHECK RUCY_CHECK_OBJ(self, Reflex::Points, cPoints)
 
 
 static
 VALUE alloc(VALUE klass)
 {
-	return new_type<RubyPoints>(klass, new RubyPoints);
+	return new_type<Reflex::Points>(klass);
 }
 
 static
 VALUE initialize(VALUE self)
 {
-	CHECK_OBJ(self, RubyPoints, Reflex::points_class());
+	RUCY_CHECK_OBJ(self, Reflex::Points, cPoints);
 	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;
+	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 initialize_copy(VALUE self, VALUE obj)
+{
+	RUCY_CHECK_OBJ(self, Reflex::Points, cPoints);
+
+	Reflex::Points* points = to<Reflex::Points*>(obj);
+	if (!points) argument_error();
 
+	*THIS = *points;
 	return self;
 }
 
@@ -90,67 +86,66 @@ static
 VALUE type(VALUE self)
 {
 	CHECK;
-	return value(this->type);
+	return value(THIS->type);
 }
 
 static
 VALUE x(VALUE self)
 {
 	CHECK;
-	return value(this->x);
+	return value(THIS->x);
 }
 
 static
 VALUE y(VALUE self)
 {
 	CHECK;
-	return value(this->y);
+	return value(THIS->y);
 }
 
 static
 VALUE size(VALUE self)
 {
 	CHECK;
-	return value(this->size);
+	return value(THIS->size);
 }
 
 static
 VALUE modifiers(VALUE self)
 {
 	CHECK;
-	return value(this->modifiers);
+	return value(THIS->modifiers);
 }
 
 static
 VALUE count(VALUE self)
 {
 	CHECK;
-	return value(this->count);
+	return value(THIS->count);
 }
 
 static
 VALUE drag(VALUE self)
 {
 	CHECK;
-	return value(this->drag);
+	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);
+	Module mReflex = rb_define_module("Reflex");
+
+	cPoints = rb_define_class_under(mReflex, "Points", rb_cObject);
+	rb_define_alloc_func(cPoints, alloc);
+	rb_define_private_method(cPoints, "initialize", RUBY_METHOD_FUNC(initialize), -1);
+	rb_define_private_method(cPoints, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+	rb_define_method(cPoints, "type", RUBY_METHOD_FUNC(type), 0);
+	rb_define_method(cPoints, "x", RUBY_METHOD_FUNC(x), 0);
+	rb_define_method(cPoints, "y", RUBY_METHOD_FUNC(y), 0);
+	rb_define_method(cPoints, "size", RUBY_METHOD_FUNC(size), 0);
+	rb_define_method(cPoints, "modifiers", RUBY_METHOD_FUNC(modifiers), 0);
+	rb_define_method(cPoints, "count", RUBY_METHOD_FUNC(count), 0);
+	rb_define_method(cPoints, "drag", RUBY_METHOD_FUNC(drag), 0);
 }

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

@@ -6,12 +6,13 @@
 using namespace Rucy;
 
 
+static Module mReflex;
+
+
 namespace Reflex
 {
 
 
-	static Module mReflex;
-
 	Module
 	reflex_module ()
 	{
@@ -26,7 +27,7 @@ static
 VALUE init(VALUE self)
 {
 	if (!Reflex::init())
-		error("Reflex::init() failed.");
+		reflex_error("Reflex::init() failed.");
 
 	return self;
 }
@@ -35,7 +36,7 @@ static
 VALUE fin(VALUE self)
 {
 	if (!Reflex::fin())
-		error("Reflex::fin() failed.");
+		reflex_error("Reflex::fin() failed.");
 
 	return self;
 }
@@ -44,7 +45,7 @@ static
 VALUE run(VALUE self, VALUE name)
 {
 	if (!Reflex::run(name ? name.c_str() : NULL))
-		error("Reflex::run() failed.");
+		reflex_error("Reflex::run() failed.");
 
 	return self;
 }
@@ -53,7 +54,7 @@ static
 VALUE quit(VALUE self)
 {
 	if (!Reflex::quit())
-		error("Reflex::quit() failed.");
+		reflex_error("Reflex::quit() failed.");
 
 	return self;
 }
@@ -62,11 +63,9 @@ VALUE quit(VALUE 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);
+	mReflex = rb_define_module("Reflex");
+	mReflex.define_singleton_method("init!", init);
+	mReflex.define_singleton_method("fin!", fin);
+	mReflex.define_singleton_method("run!", run);
+	rb_define_singleton_method(mReflex, "quit", RUBY_METHOD_FUNC(quit), 0);
 }