reflexion 0.5.3 → 0.7.0

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

data/.doc/ext/reflex/gamepad.cpp

@@ -0,0 +1,48 @@
+#include "reflex/ruby/gamepad.h"
+
+
+#include "reflex/ruby/device.h"
+#include "defs.h"
+
+
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::Gamepad)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	Reflex::reflex_error(__FILE__, __LINE__, "can not instantiate Gamepad class.");
+}
+
+static
+VALUE s_enable(VALUE self)
+{
+	Reflex::enable_gamepad();
+}
+
+
+static Class cGamepad;
+
+void
+Init_reflex_gamepad ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cGamepad = mReflex.define_class("Gamepad", Reflex::device_class());
+	rb_define_alloc_func(cGamepad, alloc);
+	rb_define_singleton_method(cGamepad, "enable", RUBY_METHOD_FUNC(s_enable), 0);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	gamepad_class ()
+	{
+		return cGamepad;
+	}
+
+
+}// Reflex

data/.doc/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)
 

data/.doc/ext/reflex/key_event.cpp

@@ -8,7 +8,7 @@ RUCY_DEFINE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::KeyEvent)
 
 #define THIS  to<Reflex::KeyEvent*>(self)
 
-#define CHECK RUCY_CHECK_OBJ(Reflex::KeyEvent, self)
+#define CHECK RUCY_CHECK_PTR(Reflex::KeyEvent, self)
 
 
 static
@@ -47,278 +47,6 @@ VALUE get_action(VALUE self)
 	return value(THIS->action());
 }
 
-static
-VALUE get_key(VALUE self)
-{
-	CHECK;
-	switch (THIS->code())
-	{
-		#define CASE(key)         case Reflex::KEY_##key
-		#define SYMBOL1(name)     SYMBOL2(_##name, #name)
-		#define SYMBOL2(var, sym) {RUCY_SYMBOL(var, sym); return var.value();}
-
-		CASE(A): SYMBOL1(a);
-		CASE(B): SYMBOL1(b);
-		CASE(C): SYMBOL1(c);
-		CASE(D): SYMBOL1(d);
-		CASE(E): SYMBOL1(e);
-		CASE(F): SYMBOL1(f);
-		CASE(G): SYMBOL1(g);
-		CASE(H): SYMBOL1(h);
-		CASE(I): SYMBOL1(i);
-		CASE(J): SYMBOL1(j);
-		CASE(K): SYMBOL1(k);
-		CASE(L): SYMBOL1(l);
-		CASE(M): SYMBOL1(m);
-		CASE(N): SYMBOL1(n);
-		CASE(O): SYMBOL1(o);
-		CASE(P): SYMBOL1(p);
-		CASE(Q): SYMBOL1(q);
-		CASE(R): SYMBOL1(r);
-		CASE(S): SYMBOL1(s);
-		CASE(T): SYMBOL1(t);
-		CASE(U): SYMBOL1(u);
-		CASE(V): SYMBOL1(v);
-		CASE(W): SYMBOL1(w);
-		CASE(X): SYMBOL1(x);
-		CASE(Y): SYMBOL1(y);
-		CASE(Z): SYMBOL1(z);
-
-		CASE(0):
-		CASE(NUM_0): SYMBOL1(0);
-		CASE(1):
-		CASE(NUM_1): SYMBOL1(1);
-		CASE(2):
-		CASE(NUM_2): SYMBOL1(2);
-		CASE(3):
-		CASE(NUM_3): SYMBOL1(3);
-		CASE(4):
-		CASE(NUM_4): SYMBOL1(4);
-		CASE(5):
-		CASE(NUM_5): SYMBOL1(5);
-		CASE(6):
-		CASE(NUM_6): SYMBOL1(6);
-		CASE(7):
-		CASE(NUM_7): SYMBOL1(7);
-		CASE(8):
-		CASE(NUM_8): SYMBOL1(8);
-		CASE(9):
-		CASE(NUM_9): SYMBOL1(9);
-
-		CASE(MINUS):      SYMBOL1(minus);
-		CASE(EQUAL):      SYMBOL1(equal);
-		CASE(COMMA):      SYMBOL1(comma);
-		CASE(PERIOD):     SYMBOL1(period);
-		CASE(SEMICOLON):  SYMBOL1(semicolon);
-		CASE(QUOTE):      SYMBOL1(quote);
-		CASE(SLASH):      SYMBOL1(slash);
-		CASE(BACKSLASH):  SYMBOL1(backslash);
-		CASE(UNDERSCORE): SYMBOL1(underscore);
-		CASE(GRAVE):      SYMBOL1(grave);
-		CASE(YEN):        SYMBOL1(yen);
-		CASE(LBRACKET):   SYMBOL1(lbracket);
-		CASE(RBRACKET):   SYMBOL1(rbracket);
-
-#if defined(OSX) || defined(IOS) || defined(WIN32) || defined(LINUX) || defined(WASM)
-		CASE(ENTER):     SYMBOL1(enter);
-#else
-		CASE(ENTER):     SYMBOL1(enter);
-		CASE(RETURN):    SYMBOL2(_return, "return");
-#endif
-		CASE(SPACE):     SYMBOL1(space);
-		CASE(TAB):       SYMBOL1(tab);
-		CASE(DELETE):    SYMBOL2(_delete, "delete");
-		CASE(BACKSPACE): SYMBOL1(backspace);
-		CASE(INSERT):    SYMBOL1(insert);
-		CASE(ESCAPE):    SYMBOL1(escape);
-
-		CASE(LEFT):     SYMBOL1(left);
-		CASE(RIGHT):    SYMBOL1(right);
-		CASE(UP):       SYMBOL1(up);
-		CASE(DOWN):     SYMBOL1(down);
-		CASE(HOME):     SYMBOL1(home);
-		CASE(END):      SYMBOL1(end);
-		CASE(PAGEUP):   SYMBOL1(pageup);
-		CASE(PAGEDOWN): SYMBOL1(pagedown);
-
-#if !defined(OSX) && !defined(IOS) && !defined(LINUX) && !defined(WASM)
-		CASE(SHIFT):
-#endif
-		CASE(LSHIFT):
-		CASE(RSHIFT):   SYMBOL1(shift);
-#if !defined(OSX) && !defined(IOS) && !defined(LINUX) && !defined(WASM)
-		CASE(CONTROL):
-#endif
-		CASE(LCONTROL):
-		CASE(RCONTROL): SYMBOL1(control);
-		CASE(ALT):
-#if !defined(IOS) && !defined(LINUX) && !defined(WASM)
-		CASE(LALT):
-#endif
-		CASE(RALT):     SYMBOL1(alt);
-		CASE(LWIN):
-		CASE(RWIN):     SYMBOL1(win);
-#if !defined(IOS) && !defined(LINUX) && !defined(WASM)
-		CASE(LCOMMAND):
-		CASE(RCOMMAND): SYMBOL1(command);
-		CASE(LOPTION):
-		CASE(ROPTION):  SYMBOL1(option);
-#endif
-		CASE(FUNCTION): SYMBOL1(function);
-
-		CASE(F1):  SYMBOL1(f1);
-		CASE(F2):  SYMBOL1(f2);
-		CASE(F3):  SYMBOL1(f3);
-		CASE(F4):  SYMBOL1(f4);
-		CASE(F5):  SYMBOL1(f5);
-		CASE(F6):  SYMBOL1(f6);
-		CASE(F7):  SYMBOL1(f7);
-		CASE(F8):  SYMBOL1(f8);
-		CASE(F9):  SYMBOL1(f9);
-		CASE(F10): SYMBOL1(f10);
-		CASE(F11): SYMBOL1(f11);
-		CASE(F12): SYMBOL1(f12);
-		CASE(F13): SYMBOL1(f13);
-		CASE(F14): SYMBOL1(f14);
-		CASE(F15): SYMBOL1(f15);
-		CASE(F16): SYMBOL1(f16);
-		CASE(F17): SYMBOL1(f17);
-		CASE(F18): SYMBOL1(f18);
-		CASE(F19): SYMBOL1(f19);
-		CASE(F20): SYMBOL1(f20);
-		CASE(F21): SYMBOL1(f21);
-		CASE(F22): SYMBOL1(f22);
-		CASE(F23): SYMBOL1(f23);
-		CASE(F24): SYMBOL1(f24);
-
-		CASE(NUM_PLUS):     SYMBOL1(plus);
-		CASE(NUM_MINUS):    SYMBOL1(minus);
-		CASE(NUM_MULTIPLY): SYMBOL1(multiply);
-		CASE(NUM_DIVIDE):   SYMBOL1(divide);
-		CASE(NUM_EQUAL):    SYMBOL1(equal);
-		CASE(NUM_COMMA):    SYMBOL1(comma);
-		CASE(NUM_DECIMAL):  SYMBOL1(decimal);
-#if !defined(IOS) && !defined(LINUX) && !defined(WASM)
-		CASE(NUM_CLEAR):    SYMBOL1(clear);
-#endif
-		CASE(NUM_ENTER):    SYMBOL1(enter);
-
-		CASE(CAPSLOCK):   SYMBOL1(capslock);
-		CASE(NUMLOCK):    SYMBOL1(numlock);
-		CASE(SCROLLLOCK): SYMBOL1(scrolllock);
-
-		CASE(PRINTSCREEN): SYMBOL1(printscreen);
-		CASE(PAUSE):       SYMBOL1(pause);
-		CASE(BREAK):       SYMBOL2(_break, "break");
-		CASE(SECTION):     SYMBOL1(section);
-		CASE(HELP):        SYMBOL1(help);
-
-		CASE(EISU):           SYMBOL1(eisu);
-		CASE(KANA):           SYMBOL1(kana);
-		CASE(KANJI):          SYMBOL1(kanji);
-		CASE(IME_ON):         SYMBOL1(ime_on);
-		CASE(IME_OFF):        SYMBOL1(ime_off);
-		CASE(IME_MODECHANGE): SYMBOL1(ime_mode_change);
-		CASE(CONVERT):        SYMBOL1(convert);
-		CASE(NONCONVERT):     SYMBOL1(nonconvert);
-		CASE(ACCEPT):         SYMBOL1(accept);
-		CASE(PROCESS):        SYMBOL1(process);
-
-		CASE(VOLUME_UP):   SYMBOL1(volume_up);
-		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(NAVIGATION_VIEW):   SYMBOL1(navigation_view);
-		CASE(NAVIGATION_MENU):   SYMBOL1(navigation_menu);
-		CASE(NAVIGATION_UP):     SYMBOL1(navigation_up);
-		CASE(NAVIGATION_DOWN):   SYMBOL1(navigation_down);
-		CASE(NAVIGATION_LEFT):   SYMBOL1(navigation_left);
-		CASE(NAVIGATION_RIGHT):  SYMBOL1(navigation_right);
-		CASE(NAVIGATION_ACCEPT): SYMBOL1(navigation_accept);
-		CASE(NAVIGATION_CANCEL): SYMBOL1(navigation_cancel);
-
-		CASE(BROWSER_BACK):      SYMBOL1(browser_back);
-		CASE(BROWSER_FORWARD):   SYMBOL1(browser_forward);
-		CASE(BROWSER_REFRESH):   SYMBOL1(browser_refresh);
-		CASE(BROWSER_STOP):      SYMBOL1(browser_stop);
-		CASE(BROWSER_SEARCH):    SYMBOL1(browser_search);
-		CASE(BROWSER_FAVORITES): SYMBOL1(browser_favorites);
-		CASE(BROWSER_HOME):      SYMBOL1(browser_home);
-
-		CASE(MEDIA_PREV_TRACK): SYMBOL1(media_prev);
-		CASE(MEDIA_NEXT_TRACK): SYMBOL1(media_next);
-		CASE(MEDIA_PLAY_PAUSE): SYMBOL1(media_play_pause);
-		CASE(MEDIA_STOP):       SYMBOL1(media_stop);
-
-		CASE(LAUNCH_MAIL):         SYMBOL1(launch_mail);
-		CASE(LAUNCH_MEDIA_SELECT): SYMBOL1(launch_media_select);
-		CASE(LAUNCH_APP1):         SYMBOL1(launch_app1);
-		CASE(LAUNCH_APP2):         SYMBOL1(launch_app2);
-
-		CASE(GAMEPAD_LEFT):         SYMBOL1(gamepad_left);
-		CASE(GAMEPAD_RIGHT):        SYMBOL1(gamepad_right);
-		CASE(GAMEPAD_UP):           SYMBOL1(gamepad_up);
-		CASE(GAMEPAD_DOWN):         SYMBOL1(gamepad_down);
-		CASE(GAMEPAD_LSTICK_LEFT):  SYMBOL1(gamepad_lstick_left);
-		CASE(GAMEPAD_LSTICK_RIGHT): SYMBOL1(gamepad_lstick_right);
-		CASE(GAMEPAD_LSTICK_UP):    SYMBOL1(gamepad_lstick_up);
-		CASE(GAMEPAD_LSTICK_DOWN):  SYMBOL1(gamepad_lstick_down);
-		CASE(GAMEPAD_RSTICK_LEFT):  SYMBOL1(gamepad_rstick_left);
-		CASE(GAMEPAD_RSTICK_RIGHT): SYMBOL1(gamepad_rstick_right);
-		CASE(GAMEPAD_RSTICK_UP):    SYMBOL1(gamepad_rstick_up);
-		CASE(GAMEPAD_RSTICK_DOWN):  SYMBOL1(gamepad_rstick_down);
-		CASE(GAMEPAD_A):            SYMBOL1(gamepad_a);
-		CASE(GAMEPAD_B):            SYMBOL1(gamepad_b);
-		CASE(GAMEPAD_X):            SYMBOL1(gamepad_x);
-		CASE(GAMEPAD_Y):            SYMBOL1(gamepad_y);
-		CASE(GAMEPAD_LTRIGGER):     SYMBOL1(gamepad_ltrigger);
-		CASE(GAMEPAD_RTRIGGER):     SYMBOL1(gamepad_rtrigger);
-		CASE(GAMEPAD_LSHOULDER):    SYMBOL1(gamepad_lshoulder);
-		CASE(GAMEPAD_RSHOULDER):    SYMBOL1(gamepad_rshoulder);
-		CASE(GAMEPAD_LTHUMB):       SYMBOL1(gamepad_lthumb);
-		CASE(GAMEPAD_RTHUMB):       SYMBOL1(gamepad_rthumb);
-		CASE(GAMEPAD_LPADDLE_0):    SYMBOL1(gamepad_lpaddle_0);
-		CASE(GAMEPAD_LPADDLE_1):    SYMBOL1(gamepad_lpaddle_1);
-		CASE(GAMEPAD_RPADDLE_0):    SYMBOL1(gamepad_rpaddle_0);
-		CASE(GAMEPAD_RPADDLE_1):    SYMBOL1(gamepad_rpaddle_1);
-		CASE(GAMEPAD_HOME):         SYMBOL1(gamepad_home);
-		CASE(GAMEPAD_MENU):         SYMBOL1(gamepad_menu);
-		CASE(GAMEPAD_OPTION):       SYMBOL1(gamepad_option);
-		CASE(GAMEPAD_SHARE):        SYMBOL1(gamepad_share);
-		CASE(GAMEPAD_START):        SYMBOL1(gamepad_start);
-		CASE(GAMEPAD_SELECT):       SYMBOL1(gamepad_select);
-		CASE(GAMEPAD_BUTTON_TOUCH): SYMBOL1(gamepad_button_touch);
-		CASE(GAMEPAD_BUTTON_0):     SYMBOL1(gamepad_button_0);
-		CASE(GAMEPAD_BUTTON_1):     SYMBOL1(gamepad_button_1);
-		CASE(GAMEPAD_BUTTON_2):     SYMBOL1(gamepad_button_2);
-		CASE(GAMEPAD_BUTTON_3):     SYMBOL1(gamepad_button_3);
-		CASE(GAMEPAD_BUTTON_4):     SYMBOL1(gamepad_button_4);
-		CASE(GAMEPAD_BUTTON_5):     SYMBOL1(gamepad_button_5);
-		CASE(GAMEPAD_BUTTON_6):     SYMBOL1(gamepad_button_6);
-		CASE(GAMEPAD_BUTTON_7):     SYMBOL1(gamepad_button_7);
-		CASE(GAMEPAD_BUTTON_8):     SYMBOL1(gamepad_button_8);
-		CASE(GAMEPAD_BUTTON_9):     SYMBOL1(gamepad_button_9);
-		CASE(GAMEPAD_BUTTON_10):    SYMBOL1(gamepad_button_10);
-		CASE(GAMEPAD_BUTTON_11):    SYMBOL1(gamepad_button_11);
-		CASE(GAMEPAD_BUTTON_12):    SYMBOL1(gamepad_button_12);
-		CASE(GAMEPAD_BUTTON_13):    SYMBOL1(gamepad_button_13);
-		CASE(GAMEPAD_BUTTON_14):    SYMBOL1(gamepad_button_14);
-		CASE(GAMEPAD_BUTTON_15):    SYMBOL1(gamepad_button_15);
-
-		#undef CASE
-		#undef SYMBOL1
-		#undef SYMBOL2
-	}
-	return nil();
-}
-
 static
 VALUE get_chars(VALUE self)
 {
@@ -368,7 +96,6 @@ Init_reflex_key_event ()
 	rb_define_private_method(cKeyEvent, "initialize", RUBY_METHOD_FUNC(initialize), 5);
 	rb_define_private_method(cKeyEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
 	rb_define_method(cKeyEvent, "action", RUBY_METHOD_FUNC(get_action), 0);
-	rb_define_method(cKeyEvent, "key", RUBY_METHOD_FUNC(get_key), 0);
 	rb_define_method(cKeyEvent, "chars", RUBY_METHOD_FUNC(get_chars), 0);
 	rb_define_method(cKeyEvent, "code", RUBY_METHOD_FUNC(get_code), 0);
 	rb_define_method(cKeyEvent, "modifiers", RUBY_METHOD_FUNC(get_modifiers), 0);

data/.doc/ext/reflex/line_shape.cpp

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