reflexion 0.3.4 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 92e1368f44fafa2ab8966bfec25f93af411b68a72eaf3f127bc6b95b97ba2fed
-  data.tar.gz: 6efaa218301242d6c4fea24062f9fd9d74f405e46a347eac1b231d6fe08a16c1
+  metadata.gz: 6208109e523193e989fd8aab8deb156b0cedac3f2d686104e44dec97c4cc9a5e
+  data.tar.gz: 8b9060b45cd8f0a2603411895d7739f7ba4df40e21d03ab9f78d4e3fbb09133f
 SHA512:
-  metadata.gz: 3886ea311fccd85da0e7e3868771d61d32f10fd091612bf306df041dbbe2cf30490e3e6a5fa9cdc049e6cf41f3b8e090ea7af950753dff81db95548ffcb7df99
-  data.tar.gz: 1704f273a82ebd9b8272e7358c6936b81171a969ad1a6f085ad641dc0f833dfeb5b97d4f5cf71e80be8d00d9b7bdbc5cb4bdba9d2c9e1228ebb6b995e7903444
+  metadata.gz: e90800b628b22f0b174ba433acfddc5232687408e6845880eed7e898f03e417906f381b7d58c7c01e19dbe7965738f1ee43bf9594a2329c83a97c84ad5f843ec
+  data.tar.gz: fbc4b887c236dce6096fb8ab1ded816da3a4c08a2c5873f2826fc044d02dae123004e9c7d8da3b5999410b906cbaafbd742c07198bae71027ddd80259d25e212

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

@@ -81,6 +81,20 @@ VALUE on_quit(VALUE self, VALUE event)
 	CALL(on_quit(to<Reflex::Event*>(event)));
 }
 
+static
+VALUE on_device_connect(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_device_connect(to<Reflex::DeviceEvent*>(event)));
+}
+
+static
+VALUE on_device_disconnect(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_device_disconnect(to<Reflex::DeviceEvent*>(event)));
+}
+
 static
 VALUE on_motion(VALUE self, VALUE event)
 {
@@ -125,6 +139,8 @@ Init_reflex_application ()
 	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);
+	rb_define_method(cApplication, "on_device_connect", RUBY_METHOD_FUNC(on_device_connect), 1);
+	rb_define_method(cApplication, "on_device_disconnect", RUBY_METHOD_FUNC(on_device_disconnect), 1);
 	rb_define_method(cApplication, "on_motion", RUBY_METHOD_FUNC(on_motion), 1);
 	rb_define_method(cApplication, "on_preference", RUBY_METHOD_FUNC(on_preference), 1);
 	rb_define_method(cApplication, "on_about", RUBY_METHOD_FUNC(on_about), 1);

data/.doc/ext/reflex/device.cpp

@@ -1,19 +1,62 @@
-#include "reflex/device.h"
+#include "reflex/ruby/device.h"
+
+
 #include "defs.h"
 
 
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::Device)
+
+#define THIS  to<Reflex::Device*>(self)
+
+#define CHECK RUCY_CHECK_OBJECT(Reflex::Device, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	Reflex::reflex_error(__FILE__, __LINE__, "can not instantiate Device class.");
+}
+
+static
+VALUE name(VALUE self)
+{
+	CHECK;
+	return value(THIS->name());
+}
+
+
 static
-VALUE vibrate(VALUE self)
+VALUE s_vibrate(VALUE self)
 {
 	Reflex::vibrate();
 	return self;
 }
 
 
+static Class cDevice;
+
 void
 Init_reflex_device ()
 {
 	Module mReflex = rb_define_module("Reflex");
 
-	rb_define_singleton_method(mReflex, "vibrate", RUBY_METHOD_FUNC(vibrate), 0);
+	cDevice = mReflex.define_class("Device", Reflex::device_class());
+	rb_define_alloc_func(cDevice, alloc);
+	rb_define_method(cDevice, "name", RUBY_METHOD_FUNC(name), 0);
+
+	rb_define_singleton_method(mReflex, "vibrate", RUBY_METHOD_FUNC(s_vibrate), 0);
 }
+
+
+namespace Reflex
+{
+
+
+	Class
+	device_class ()
+	{
+		return cDevice;
+	}
+
+
+}// Reflex

data/.doc/ext/reflex/device_event.cpp

@@ -0,0 +1,62 @@
+#include "reflex/ruby/event.h"
+
+
+#include "reflex/ruby/device.h"
+#include "defs.h"
+
+
+RUCY_DEFINE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::DeviceEvent)
+
+#define THIS  to<Reflex::DeviceEvent*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::DeviceEvent, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Reflex::DeviceEvent>(klass);
+}
+
+static
+VALUE initialize_copy(VALUE self, VALUE obj)
+{
+	CHECK;
+	*THIS = to<Reflex::DeviceEvent&>(obj).dup();
+	return self;
+}
+
+static
+VALUE get_device(VALUE self)
+{
+	CHECK;
+	return value(THIS->device());
+}
+
+
+static Class cDeviceEvent;
+
+void
+Init_reflex_device_event ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cDeviceEvent = mReflex.define_class("DeviceEvent", Reflex::event_class());
+	rb_define_alloc_func(cDeviceEvent, alloc);
+	rb_define_private_method(cDeviceEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+	rb_define_method(cDeviceEvent, "device", RUBY_METHOD_FUNC(get_device), 0);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	device_event_class ()
+	{
+		return cDeviceEvent;
+	}
+
+
+}// Reflex

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

@@ -256,6 +256,56 @@ VALUE get_key(VALUE self)
 		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

data/.doc/ext/reflex/native.cpp

@@ -4,6 +4,7 @@
 void Init_reflex ();
 void Init_reflex_exception ();
 
+void Init_reflex_pointer ();
 void Init_reflex_selector ();
 void Init_reflex_style ();
 void Init_reflex_style_length ();
@@ -11,19 +12,19 @@ void Init_reflex_timer ();
 void Init_reflex_filter ();
 
 void Init_reflex_event ();
-void Init_reflex_motion_event ();
+void Init_reflex_device_event ();
 void Init_reflex_update_event ();
 void Init_reflex_draw_event ();
 void Init_reflex_frame_event ();
 void Init_reflex_scroll_event ();
 void Init_reflex_focus_event ();
 void Init_reflex_key_event ();
-void Init_reflex_pointer ();
 void Init_reflex_pointer_event ();
 void Init_reflex_wheel_event ();
 void Init_reflex_capture_event ();
 void Init_reflex_timer_event ();
 void Init_reflex_contact_event ();
+void Init_reflex_motion_event ();
 
 void Init_reflex_shape ();
 void Init_reflex_polygon_shape ();
@@ -55,6 +56,7 @@ extern "C" void
 	Init_reflex();
 	Init_reflex_exception();
 
+	Init_reflex_pointer();
 	Init_reflex_selector();
 	Init_reflex_style();
 	Init_reflex_style_length();
@@ -62,19 +64,19 @@ extern "C" void
 	Init_reflex_filter();
 
 	Init_reflex_event();
-	Init_reflex_motion_event();
+	Init_reflex_device_event();
 	Init_reflex_update_event();
 	Init_reflex_draw_event();
 	Init_reflex_frame_event();
 	Init_reflex_scroll_event();
 	Init_reflex_focus_event();
 	Init_reflex_key_event();
-	Init_reflex_pointer();
 	Init_reflex_pointer_event();
 	Init_reflex_wheel_event();
 	Init_reflex_capture_event();
 	Init_reflex_timer_event();
 	Init_reflex_contact_event();
+	Init_reflex_motion_event();
 
 	Init_reflex_shape();
 	Init_reflex_polygon_shape();

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

@@ -249,6 +249,30 @@ Init_reflex ()
 	DEFINE_CONST(KEY_LAUNCH_APP1);
 	DEFINE_CONST(KEY_LAUNCH_APP2);
 
+	DEFINE_CONST(KEY_GAMEPAD_LEFT);
+	DEFINE_CONST(KEY_GAMEPAD_RIGHT);
+	DEFINE_CONST(KEY_GAMEPAD_UP);
+	DEFINE_CONST(KEY_GAMEPAD_DOWN);
+
+	DEFINE_CONST(KEY_GAMEPAD_A);
+	DEFINE_CONST(KEY_GAMEPAD_B);
+	DEFINE_CONST(KEY_GAMEPAD_X);
+	DEFINE_CONST(KEY_GAMEPAD_Y);
+
+	DEFINE_CONST(KEY_GAMEPAD_LSHOULDER);
+	DEFINE_CONST(KEY_GAMEPAD_RSHOULDER);
+	DEFINE_CONST(KEY_GAMEPAD_LTRIGGER);
+	DEFINE_CONST(KEY_GAMEPAD_RTRIGGER);
+	DEFINE_CONST(KEY_GAMEPAD_LTHUMB);
+	DEFINE_CONST(KEY_GAMEPAD_RTHUMB);
+
+	DEFINE_CONST(KEY_GAMEPAD_HOME);
+	DEFINE_CONST(KEY_GAMEPAD_MENU);
+	DEFINE_CONST(KEY_GAMEPAD_OPTION);
+	DEFINE_CONST(KEY_GAMEPAD_SHARE);
+	DEFINE_CONST(KEY_GAMEPAD_START);
+	DEFINE_CONST(KEY_GAMEPAD_SELECT);
+
 	DEFINE_CONST(MOD_SHIFT);
 	DEFINE_CONST(MOD_CONTROL);
 	DEFINE_CONST(MOD_ALT);

data/.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,12 @@
+## Pull Requests Not Accepted 🚫
+
+Thank you for your interest in contributing!
+However, this repository does not accept pull requests directly.
+
+### Where to Contribute?
+
+Please submit your changes to the [xord/all](https://github.com/xord/all) monorepo, which serves as the primary repository for all our main libraries.
+
+For more details, please refer to our [contribution guidelines](../CONTRIBUTING.md).
+
+Thanks for your understanding! 🙌

data/CONTRIBUTING.md

@@ -0,0 +1,7 @@
+# Contribution Guide
+
+Thank you for your interest in contributing!
+However, this repository does not accept pull requests.
+Instead, please submit your changes to the [xord/all](https://github.com/xord/all) monorepo, which serves as the primary repository for all our main libraries.
+
+For any questions, feel free to open an issue.

data/ChangeLog.md

@@ -1,6 +1,26 @@
 # reflex ChangeLog
 
 
+## [v0.3.6] - 2025-04-08
+
+- Add Gamepad class
+- Add Device and DeviceEvent classes
+- Add Application#on_device_connect/disconnect
+- Add Application_call_start() and Application_call_quit()
+
+
+## [v0.3.5] - 2025-03-24
+
+- Add PULL_REQUEST_TEMPLATE.md
+- Add CONTRIBUTING.md
+- Handle gamepad events on macOS, iOS, and Win32
+- Call activate/deactivate event for window on Win32
+- Define constants for gamepad keys
+- Delay removing child to avoid breaking child list looped on View_update_tree()
+
+- Fix a crash caused by add/remove_child()
+
+
 ## [v0.3.4] - 2025-03-07
 
 - Captured key and pointer events can be blocked before being sent to the window and views

data/README.md

@@ -1,4 +1,48 @@
-
 # Reflex - A Graphical User Interface Tool Kit for Ruby.
 
- by xordog@gmail.com
+![License](https://img.shields.io/github/license/xord/reflex)
+![Build Status](https://github.com/xord/reflex/actions/workflows/test.yml/badge.svg)
+![Gem Version](https://badge.fury.io/rb/reflexion.svg)
+
+## ⚠️  Notice
+
+This repository is a read-only mirror of our monorepo.
+We do not accept pull requests or direct contributions here.
+
+### 🔄 Where to Contribute?
+
+All development happens in our [xord/all](https://github.com/xord/all) monorepo, which contains all our main libraries.
+If you'd like to contribute, please submit your changes there.
+
+For more details, check out our [Contribution Guidelines](./CONTRIBUTING.md).
+
+Thanks for your support! 🙌
+
+## 🚀 About
+
+**Reflex** is a graphical user interface (GUI) toolkit for Ruby.
+
+It is designed to help developers create intuitive and responsive user interfaces for their Ruby applications.
+**Reflex** provides core components such as Window and View, making it easier to build the foundation of your GUI applications.
+
+## 📦 Installation
+
+Add this line to your Gemfile:
+```ruby
+$ gem 'reflexion'
+```
+
+Then, install gem:
+```bash
+$ bundle install
+```
+
+Or install it directly:
+```bash
+$ gem install reflexion
+```
+
+## 📜 License
+
+**Reflex** is licensed under the MIT License.
+See the [LICENSE](./LICENSE) file for details.

data/VERSION

@@ -1 +1 @@
-0.3.4
+0.3.6

data/ext/reflex/application.cpp

@@ -89,6 +89,22 @@ RUCY_DEF1(on_quit, event)
 }
 RUCY_END
 
+static
+RUCY_DEF1(on_device_connect, event)
+{
+	CHECK;
+	CALL(on_device_connect(to<Reflex::DeviceEvent*>(event)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_device_disconnect, event)
+{
+	CHECK;
+	CALL(on_device_disconnect(to<Reflex::DeviceEvent*>(event)));
+}
+RUCY_END
+
 static
 RUCY_DEF1(on_motion, event)
 {
@@ -137,6 +153,8 @@ Init_reflex_application ()
 	cApplication.define_method("each_window", each_window);
 	cApplication.define_method("on_start", on_start);
 	cApplication.define_method("on_quit",  on_quit);
+	cApplication.define_method("on_device_connect",    on_device_connect);
+	cApplication.define_method("on_device_disconnect", on_device_disconnect);
 	cApplication.define_method("on_motion", on_motion);
 	cApplication.define_method("on_preference", on_preference);
 	cApplication.define_method("on_about",      on_about);

data/ext/reflex/device.cpp

@@ -1,9 +1,34 @@
-#include "reflex/device.h"
+#include "reflex/ruby/device.h"
+
+
 #include "defs.h"
 
 
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::Device)
+
+#define THIS  to<Reflex::Device*>(self)
+
+#define CHECK RUCY_CHECK_OBJECT(Reflex::Device, self)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	Reflex::reflex_error(__FILE__, __LINE__, "can not instantiate Device class.");
+}
+RUCY_END
+
+static
+RUCY_DEF0(name)
+{
+	CHECK;
+	return value(THIS->name());
+}
+RUCY_END
+
+
 static
-RUCY_DEF0(vibrate)
+RUCY_DEF0(s_vibrate)
 {
 	Reflex::vibrate();
 	return self;
@@ -11,10 +36,30 @@ RUCY_DEF0(vibrate)
 RUCY_END
 
 
+static Class cDevice;
+
 void
 Init_reflex_device ()
 {
 	Module mReflex = define_module("Reflex");
 
-	mReflex.define_singleton_method("vibrate", vibrate);
+	cDevice = mReflex.define_class("Device", Reflex::device_class());
+	cDevice.define_alloc_func(alloc);
+	cDevice.define_method("name", name);
+
+	mReflex.define_singleton_method("vibrate", s_vibrate);
 }
+
+
+namespace Reflex
+{
+
+
+	Class
+	device_class ()
+	{
+		return cDevice;
+	}
+
+
+}// Reflex

data/ext/reflex/device_event.cpp

@@ -0,0 +1,65 @@
+#include "reflex/ruby/event.h"
+
+
+#include "reflex/ruby/device.h"
+#include "defs.h"
+
+
+RUCY_DEFINE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::DeviceEvent)
+
+#define THIS  to<Reflex::DeviceEvent*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::DeviceEvent, self)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Reflex::DeviceEvent>(klass);
+}
+RUCY_END
+
+static
+RUCY_DEF1(initialize_copy, obj)
+{
+	CHECK;
+	*THIS = to<Reflex::DeviceEvent&>(obj).dup();
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_device)
+{
+	CHECK;
+	return value(THIS->device());
+}
+RUCY_END
+
+
+static Class cDeviceEvent;
+
+void
+Init_reflex_device_event ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cDeviceEvent = mReflex.define_class("DeviceEvent", Reflex::event_class());
+	cDeviceEvent.define_alloc_func(alloc);
+	cDeviceEvent.define_private_method("initialize_copy", initialize_copy);
+	cDeviceEvent.define_method("device", get_device);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	device_event_class ()
+	{
+		return cDeviceEvent;
+	}
+
+
+}// Reflex

data/ext/reflex/extconf.rb

@@ -13,9 +13,9 @@ require 'reflex/extension'
 Xot::ExtConf.new Xot, Rucy, Rays, Reflex do
   setup do
     headers    << 'ruby.h'
-    libs.unshift 'gdi32', 'winmm', 'opengl32', 'glew32' if win32?
-    frameworks << 'Cocoa'                               if osx?
-    $LDFLAGS   << ' -Wl,--out-implib=native.dll.a'      if mingw? || cygwin?
+    libs.unshift 'gdi32', 'winmm', 'opengl32', 'glew32', 'xinput' if win32?
+    frameworks << 'Cocoa' << 'GameController'                     if osx?
+    $LDFLAGS   << ' -Wl,--out-implib=native.dll.a'                if mingw? || cygwin?
 
     unless osx?
       lib_dirs << Rays::Extension.ext_dir

data/ext/reflex/key_event.cpp

@@ -260,6 +260,56 @@ RUCY_DEF0(get_key)
 		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