reflexion 0.5.3 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15c42394de71e92c5f03509d7e79930a02b00d849846647a1722d2b381aded79
-  data.tar.gz: ca3a4f10526c32f2307bb9f70f305e66063142b62713f4f9c90bf66ca96646f5
+  metadata.gz: 5228288ca6eaf922b07a4e5934fc402f16a79261541db581691fdc77df985a41
+  data.tar.gz: 9a4918d2d0c66b5aec2dda5b4cf9afd080d9c7fd8ef863517791b2bcf34561f4
 SHA512:
-  metadata.gz: f31929a116e8213bfc46812b43da782c7c1fcae7b25a9ff22dda2a5c069362abc74f32dd645cfce1b28ace8e8a6cf4f9eacaac5967e6658f1ce7e45314dfe584
-  data.tar.gz: 29879e13e7fd53991fd28f17cc956fcb2acdaf785cfb4fc657f52616e9c0698cdd223f8928ac5815012a8fb85e4d268c675eb1d77594a3c671a150a9075074ff
+  metadata.gz: 6520e51eb23b4215b34116fd37b34fe1a06532e554186bf47ac0b956e5f9a71e97d6c7aae4465550e8d4ed86f763e86f605d2e811959fbe42fe50fb253bcfb67
+  data.tar.gz: 371a81c13682e5c6cceda6549fcf2e6378574d3bf4181bcedbf4e09f175a7ba975869d76240692c72ce312de6dc0dec079e11e546aaba4bb86eb0c038c28e085

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

@@ -1,6 +1,7 @@
 #include "reflex/ruby/application.h"
 
 
+#include "reflex/ruby/menu.h"
 #include "reflex/ruby/window.h"
 #include "defs.h"
 
@@ -9,8 +10,8 @@ RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::Application)
 
 #define THIS      to<Reflex::Application*>(self)
 
-#define CHECK_OBJ RUCY_CHECK_OBJ(   Reflex::Application, self)
-#define CHECK     RUCY_CHECK_OBJECT(Reflex::Application, self)
+#define CHECK_PTR RUCY_CHECK_PTR(Reflex::Application, self)
+#define CHECK     RUCY_CHECK_OBJ(Reflex::Application, self)
 
 #define CALL(fun) RUCY_CALL_SUPER(THIS, fun)
 
@@ -24,7 +25,7 @@ VALUE alloc(VALUE klass)
 static
 VALUE start(VALUE self)
 {
-	CHECK_OBJ;
+	CHECK_PTR;
 	CALL(start());
 	return self;
 }
@@ -52,6 +53,51 @@ VALUE get_name(VALUE self)
 	return value(THIS->name());
 }
 
+static
+VALUE set_menu(VALUE self, VALUE menu)
+{
+	CHECK;
+	THIS->set_menu(menu ? to<Reflex::Menu*>(menu) : NULL);
+	return menu;
+}
+
+static
+VALUE get_menu(VALUE self)
+{
+	CHECK;
+	return value(THIS->menu());
+}
+
+static
+VALUE set_background(VALUE self, VALUE state)
+{
+	CHECK;
+	THIS->set_background(to<bool>(state));
+	return state;
+}
+
+static
+VALUE is_background(VALUE self)
+{
+	CHECK;
+	return value(THIS->background());
+}
+
+static
+VALUE set_background_menu(VALUE self, VALUE menu)
+{
+	CHECK;
+	THIS->set_background_menu(menu ? to<Reflex::Menu*>(menu) : NULL);
+	return menu;
+}
+
+static
+VALUE get_background_menu(VALUE self)
+{
+	CHECK;
+	return value(THIS->background_menu());
+}
+
 static
 VALUE each_window(VALUE self)
 {
@@ -59,7 +105,7 @@ VALUE each_window(VALUE self)
 
 	Value ret;
 	for (auto it = THIS->window_begin(), end = THIS->window_end(); it != end; ++it)
-		ret = rb_yield(value(it->get()));
+		ret = yield(value(it->get()));
 	return ret;
 }
 
@@ -68,9 +114,6 @@ VALUE on_start(VALUE self, VALUE event)
 {
 	CHECK;
 
-	RUCY_SYM(call_start_block);
-	self.call(call_start_block);
-
 	CALL(on_start(to<Reflex::Event*>(event)));
 }
 
@@ -136,6 +179,12 @@ Init_reflex_application ()
 	rb_define_method(cApplication, "quit", RUBY_METHOD_FUNC(quit), 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_method(cApplication, "menu=", RUBY_METHOD_FUNC(set_menu), 1);
+	rb_define_method(cApplication, "menu", RUBY_METHOD_FUNC(get_menu), 0);
+	rb_define_method(cApplication, "background=", RUBY_METHOD_FUNC(set_background), 1);
+	cApplication.define_method("background?",       is_background);
+	rb_define_method(cApplication, "background_menu=", RUBY_METHOD_FUNC(set_background_menu), 1);
+	rb_define_method(cApplication, "background_menu", RUBY_METHOD_FUNC(get_background_menu), 0);
 	rb_define_method(cApplication, "each_window", RUBY_METHOD_FUNC(each_window), 0);
 	rb_define_method(cApplication, "on_start", RUBY_METHOD_FUNC(on_start), 1);
 	rb_define_method(cApplication, "on_quit", RUBY_METHOD_FUNC(on_quit), 1);

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

@@ -9,7 +9,7 @@ RUCY_DEFINE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::CaptureEvent)
 
 #define THIS  to<Reflex::CaptureEvent*>(self)
 
-#define CHECK RUCY_CHECK_OBJ(Reflex::CaptureEvent, self)
+#define CHECK RUCY_CHECK_PTR(Reflex::CaptureEvent, self)
 
 
 static

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

@@ -0,0 +1,84 @@
+#include "reflex/ruby/constraint.h"
+
+
+#include <rays/ruby/point.h>
+#include "reflex/exception.h"
+#include "reflex/ruby/pin.h"
+#include "reflex/ruby/view.h"
+#include "defs.h"
+
+
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::ChaseConstraint)
+
+#define THIS  to<Reflex::ChaseConstraint*>(self)
+
+#define CHECK RUCY_CHECK_PTR(Reflex::ChaseConstraint, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	Reflex::reflex_error(
+		__FILE__, __LINE__, "can not instantiate ChaseConstraint class");
+}
+
+static
+VALUE set_target(VALUE self)
+{
+	CHECK;
+	THIS->set_target(to<Reflex::Pin>(argc, argv));
+}
+
+static
+VALUE get_target(VALUE self)
+{
+	CHECK;
+	return value(THIS->target());
+}
+
+static
+VALUE set_force(VALUE self, VALUE max_force)
+{
+	CHECK;
+	if (max_force.is_nil())
+		THIS->clear_force();
+	else
+		THIS->set_force(to<float>(max_force));
+}
+
+static
+VALUE get_force(VALUE self)
+{
+	CHECK;
+	return THIS->has_force() ? value(THIS->force()) : nil();
+}
+
+
+static Class cChaseConstraint;
+
+void
+Init_reflex_chase_constraint ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cChaseConstraint = mReflex.define_class("ChaseConstraint", Reflex::constraint_class());
+	rb_define_alloc_func(cChaseConstraint, alloc);
+	rb_define_method(cChaseConstraint, "target=", RUBY_METHOD_FUNC(set_target), -1);
+	rb_define_method(cChaseConstraint, "target", RUBY_METHOD_FUNC(get_target), 0);
+	rb_define_method(cChaseConstraint, "force=", RUBY_METHOD_FUNC(set_force), 1);
+	rb_define_method(cChaseConstraint, "force", RUBY_METHOD_FUNC(get_force), 0);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	chase_constraint_class ()
+	{
+		return cChaseConstraint;
+	}
+
+
+}// Reflex

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

@@ -0,0 +1,65 @@
+#include "reflex/ruby/clipboard.h"
+
+
+#include "reflex/exception.h"
+#include "defs.h"
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	Reflex::reflex_error(__FILE__, __LINE__, "can not instantiate Clipboard class.");
+}
+
+static
+VALUE set_text(VALUE self, VALUE text)
+{
+	Reflex::Clipboard clipboard;
+	if (!text.is_nil()) clipboard.set_text(text.c_str());
+	Reflex::set_clipboard(clipboard);
+	return text;
+}
+
+static
+VALUE get_text(VALUE self)
+{
+	Reflex::Clipboard clipboard = Reflex::get_clipboard();
+	const char* text = clipboard.text();
+	return text ? value(text) : nil();
+}
+
+static
+VALUE clear(VALUE self)
+{
+	Reflex::set_clipboard(Reflex::Clipboard());
+	return self;
+}
+
+
+static Class cClipboard;
+
+void
+Init_reflex_clipboard ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cClipboard = rb_define_class_under(mReflex, "Clipboard", rb_cObject);
+	rb_define_alloc_func(cClipboard, alloc);
+	rb_define_singleton_method(cClipboard, "text=", RUBY_METHOD_FUNC(set_text), 1);
+	rb_define_singleton_method(cClipboard, "text", RUBY_METHOD_FUNC(get_text), 0);
+	rb_define_singleton_method(cClipboard, "clear", RUBY_METHOD_FUNC(clear), 0);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	clipboard_class ()
+	{
+		return cClipboard;
+	}
+
+
+}// Reflex

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

@@ -0,0 +1,76 @@
+#include "reflex/ruby/event.h"
+
+
+#include <rays/ruby/color.h>
+#include "defs.h"
+
+
+RUCY_DEFINE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::ColorEvent)
+
+#define THIS  to<Reflex::ColorEvent*>(self)
+
+#define CHECK RUCY_CHECK_PTR(Reflex::ColorEvent, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Reflex::ColorEvent>(klass);
+}
+
+static
+VALUE initialize(VALUE self, VALUE color)
+{
+	CHECK;
+
+	if (color.is_nil())
+		argument_error(__FILE__, __LINE__);
+
+	*THIS = Reflex::ColorEvent(to<Rays::Color>(color));
+
+	return rb_call_super(0, NULL);
+}
+
+static
+VALUE initialize_copy(VALUE self, VALUE obj)
+{
+	CHECK;
+	*THIS = to<Reflex::ColorEvent&>(obj).dup();
+	return self;
+}
+
+static
+VALUE get_color(VALUE self)
+{
+	CHECK;
+	return value(THIS->color());
+}
+
+
+static Class cColorEvent;
+
+void
+Init_reflex_color_event ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cColorEvent = mReflex.define_class("ColorEvent", Reflex::event_class());
+	rb_define_alloc_func(cColorEvent, alloc);
+	rb_define_private_method(cColorEvent, "initialize", RUBY_METHOD_FUNC(initialize), 1);
+	rb_define_private_method(cColorEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+	rb_define_method(cColorEvent, "color", RUBY_METHOD_FUNC(get_color), 0);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	color_event_class ()
+	{
+		return cColorEvent;
+	}
+
+
+}// Reflex

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

@@ -0,0 +1,113 @@
+#include "reflex/ruby/color_picker.h"
+
+
+#include <rays/ruby/color.h>
+#include "reflex/ruby/window.h"
+#include "defs.h"
+
+
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::ColorPicker)
+
+#define THIS      to<Reflex::ColorPicker*>(self)
+
+#define CHECK     RUCY_CHECK_OBJ(Reflex::ColorPicker, self)
+
+#define CALL(fun) RUCY_CALL_SUPER(THIS, fun)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return value(new Reflex::RubyColorPicker<Reflex::ColorPicker>, klass);
+}
+
+static
+VALUE pick_color(VALUE self, VALUE initial)
+{
+	CHECK;
+
+	if (initial.is_nil())
+		THIS->pick_color();
+	else
+		THIS->pick_color(to<Rays::Color>(initial));
+	return self;
+}
+
+static
+VALUE set_owner(VALUE self, VALUE owner)
+{
+	CHECK;
+	THIS->set_owner(owner.is_nil() ? NULL : to<Reflex::Window*>(owner));
+	return owner;
+}
+
+static
+VALUE get_owner(VALUE self)
+{
+	CHECK;
+	return value(THIS->owner());
+}
+
+static
+VALUE set_alpha(VALUE self, VALUE state)
+{
+	CHECK;
+	THIS->set_alpha(to<bool>(state));
+	return state;
+}
+
+static
+VALUE is_alpha(VALUE self)
+{
+	CHECK;
+	return value(THIS->alpha());
+}
+
+static
+VALUE on_color(VALUE self, VALUE event)
+{
+	CHECK;
+
+	CALL(on_color(to<Reflex::ColorEvent*>(event)));
+}
+
+static
+VALUE on_close(VALUE self, VALUE event)
+{
+	CHECK;
+
+	CALL(on_close(to<Reflex::Event*>(event)));
+}
+
+
+static Class cColorPicker;
+
+void
+Init_reflex_color_picker ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cColorPicker = rb_define_class_under(mReflex, "ColorPicker", rb_cObject);
+	rb_define_alloc_func(cColorPicker, alloc);
+	cColorPicker.define_method("pick_color!", pick_color);
+	rb_define_method(cColorPicker, "owner=", RUBY_METHOD_FUNC(set_owner), 1);
+	rb_define_method(cColorPicker, "owner", RUBY_METHOD_FUNC(get_owner), 0);
+	rb_define_method(cColorPicker, "alpha=", RUBY_METHOD_FUNC(set_alpha), 1);
+	cColorPicker.define_method("alpha?",  is_alpha);
+	rb_define_method(cColorPicker, "on_color", RUBY_METHOD_FUNC(on_color), 1);
+	rb_define_method(cColorPicker, "on_close", RUBY_METHOD_FUNC(on_close), 1);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	color_picker_class ()
+	{
+		return cColorPicker;
+	}
+
+
+}// Reflex

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

@@ -0,0 +1,135 @@
+#include "reflex/ruby/constraint.h"
+
+
+#include <rays/ruby/point.h>
+#include "reflex/exception.h"
+#include "reflex/ruby/view.h"
+#include "reflex/ruby/pin.h"
+#include "defs.h"
+#include "selector.h"
+
+
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::Constraint)
+
+#define THIS  to<Reflex::Constraint*>(self)
+
+#define CHECK RUCY_CHECK_PTR(Reflex::Constraint, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	Reflex::reflex_error(
+		__FILE__, __LINE__, "can not instantiate Constraint class");
+}
+
+static
+VALUE remove(VALUE self)
+{
+	CHECK;
+	THIS->remove();
+	return self;
+}
+
+static
+VALUE get_pin(VALUE self, VALUE index)
+{
+	CHECK;
+	return value(THIS->pin(to<int>(index)));
+}
+
+static
+VALUE set_spring(VALUE self, VALUE hertz)
+{
+	CHECK;
+	THIS->set_spring(hertz ? to<float>(hertz) : 0);
+}
+
+static
+VALUE get_spring(VALUE self)
+{
+	CHECK;
+	float hertz = THIS->spring();
+	return hertz > 0 ? value(hertz) : nil();
+}
+
+static
+VALUE set_damping(VALUE self, VALUE ratio)
+{
+	CHECK;
+	THIS->set_damping(to<float>(ratio));
+}
+
+static
+VALUE get_damping(VALUE self)
+{
+	CHECK;
+	return value(THIS->damping());
+}
+
+static
+VALUE set_collide(VALUE self, VALUE state)
+{
+	CHECK;
+	THIS->set_collide(to<bool>(state));
+}
+
+static
+VALUE can_collide(VALUE self)
+{
+	CHECK;
+	return value(THIS->can_collide());
+}
+
+static
+VALUE is_removed(VALUE self)
+{
+	CHECK;
+	return value(THIS->is_removed());
+}
+
+static
+VALUE is_active(VALUE self)
+{
+	CHECK;
+	return value(THIS->operator bool());
+}
+
+
+static Class cConstraint;
+
+void
+Init_reflex_constraint ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cConstraint = rb_define_class_under(mReflex, "Constraint", rb_cObject);
+	rb_define_alloc_func(cConstraint, alloc);
+	rb_define_method(cConstraint, "remove", RUBY_METHOD_FUNC(remove), 0);
+	rb_define_private_method(cConstraint, "get_pin", RUBY_METHOD_FUNC(get_pin), 1);
+	rb_define_method(cConstraint, "spring=", RUBY_METHOD_FUNC(set_spring), 1);
+	rb_define_method(cConstraint, "spring", RUBY_METHOD_FUNC(get_spring), 0);
+	rb_define_method(cConstraint, "damping=", RUBY_METHOD_FUNC(set_damping), 1);
+	rb_define_method(cConstraint, "damping", RUBY_METHOD_FUNC(get_damping), 0);
+	rb_define_method(cConstraint, "collide=", RUBY_METHOD_FUNC(set_collide), 1);
+	cConstraint.define_method("collide?", can_collide);
+	cConstraint.define_method("removed?", is_removed);
+	cConstraint.define_method("active?",  is_active);
+
+	define_selector_methods<Reflex::Constraint>(cConstraint);
+	define_wrapper_equality_methods<Reflex::Constraint>(cConstraint);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	constraint_class ()
+	{
+		return cConstraint;
+	}
+
+
+}// Reflex

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

@@ -11,7 +11,7 @@ RUCY_DEFINE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::ContactEvent)
 
 #define THIS  to<Reflex::ContactEvent*>(self)
 
-#define CHECK RUCY_CHECK_OBJ(Reflex::ContactEvent, self)
+#define CHECK RUCY_CHECK_PTR(Reflex::ContactEvent, self)
 
 
 static

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

@@ -8,7 +8,7 @@ RUCY_DEFINE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::ControlChangeEvent)
 
 #define THIS  to<Reflex::ControlChangeEvent*>(self)
 
-#define CHECK RUCY_CHECK_OBJ(Reflex::ControlChangeEvent, self)
+#define CHECK RUCY_CHECK_PTR(Reflex::ControlChangeEvent, self)
 
 
 static

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

@@ -8,7 +8,7 @@ RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::Device)
 
 #define THIS  to<Reflex::Device*>(self)
 
-#define CHECK RUCY_CHECK_OBJECT(Reflex::Device, self)
+#define CHECK RUCY_CHECK_OBJ(Reflex::Device, self)
 
 
 static

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

@@ -9,7 +9,7 @@ RUCY_DEFINE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::DeviceEvent)
 
 #define THIS  to<Reflex::DeviceEvent*>(self)
 
-#define CHECK RUCY_CHECK_OBJ(Reflex::DeviceEvent, self)
+#define CHECK RUCY_CHECK_PTR(Reflex::DeviceEvent, self)
 
 
 static

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

@@ -10,7 +10,7 @@ RUCY_DEFINE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::DrawEvent)
 
 #define THIS  to<Reflex::DrawEvent*>(self)
 
-#define CHECK RUCY_CHECK_OBJ(Reflex::DrawEvent, self)
+#define CHECK RUCY_CHECK_PTR(Reflex::DrawEvent, self)
 
 
 static

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

@@ -8,7 +8,7 @@ RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::EllipseShape)
 
 #define THIS      to<Reflex::EllipseShape*>(self)
 
-#define CHECK     RUCY_CHECK_OBJ(Reflex::EllipseShape, self)
+#define CHECK     RUCY_CHECK_PTR(Reflex::EllipseShape, self)
 
 #define CALL(fun) RUCY_CALL_SUPER(THIS, fun)
 

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

@@ -9,7 +9,7 @@ RUCY_DEFINE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::Event)
 
 #define THIS  to<Reflex::Event*>(self)
 
-#define CHECK RUCY_CHECK_OBJ(Reflex::Event, self)
+#define CHECK RUCY_CHECK_PTR(Reflex::Event, self)
 
 
 static