reflexion 0.6.0 → 0.7.0

data/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)
 
@@ -26,7 +26,7 @@ RUCY_END
 static
 RUCY_DEF0(start)
 {
-	CHECK_OBJ;
+	CHECK_PTR;
 	CALL(start());
 	return self;
 }
@@ -75,6 +75,40 @@ RUCY_DEF0(get_menu)
 }
 RUCY_END
 
+static
+RUCY_DEF1(set_background, state)
+{
+	CHECK;
+	THIS->set_background(to<bool>(state));
+	return state;
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_background)
+{
+	CHECK;
+	return value(THIS->background());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_background_menu, menu)
+{
+	CHECK;
+	THIS->set_background_menu(menu ? to<Reflex::Menu*>(menu) : NULL);
+	return menu;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_background_menu)
+{
+	CHECK;
+	return value(THIS->background_menu());
+}
+RUCY_END
+
 static
 RUCY_DEF0(each_window)
 {
@@ -92,9 +126,6 @@ RUCY_DEF1(on_start, event)
 {
 	CHECK;
 
-	RUCY_SYM(call_start_block);
-	self.call(call_start_block);
-
 	CALL(on_start(to<Reflex::Event*>(event)));
 }
 RUCY_END
@@ -170,6 +201,10 @@ Init_reflex_application ()
 	cApplication.define_method("name",  get_name);
 	cApplication.define_method("menu=", set_menu);
 	cApplication.define_method("menu",  get_menu);
+	cApplication.define_method("background=",      set_background);
+	cApplication.define_method("background?",       is_background);
+	cApplication.define_method("background_menu=", set_background_menu);
+	cApplication.define_method("background_menu",  get_background_menu);
 	cApplication.define_method("each_window", each_window);
 	cApplication.define_method("on_start", on_start);
 	cApplication.define_method("on_quit",  on_quit);

data/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/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/ext/reflex/clipboard.cpp

@@ -27,7 +27,7 @@ RUCY_DEF0(get_text)
 {
 	Reflex::Clipboard clipboard = Reflex::get_clipboard();
 	const char* text = clipboard.text();
-	return text ? value(text, rb_utf8_encoding()) : nil();
+	return text ? value(text) : nil();
 }
 RUCY_END
 

data/ext/reflex/color_event.cpp

@@ -0,0 +1,80 @@
+#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
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Reflex::ColorEvent>(klass);
+}
+RUCY_END
+
+static
+RUCY_DEF1(initialize, color)
+{
+	CHECK;
+
+	if (color.is_nil())
+		argument_error(__FILE__, __LINE__);
+
+	*THIS = Reflex::ColorEvent(to<Rays::Color>(color));
+
+	return rb_call_super(0, NULL);
+}
+RUCY_END
+
+static
+RUCY_DEF1(initialize_copy, obj)
+{
+	CHECK;
+	*THIS = to<Reflex::ColorEvent&>(obj).dup();
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_color)
+{
+	CHECK;
+	return value(THIS->color());
+}
+RUCY_END
+
+
+static Class cColorEvent;
+
+void
+Init_reflex_color_event ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cColorEvent = mReflex.define_class("ColorEvent", Reflex::event_class());
+	cColorEvent.define_alloc_func(alloc);
+	cColorEvent.define_private_method("initialize",      initialize);
+	cColorEvent.define_private_method("initialize_copy", initialize_copy);
+	cColorEvent.define_method("color", get_color);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	color_event_class ()
+	{
+		return cColorEvent;
+	}
+
+
+}// Reflex

data/ext/reflex/color_picker.cpp

@@ -0,0 +1,121 @@
+#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
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return value(new Reflex::RubyColorPicker<Reflex::ColorPicker>, klass);
+}
+RUCY_END
+
+static
+RUCY_DEF1(pick_color, initial)
+{
+	CHECK;
+
+	if (initial.is_nil())
+		THIS->pick_color();
+	else
+		THIS->pick_color(to<Rays::Color>(initial));
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_owner, owner)
+{
+	CHECK;
+	THIS->set_owner(owner.is_nil() ? NULL : to<Reflex::Window*>(owner));
+	return owner;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_owner)
+{
+	CHECK;
+	return value(THIS->owner());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_alpha, state)
+{
+	CHECK;
+	THIS->set_alpha(to<bool>(state));
+	return state;
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_alpha)
+{
+	CHECK;
+	return value(THIS->alpha());
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_color, event)
+{
+	CHECK;
+
+	CALL(on_color(to<Reflex::ColorEvent*>(event)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_close, event)
+{
+	CHECK;
+
+	CALL(on_close(to<Reflex::Event*>(event)));
+}
+RUCY_END
+
+
+static Class cColorPicker;
+
+void
+Init_reflex_color_picker ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cColorPicker = mReflex.define_class("ColorPicker");
+	cColorPicker.define_alloc_func(alloc);
+	cColorPicker.define_method("pick_color!", pick_color);
+	cColorPicker.define_method("owner=", set_owner);
+	cColorPicker.define_method("owner",  get_owner);
+	cColorPicker.define_method("alpha=", set_alpha);
+	cColorPicker.define_method("alpha?",  is_alpha);
+	cColorPicker.define_method("on_color", on_color);
+	cColorPicker.define_method("on_close", on_close);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	color_picker_class ()
+	{
+		return cColorPicker;
+	}
+
+
+}// Reflex

data/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/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/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/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/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/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/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/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/ext/reflex/extconf.rb

@@ -13,8 +13,10 @@ require 'reflex/extension'
 Xot::ExtConf.new Xot, Rucy, Rays, Reflex do
   setup do
     headers    << 'ruby.h'
-    libs.unshift 'gdi32', 'winmm', 'opengl32', 'glew32', 'xinput' if win32?
-    frameworks << 'Cocoa' << 'GameController'                     if osx?
+    libs.unshift(
+      'gdi32', 'ole32', 'imm32', 'shell32', 'comdlg32', 'opengl32', 'glew32',
+      'version', 'dwmapi', 'uuid', 'winmm', 'xinput1_4')          if win32?
+    frameworks.concat %w[Cocoa GameController CoreAudio CoreMIDI] if osx?
     $LDFLAGS   << ' -Wl,--out-implib=libreflex.dll.a'             if mingw? || cygwin?
   end
 

data/ext/reflex/file_dialog.cpp

@@ -0,0 +1,194 @@
+#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
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return value(new Reflex::RubyFileDialog<Reflex::FileDialog>, klass);
+}
+RUCY_END
+
+static
+RUCY_DEF1(open_file, dir)
+{
+	CHECK;
+	THIS->open_file(dir.is_nil() ? NULL : dir.c_str());
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF1(open_files, dir)
+{
+	CHECK;
+	THIS->open_files(dir.is_nil() ? NULL : dir.c_str());
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF1(open_directory, dir)
+{
+	CHECK;
+	THIS->open_directory(dir.is_nil() ? NULL : dir.c_str());
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF2(save_file, dir, name)
+{
+	CHECK;
+	THIS->save_file(
+		dir.is_nil()  ? NULL : dir.c_str(),
+		name.is_nil() ? NULL : name.c_str());
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_owner, owner)
+{
+	CHECK;
+	THIS->set_owner(owner.is_nil() ? NULL : to<Reflex::Window*>(owner));
+	return owner;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_owner)
+{
+	CHECK;
+	return value(THIS->owner());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_title, title)
+{
+	CHECK;
+	THIS->set_title(title.c_str());
+	return title;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_title)
+{
+	CHECK;
+	return value(THIS->title());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_extensions, 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;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_extensions)
+{
+	CHECK;
+
+	const auto& extensions = THIS->extensions();
+
+	Value values = array(NULL, extensions.size());
+	for (const auto& extension : extensions)
+		values.push(extension.c_str());
+
+	return values;
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_file, event)
+{
+	CHECK;
+
+	CALL(on_file(to<Reflex::FileEvent*>(event)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_cancel, event)
+{
+	CHECK;
+
+	CALL(on_cancel(to<Reflex::Event*>(event)));
+}
+RUCY_END
+
+
+static Class cFileDialog;
+
+void
+Init_reflex_file_dialog ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cFileDialog = mReflex.define_class("FileDialog");
+	cFileDialog.define_alloc_func(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);
+	cFileDialog.define_method("owner=", set_owner);
+	cFileDialog.define_method("owner",  get_owner);
+	cFileDialog.define_method("title=", set_title);
+	cFileDialog.define_method("title",  get_title);
+	cFileDialog.define_method("extensions=", set_extensions);
+	cFileDialog.define_method("extensions",  get_extensions);
+	cFileDialog.define_method("on_file",   on_file);
+	cFileDialog.define_method("on_cancel", on_cancel);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	file_dialog_class ()
+	{
+		return cFileDialog;
+	}
+
+
+}// Reflex

data/ext/reflex/file_event.cpp

@@ -0,0 +1,108 @@
+#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
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Reflex::FileEvent>(klass);
+}
+RUCY_END
+
+static
+RUCY_DEF2(initialize, action, 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);
+}
+RUCY_END
+
+static
+RUCY_DEF1(initialize_copy, obj)
+{
+	CHECK;
+	*THIS = to<Reflex::FileEvent&>(obj).dup();
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_action)
+{
+	CHECK;
+	return value(THIS->action());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_paths)
+{
+	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;
+}
+RUCY_END
+
+
+static Class cFileEvent;
+
+void
+Init_reflex_file_event ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cFileEvent = mReflex.define_class("FileEvent", Reflex::event_class());
+	cFileEvent.define_alloc_func(alloc);
+	cFileEvent.define_private_method("initialize",      initialize);
+	cFileEvent.define_private_method("initialize_copy", initialize_copy);
+	cFileEvent.define_method("action", get_action);
+	cFileEvent.define_method("paths",  get_paths);
+
+	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