reflexion 0.5.3 → 0.7.0

data/ext/reflex/constraint.cpp

@@ -0,0 +1,146 @@
+#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
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	Reflex::reflex_error(
+		__FILE__, __LINE__, "can not instantiate Constraint class");
+}
+RUCY_END
+
+static
+RUCY_DEF0(remove)
+{
+	CHECK;
+	THIS->remove();
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF1(get_pin, index)
+{
+	CHECK;
+	return value(THIS->pin(to<int>(index)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_spring, hertz)
+{
+	CHECK;
+	THIS->set_spring(hertz ? to<float>(hertz) : 0);
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_spring)
+{
+	CHECK;
+	float hertz = THIS->spring();
+	return hertz > 0 ? value(hertz) : nil();
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_damping, ratio)
+{
+	CHECK;
+	THIS->set_damping(to<float>(ratio));
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_damping)
+{
+	CHECK;
+	return value(THIS->damping());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_collide, state)
+{
+	CHECK;
+	THIS->set_collide(to<bool>(state));
+}
+RUCY_END
+
+static
+RUCY_DEF0(can_collide)
+{
+	CHECK;
+	return value(THIS->can_collide());
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_removed)
+{
+	CHECK;
+	return value(THIS->is_removed());
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_active)
+{
+	CHECK;
+	return value(THIS->operator bool());
+}
+RUCY_END
+
+
+static Class cConstraint;
+
+void
+Init_reflex_constraint ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cConstraint = mReflex.define_class("Constraint");
+	cConstraint.define_alloc_func(alloc);
+	cConstraint.define_method("remove", remove);
+	cConstraint.define_private_method("get_pin", get_pin);
+	cConstraint.define_method("spring=",  set_spring);
+	cConstraint.define_method("spring",   get_spring);
+	cConstraint.define_method("damping=", set_damping);
+	cConstraint.define_method("damping",  get_damping);
+	cConstraint.define_method("collide=", set_collide);
+	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/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

data/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/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/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

data/ext/reflex/gamepad.cpp

@@ -0,0 +1,50 @@
+#include "reflex/ruby/gamepad.h"
+
+
+#include "reflex/ruby/device.h"
+#include "defs.h"
+
+
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::Gamepad)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	Reflex::reflex_error(__FILE__, __LINE__, "can not instantiate Gamepad class.");
+}
+RUCY_END
+
+static
+RUCY_DEF0(s_enable)
+{
+	Reflex::enable_gamepad();
+}
+RUCY_END
+
+
+static Class cGamepad;
+
+void
+Init_reflex_gamepad ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cGamepad = mReflex.define_class("Gamepad", Reflex::device_class());
+	cGamepad.define_alloc_func(alloc);
+	cGamepad.define_singleton_method("enable", s_enable);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	gamepad_class ()
+	{
+		return cGamepad;
+	}
+
+
+}// Reflex

data/ext/reflex/image_view.cpp

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