reflexion 0.5.2 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b6222aa69aa05923ed1970d9bab4065e1c452bcbed101cfded2eb112c2ec224e
-  data.tar.gz: da09eb039834c9673114872cf9461b44c6141ea895ec403c80ffe438e103657d
+  metadata.gz: 7dfd1c406c7a371f5d109f3d24816c4dce13dc011a91915f790355a779c21020
+  data.tar.gz: 4d42b1ce9f95d72d222a016a41ea216786276b539abd77d6818c4f71d4bf6d9b
 SHA512:
-  metadata.gz: ac0b559b2120b13f9434ea02d7ff305576c538eb40ea27059ab184277b5588526c54ba0996ec6605735bfe6d4f38870657145f2337d642b69ad168a84f992f89
-  data.tar.gz: 1a1692e6a5b0cccec1c4fddfab74187bfdcd3fa588501d8d54d528a6975c378f3825e9ce843e7c49513e475ada82a45df181fe28275eed5161dddc43e16e0ad8
+  metadata.gz: e90160117d281ea46b2cf1d2a51e086575f5790154c67059d877c5ec85c3c0c00e34ee7972f70188cb125b08028154f86ba9f61d6ebd5ac55c6614f443ed10d4
+  data.tar.gz: 103874aa03b0f69b65e576c2841c7962d566dfb0642ac3a8041b7bd489a1d5b5a7312822eecb4b078b6738a834e92254297a5c79a39d7e317e9d2f0192b38053

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"
 
@@ -52,6 +53,21 @@ 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 each_window(VALUE self)
 {
@@ -59,7 +75,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;
 }
 
@@ -136,6 +152,8 @@ 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, "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/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_OBJ(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, rb_utf8_encoding()) : 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/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_OBJ(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/key_event.cpp

@@ -228,12 +228,12 @@ VALUE get_key(VALUE self)
 		CASE(VOLUME_DOWN): SYMBOL1(volume_down);
 		CASE(MUTE):        SYMBOL1(mute);
 
-		CASE(SLEEP):  SYMBOL1(sleep);
-		CASE(EXEC):   SYMBOL1(exec);
-		CASE(PRINT):  SYMBOL1(print);
-		CASE(APPS):   SYMBOL1(apps);
-		CASE(SELECT): SYMBOL1(select);
-		CASE(CLEAR):  SYMBOL1(clear);
+		CASE(SLEEP):        SYMBOL1(sleep);
+		CASE(EXEC):         SYMBOL1(exec);
+		CASE(PRINT):        SYMBOL1(print);
+		CASE(CONTEXT_MENU): SYMBOL1(context_menu);
+		CASE(SELECT):       SYMBOL1(select);
+		CASE(CLEAR):        SYMBOL1(clear);
 
 		CASE(NAVIGATION_VIEW):   SYMBOL1(navigation_view);
 		CASE(NAVIGATION_MENU):   SYMBOL1(navigation_menu);

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

@@ -0,0 +1,178 @@
+#include "reflex/ruby/constraint.h"
+
+
+#include <rays/ruby/point.h>
+#include "reflex/exception.h"
+#include "defs.h"
+
+
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::LinkConstraint)
+
+#define THIS  to<Reflex::LinkConstraint*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::LinkConstraint, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	Reflex::reflex_error(
+		__FILE__, __LINE__, "can not instantiate LinkConstraint class");
+}
+
+static
+VALUE set_axis(VALUE self)
+{
+	CHECK;
+	if (argc == 1 && argv[0].is_nil())
+		THIS->clear_axis();
+	else
+		THIS->set_axis(to<Rays::Point>(argc, argv));
+}
+
+static
+VALUE get_axis(VALUE self)
+{
+	CHECK;
+	return THIS->has_axis() ? value(THIS->axis()) : nil();
+}
+
+static
+VALUE set_distance(VALUE self, VALUE distance)
+{
+	CHECK;
+	if (distance.is_nil())
+		THIS->clear_distance();
+	else
+		THIS->set_distance(to<coord>(distance));
+}
+
+static
+VALUE get_distance(VALUE self)
+{
+	CHECK;
+	return value(THIS->distance());
+}
+
+static
+VALUE has_distance(VALUE self)
+{
+	CHECK;
+	return value(THIS->has_distance());
+}
+
+static
+VALUE current_distance(VALUE self)
+{
+	CHECK;
+	return value(THIS->current_distance());
+}
+
+static
+VALUE set_range(VALUE self, VALUE min, VALUE max)
+{
+	CHECK;
+	THIS->set_range(to<coord>(min), to<coord>(max));
+}
+
+static
+VALUE clear_range(VALUE self)
+{
+	CHECK;
+	THIS->clear_range();
+}
+
+static
+VALUE range_min(VALUE self)
+{
+	CHECK;
+	return value(THIS->range_min());
+}
+
+static
+VALUE range_max(VALUE self)
+{
+	CHECK;
+	return value(THIS->range_max());
+}
+
+static
+VALUE has_range(VALUE self)
+{
+	CHECK;
+	return value(THIS->has_range());
+}
+
+static
+VALUE set_motor(VALUE self, VALUE pixels_per_second)
+{
+	CHECK;
+	if (pixels_per_second.is_nil())
+		THIS->clear_motor();
+	else
+		THIS->set_motor(to<coord>(pixels_per_second));
+}
+
+static
+VALUE get_motor(VALUE self)
+{
+	CHECK;
+	return THIS->has_motor() ? value(THIS->motor()) : nil();
+}
+
+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 cLinkConstraint;
+
+void
+Init_reflex_link_constraint ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cLinkConstraint = mReflex.define_class("LinkConstraint", Reflex::constraint_class());
+	rb_define_alloc_func(cLinkConstraint, alloc);
+	rb_define_method(cLinkConstraint, "axis=", RUBY_METHOD_FUNC(set_axis), -1);
+	rb_define_method(cLinkConstraint, "axis", RUBY_METHOD_FUNC(get_axis), 0);
+	rb_define_method(cLinkConstraint, "distance=", RUBY_METHOD_FUNC(set_distance), 1);
+	rb_define_method(cLinkConstraint, "distance", RUBY_METHOD_FUNC(get_distance), 0);
+	rb_define_method(cLinkConstraint, "current_distance", RUBY_METHOD_FUNC(current_distance), 0);
+	cLinkConstraint.define_private_method(  "set_range!",   set_range);
+	cLinkConstraint.define_private_method("clear_range!", clear_range);
+	cLinkConstraint.define_private_method(      "range_min!",   range_min);
+	cLinkConstraint.define_private_method(      "range_max!",   range_max);
+	cLinkConstraint.define_private_method(  "has_range!",   has_range);
+	rb_define_method(cLinkConstraint, "motor=", RUBY_METHOD_FUNC(set_motor), 1);
+	rb_define_method(cLinkConstraint, "motor", RUBY_METHOD_FUNC(get_motor), 0);
+	rb_define_method(cLinkConstraint, "force=", RUBY_METHOD_FUNC(set_force), 1);
+	rb_define_method(cLinkConstraint, "force", RUBY_METHOD_FUNC(get_force), 0);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	link_constraint_class ()
+	{
+		return cLinkConstraint;
+	}
+
+
+}// Reflex