reflexion 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7dfd1c406c7a371f5d109f3d24816c4dce13dc011a91915f790355a779c21020
-  data.tar.gz: 4d42b1ce9f95d72d222a016a41ea216786276b539abd77d6818c4f71d4bf6d9b
+  metadata.gz: 5228288ca6eaf922b07a4e5934fc402f16a79261541db581691fdc77df985a41
+  data.tar.gz: 9a4918d2d0c66b5aec2dda5b4cf9afd080d9c7fd8ef863517791b2bcf34561f4
 SHA512:
-  metadata.gz: e90160117d281ea46b2cf1d2a51e086575f5790154c67059d877c5ec85c3c0c00e34ee7972f70188cb125b08028154f86ba9f61d6ebd5ac55c6614f443ed10d4
-  data.tar.gz: 103874aa03b0f69b65e576c2841c7962d566dfb0642ac3a8041b7bd489a1d5b5a7312822eecb4b078b6738a834e92254297a5c79a39d7e317e9d2f0192b38053
+  metadata.gz: 6520e51eb23b4215b34116fd37b34fe1a06532e554186bf47ac0b956e5f9a71e97d6c7aae4465550e8d4ed86f763e86f605d2e811959fbe42fe50fb253bcfb67
+  data.tar.gz: 371a81c13682e5c6cceda6549fcf2e6378574d3bf4181bcedbf4e09f175a7ba975869d76240692c72ce312de6dc0dec079e11e546aaba4bb86eb0c038c28e085

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

@@ -10,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)
 
@@ -25,7 +25,7 @@ VALUE alloc(VALUE klass)
 static
 VALUE start(VALUE self)
 {
-	CHECK_OBJ;
+	CHECK_PTR;
 	CALL(start());
 	return self;
 }
@@ -68,6 +68,36 @@ VALUE get_menu(VALUE self)
 	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)
 {
@@ -84,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)));
 }
 
@@ -154,6 +181,10 @@ Init_reflex_application ()
 	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

@@ -12,7 +12,7 @@ RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::ChaseConstraint)
 
 #define THIS  to<Reflex::ChaseConstraint*>(self)
 
-#define CHECK RUCY_CHECK_OBJ(Reflex::ChaseConstraint, self)
+#define CHECK RUCY_CHECK_PTR(Reflex::ChaseConstraint, self)
 
 
 static

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

@@ -25,7 +25,7 @@ VALUE get_text(VALUE self)
 {
 	Reflex::Clipboard clipboard = Reflex::get_clipboard();
 	const char* text = clipboard.text();
-	return text ? value(text, rb_utf8_encoding()) : nil();
+	return text ? value(text) : nil();
 }
 
 static

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

@@ -13,7 +13,7 @@ RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::Constraint)
 
 #define THIS  to<Reflex::Constraint*>(self)
 
-#define CHECK RUCY_CHECK_OBJ(Reflex::Constraint, self)
+#define CHECK RUCY_CHECK_PTR(Reflex::Constraint, self)
 
 
 static

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

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

@@ -0,0 +1,181 @@
+#include "reflex/ruby/file_dialog.h"
+
+
+#include "reflex/ruby/window.h"
+#include "defs.h"
+
+
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::FileDialog)
+
+#define THIS      to<Reflex::FileDialog*>(self)
+
+#define CHECK     RUCY_CHECK_OBJ(Reflex::FileDialog, self)
+
+#define CALL(fun) RUCY_CALL_SUPER(THIS, fun)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return value(new Reflex::RubyFileDialog<Reflex::FileDialog>, klass);
+}
+
+static
+VALUE open_file(VALUE self, VALUE dir)
+{
+	CHECK;
+	THIS->open_file(dir.is_nil() ? NULL : dir.c_str());
+	return self;
+}
+
+static
+VALUE open_files(VALUE self, VALUE dir)
+{
+	CHECK;
+	THIS->open_files(dir.is_nil() ? NULL : dir.c_str());
+	return self;
+}
+
+static
+VALUE open_directory(VALUE self, VALUE dir)
+{
+	CHECK;
+	THIS->open_directory(dir.is_nil() ? NULL : dir.c_str());
+	return self;
+}
+
+static
+VALUE save_file(VALUE self, VALUE dir, VALUE name)
+{
+	CHECK;
+	THIS->save_file(
+		dir.is_nil()  ? NULL : dir.c_str(),
+		name.is_nil() ? NULL : name.c_str());
+	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_title(VALUE self, VALUE title)
+{
+	CHECK;
+	THIS->set_title(title.c_str());
+	return title;
+}
+
+static
+VALUE get_title(VALUE self)
+{
+	CHECK;
+	return value(THIS->title());
+}
+
+static
+VALUE set_extensions(VALUE self, VALUE extensions)
+{
+	CHECK;
+
+	Reflex::StringList list;
+	if (extensions.is_nil())
+		;// emplace nothing
+	else if (extensions.is_s() || extensions.is_sym())
+		list.emplace_back(extensions.c_str());
+	else if (extensions.is_array())
+	{
+		size_t size = extensions.size();
+		for (size_t i = 0; i < size; ++i)
+		{
+			if (!extensions[i].is_s() && !extensions[i].is_sym())
+				argument_error(__FILE__, __LINE__);
+
+			list.emplace_back(extensions[i].c_str());
+		}
+	}
+	else
+		argument_error(__FILE__, __LINE__);
+
+	THIS->set_extensions(list);
+	return extensions;
+}
+
+static
+VALUE get_extensions(VALUE self)
+{
+	CHECK;
+
+	const auto& extensions = THIS->extensions();
+
+	Value values = array(NULL, extensions.size());
+	for (const auto& extension : extensions)
+		values.push(extension.c_str());
+
+	return values;
+}
+
+static
+VALUE on_file(VALUE self, VALUE event)
+{
+	CHECK;
+
+	CALL(on_file(to<Reflex::FileEvent*>(event)));
+}
+
+static
+VALUE on_cancel(VALUE self, VALUE event)
+{
+	CHECK;
+
+	CALL(on_cancel(to<Reflex::Event*>(event)));
+}
+
+
+static Class cFileDialog;
+
+void
+Init_reflex_file_dialog ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cFileDialog = rb_define_class_under(mReflex, "FileDialog", rb_cObject);
+	rb_define_alloc_func(cFileDialog, alloc);
+	cFileDialog.define_method("open_file!",      open_file);
+	cFileDialog.define_method("open_files!",     open_files);
+	cFileDialog.define_method("open_directory!", open_directory);
+	cFileDialog.define_method("save_file!",      save_file);
+	rb_define_method(cFileDialog, "owner=", RUBY_METHOD_FUNC(set_owner), 1);
+	rb_define_method(cFileDialog, "owner", RUBY_METHOD_FUNC(get_owner), 0);
+	rb_define_method(cFileDialog, "title=", RUBY_METHOD_FUNC(set_title), 1);
+	rb_define_method(cFileDialog, "title", RUBY_METHOD_FUNC(get_title), 0);
+	rb_define_method(cFileDialog, "extensions=", RUBY_METHOD_FUNC(set_extensions), 1);
+	rb_define_method(cFileDialog, "extensions", RUBY_METHOD_FUNC(get_extensions), 0);
+	rb_define_method(cFileDialog, "on_file", RUBY_METHOD_FUNC(on_file), 1);
+	rb_define_method(cFileDialog, "on_cancel", RUBY_METHOD_FUNC(on_cancel), 1);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	file_dialog_class ()
+	{
+		return cFileDialog;
+	}
+
+
+}// Reflex

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

@@ -0,0 +1,103 @@
+#include "reflex/ruby/event.h"
+
+
+#include "defs.h"
+
+
+RUCY_DEFINE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::FileEvent)
+
+#define THIS  to<Reflex::FileEvent*>(self)
+
+#define CHECK RUCY_CHECK_PTR(Reflex::FileEvent, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Reflex::FileEvent>(klass);
+}
+
+static
+VALUE initialize(VALUE self, VALUE action, VALUE paths)
+{
+	CHECK;
+
+	if (!paths.is_array())
+		argument_error(__FILE__, __LINE__);
+
+	Reflex::StringList list;
+	int size = paths.size();
+	for (int i = 0; i < size; ++i)
+	{
+		if (paths[i].is_nil())
+			argument_error(__FILE__, __LINE__);
+
+		list.emplace_back(paths[i].c_str());
+	}
+	*THIS = Reflex::FileEvent((Reflex::FileEvent::Action) to<uint>(action), list);
+
+	return rb_call_super(0, NULL);
+}
+
+static
+VALUE initialize_copy(VALUE self, VALUE obj)
+{
+	CHECK;
+	*THIS = to<Reflex::FileEvent&>(obj).dup();
+	return self;
+}
+
+static
+VALUE get_action(VALUE self)
+{
+	CHECK;
+	return value(THIS->action());
+}
+
+static
+VALUE get_paths(VALUE self)
+{
+	CHECK;
+
+	const Reflex::StringList& paths = THIS->paths();
+
+	Value values = array(NULL, paths.size());
+	for (const auto& path : paths)
+		values.push(path.c_str());
+
+	return values;
+}
+
+
+static Class cFileEvent;
+
+void
+Init_reflex_file_event ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cFileEvent = mReflex.define_class("FileEvent", Reflex::event_class());
+	rb_define_alloc_func(cFileEvent, alloc);
+	rb_define_private_method(cFileEvent, "initialize", RUBY_METHOD_FUNC(initialize), 2);
+	rb_define_private_method(cFileEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+	rb_define_method(cFileEvent, "action", RUBY_METHOD_FUNC(get_action), 0);
+	rb_define_method(cFileEvent, "paths", RUBY_METHOD_FUNC(get_paths), 0);
+
+	cFileEvent.define_const("ACTION_NONE", Reflex::FileEvent::ACTION_NONE);
+	cFileEvent.define_const("OPEN",        Reflex::FileEvent::OPEN);
+	cFileEvent.define_const("SAVE",        Reflex::FileEvent::SAVE);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	file_event_class ()
+	{
+		return cFileEvent;
+	}
+
+
+}// Reflex

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

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

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

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

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

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