[gnome-games/wip/aplazas/781572-remove-vala-macro] gamepad: Port GamepadMapping to C
- From: Adrien Plazas <aplazas src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gnome-games/wip/aplazas/781572-remove-vala-macro] gamepad: Port GamepadMapping to C
- Date: Sat, 29 Apr 2017 04:54:57 +0000 (UTC)
commit b04a26ce2964383945ddd3f0c0beb11b6ed22cbe
Author: Adrien Plazas <kekun plazas laposte net>
Date: Fri Apr 28 14:48:01 2017 +0200
gamepad: Port GamepadMapping to C
This will help to port part of the gamepad handling to C to avoid using
the Vala preprocessor.
src/Makefile.am | 4 +-
src/gamepad/gamepad-mapping.c | 832 ++++++++++++++++++++++++++++++++++++++
src/gamepad/gamepad-mapping.h | 31 ++
src/gamepad/gamepad-mapping.vala | 6 +-
src/gamepad/gamepad-mapping.vapi | 9 +
5 files changed, 878 insertions(+), 4 deletions(-)
---
diff --git a/src/Makefile.am b/src/Makefile.am
index ead8089..7c09f9c 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -26,6 +26,7 @@ EXTRA_DIST = \
gamepad/gamepad-dpad.vapi \
gamepad/gamepad-input-type.vapi \
gamepad/gamepad-mapped-event.vapi \
+ gamepad/gamepad-mapping.vapi \
gamepad/gamepad-mapping-error.vapi \
gamepad/linux/linux-raw-gamepad-monitor.vapi \
gamepad/raw-gamepad.vapi \
@@ -79,7 +80,7 @@ gnome_games_SOURCES = \
gamepad/gamepad-dpad.c \
gamepad/gamepad-input-type.c \
gamepad/gamepad-mapped-event.c \
- gamepad/gamepad-mapping.vala \
+ gamepad/gamepad-mapping.c \
gamepad/gamepad-mapping-error.c \
gamepad/gamepad-mappings-manager.vala \
gamepad/gamepad-monitor.vala \
@@ -189,6 +190,7 @@ gnome_games_VALAFLAGS = \
--pkg gamepad-dpad \
--pkg gamepad-input-type \
--pkg gamepad-mapped-event \
+ --pkg gamepad-mapping \
--pkg gamepad-mapping-error \
--pkg raw-gamepad \
--pkg raw-gamepad-monitor \
diff --git a/src/gamepad/gamepad-mapping.c b/src/gamepad/gamepad-mapping.c
new file mode 100644
index 0000000..3df57cc
--- /dev/null
+++ b/src/gamepad/gamepad-mapping.c
@@ -0,0 +1,832 @@
+// This file is part of GNOME Games. License: GPL-3.0+.
+
+#include "gamepad-mapping.h"
+
+#include "gamepad-dpad.h"
+#include "gamepad-mapping-error.h"
+#include "glib/gi18n-lib.h"
+#include "stdlib.h"
+
+struct _GamesGamepadMapping {
+ GObject parent_instance;
+
+ GamesGamepadInputType *buttons_type;
+ gint buttons_type_length;
+ gint buttons_type_size;
+ gint *buttons_value;
+ gint buttons_value_length;
+ gint buttons_value_size;
+ GamesGamepadInputType *axes_type;
+ gint axes_type_length;
+ gint axes_type_size;
+ gint *axes_value;
+ gint axes_value_length;
+ gint axes_value_size;
+ GamesGamepadDPad *dpads;
+ gint dpads_length;
+ gint dpads_size;
+};
+
+G_DEFINE_TYPE (GamesGamepadMapping, games_gamepad_mapping, G_TYPE_OBJECT)
+
+#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
+#define _g_free0(var) (var = (g_free (var), NULL))
+
+static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);
+static gint _vala_array_length (gpointer array);
+
+static gchar
+string_get (const gchar *self,
+ glong index)
+{
+ g_return_val_if_fail (self != NULL, '\0');
+
+ return ((gchar *) self)[index];
+}
+
+static gchar *
+string_slice (const gchar *self,
+ glong start,
+ glong end)
+{
+ gchar *result = NULL;
+ glong string_length;
+ gint _tmp0_;
+ gint _tmp1_;
+ glong _tmp2_;
+ glong _tmp5_;
+ gboolean _tmp8_ = FALSE;
+ glong _tmp9_;
+ gboolean _tmp12_ = FALSE;
+ glong _tmp13_;
+ glong _tmp16_;
+ glong _tmp17_;
+ glong _tmp18_;
+ glong _tmp19_;
+ glong _tmp20_;
+ gchar *_tmp21_;
+ g_return_val_if_fail (self != NULL, NULL);
+ _tmp0_ = strlen (self);
+ _tmp1_ = _tmp0_;
+ string_length = (glong) _tmp1_;
+ _tmp2_ = start;
+ if (_tmp2_ < ((glong) 0)) {
+ glong _tmp3_;
+ glong _tmp4_;
+ _tmp3_ = string_length;
+ _tmp4_ = start;
+ start = _tmp3_ + _tmp4_;
+ }
+ _tmp5_ = end;
+ if (_tmp5_ < ((glong) 0)) {
+ glong _tmp6_;
+ glong _tmp7_;
+ _tmp6_ = string_length;
+ _tmp7_ = end;
+ end = _tmp6_ + _tmp7_;
+ }
+ _tmp9_ = start;
+ if (_tmp9_ >= ((glong) 0)) {
+ glong _tmp10_;
+ glong _tmp11_;
+ _tmp10_ = start;
+ _tmp11_ = string_length;
+ _tmp8_ = _tmp10_ <= _tmp11_;
+ } else {
+ _tmp8_ = FALSE;
+ }
+ g_return_val_if_fail (_tmp8_, NULL);
+ _tmp13_ = end;
+ if (_tmp13_ >= ((glong) 0)) {
+ glong _tmp14_;
+ glong _tmp15_;
+ _tmp14_ = end;
+ _tmp15_ = string_length;
+ _tmp12_ = _tmp14_ <= _tmp15_;
+ } else {
+ _tmp12_ = FALSE;
+ }
+ g_return_val_if_fail (_tmp12_, NULL);
+ _tmp16_ = start;
+ _tmp17_ = end;
+ g_return_val_if_fail (_tmp16_ <= _tmp17_, NULL);
+ _tmp18_ = start;
+ _tmp19_ = end;
+ _tmp20_ = start;
+ _tmp21_ = g_strndup (((gchar*) self) + _tmp18_, (gsize) (_tmp19_ - _tmp20_));
+ result = _tmp21_;
+ return result;
+}
+
+static void
+_vala_array_add1 (GamesGamepadDPad **array,
+ int *length,
+ int *size,
+ const GamesGamepadDPad *value)
+{
+ if ((*length) == (*size)) {
+ *size = (*size) ? (2 *(*size)) : 4;
+ *array = g_renew (GamesGamepadDPad, *array, *size);
+ }
+ (*array)[(*length)++] = *value;
+}
+
+static void
+parse_dpad_value (GamesGamepadMapping *self,
+ const gchar *mapping_value,
+ GamesGamepadInputType type,
+ gint parsed_key)
+{
+ gchar **dpad_parse_array;
+ const gchar *_tmp0_;
+ const gchar *_tmp1_;
+ gint _tmp2_;
+ gint _tmp3_;
+ gchar *_tmp4_;
+ gchar *_tmp5_;
+ gchar **_tmp6_;
+ gchar **_tmp7_;
+ gchar **_tmp8_;
+ gint _tmp8__length1;
+ gint dpad_parse_array_length1;
+ gint _dpad_parse_array_size_;
+ gint dpad_index;
+ gchar **_tmp9_;
+ gint _tmp9__length1;
+ const gchar *_tmp10_;
+ gint _tmp11_;
+ gint dpad_position_2pow;
+ gchar **_tmp12_;
+ gint _tmp12__length1;
+ const gchar *_tmp13_;
+ gint _tmp14_;
+ gint dpad_position;
+ GamesGamepadDPad *_tmp22_;
+ gint _tmp22__length1;
+ gint _tmp23_;
+ GamesGamepadDPad _tmp24_;
+ gint _tmp25_;
+ GamesGamepadInputType _tmp26_;
+ GamesGamepadInputType _tmp27_;
+ GamesGamepadDPad *_tmp28_;
+ gint _tmp28__length1;
+ gint _tmp29_;
+ GamesGamepadDPad _tmp30_;
+ gint _tmp31_;
+ gint _tmp32_;
+ gint _tmp33_;
+ g_return_if_fail (self != NULL);
+ g_return_if_fail (mapping_value != NULL);
+ _tmp0_ = mapping_value;
+ _tmp1_ = mapping_value;
+ _tmp2_ = strlen (_tmp1_);
+ _tmp3_ = _tmp2_;
+ _tmp4_ = string_slice (_tmp0_, (glong) 1, (glong) _tmp3_);
+ _tmp5_ = _tmp4_;
+ _tmp7_ = _tmp6_ = g_strsplit (_tmp5_, ".", 0);
+ _tmp8_ = _tmp7_;
+ _tmp8__length1 = _vala_array_length (_tmp6_);
+ _g_free0 (_tmp5_);
+ dpad_parse_array = _tmp8_;
+ dpad_parse_array_length1 = _tmp8__length1;
+ _dpad_parse_array_size_ = dpad_parse_array_length1;
+ _tmp9_ = dpad_parse_array;
+ _tmp9__length1 = dpad_parse_array_length1;
+ _tmp10_ = _tmp9_[0];
+ _tmp11_ = atoi (_tmp10_);
+ dpad_index = _tmp11_;
+ _tmp12_ = dpad_parse_array;
+ _tmp12__length1 = dpad_parse_array_length1;
+ _tmp13_ = _tmp12_[1];
+ _tmp14_ = atoi (_tmp13_);
+ dpad_position_2pow = _tmp14_;
+ dpad_position = 0;
+ while (TRUE) {
+ gint _tmp15_;
+ gint _tmp16_;
+ gint _tmp17_;
+ _tmp15_ = dpad_position_2pow;
+ if (!(_tmp15_ > 1)) {
+ break;
+ }
+ _tmp16_ = dpad_position_2pow;
+ dpad_position_2pow = _tmp16_ >> 1;
+ _tmp17_ = dpad_position;
+ dpad_position = _tmp17_ + 1;
+ }
+ while (TRUE) {
+ GamesGamepadDPad *_tmp18_;
+ gint _tmp18__length1;
+ gint _tmp19_;
+ GamesGamepadDPad *_tmp20_;
+ gint _tmp20__length1;
+ GamesGamepadDPad _tmp21_ = {0};
+ _tmp18_ = self->dpads;
+ _tmp18__length1 = self->dpads_length;
+ _tmp19_ = dpad_index;
+ if (!(_tmp18__length1 <= _tmp19_)) {
+ break;
+ }
+ _tmp20_ = self->dpads;
+ _tmp20__length1 = self->dpads_length;
+ memset (&_tmp21_, 0, sizeof (GamesGamepadDPad));
+ _vala_array_add1 (&self->dpads, &self->dpads_length, &self->dpads_size, &_tmp21_);
+ }
+ _tmp22_ = self->dpads;
+ _tmp22__length1 = self->dpads_length;
+ _tmp23_ = dpad_index;
+ _tmp24_ = _tmp22_[_tmp23_];
+ _tmp25_ = dpad_position;
+ _tmp26_ = type;
+ _tmp24_.types[_tmp25_] = _tmp26_;
+ _tmp27_ = _tmp24_.types[_tmp25_];
+ _tmp28_ = self->dpads;
+ _tmp28__length1 = self->dpads_length;
+ _tmp29_ = dpad_index;
+ _tmp30_ = _tmp28_[_tmp29_];
+ _tmp31_ = dpad_position;
+ _tmp32_ = parsed_key;
+ _tmp30_.values[_tmp31_] = _tmp32_;
+ _tmp33_ = _tmp30_.values[_tmp31_];
+ dpad_parse_array = (_vala_array_free (dpad_parse_array, dpad_parse_array_length1, (GDestroyNotify)
g_free), NULL);
+}
+
+static void
+_vala_array_add2 (GamesGamepadInputType **array,
+ int *length,
+ int *size,
+ GamesGamepadInputType value)
+{
+ if ((*length) == (*size)) {
+ *size = (*size) ? (2 *(*size)) : 4;
+ *array = g_renew (GamesGamepadInputType, *array, *size);
+ }
+ (*array)[(*length)++] = value;
+}
+
+static void
+parse_button_value (GamesGamepadMapping *self,
+ const gchar *mapping_value,
+ GamesGamepadInputType type,
+ gint parsed_key)
+{
+ const gchar *mapping_value_number;
+ gint button;
+
+ g_return_if_fail (self != NULL);
+ g_return_if_fail (mapping_value != NULL);
+ g_return_if_fail (*mapping_value == 'b');
+
+ mapping_value_number = mapping_value + 1;
+
+ g_return_if_fail (*mapping_value_number != '\0');
+
+ button = atoi (mapping_value_number);
+
+ while (self->buttons_type_length <= button)
+ _vala_array_add2 (&self->buttons_type, &self->buttons_type_length, &self->buttons_type_size,
GAMES_GAMEPAD_INPUT_TYPE_INVALID);
+
+ if (self->buttons_value_length <= button) {
+ gint _tmp13_;
+ gint _tmp14_;
+ _tmp13_ = button;
+ _tmp14_ = _tmp13_ + 1;
+ self->buttons_value = g_renew (gint, self->buttons_value, _tmp13_ + 1);
+ (_tmp14_ > self->buttons_value_length) ? memset (self->buttons_value + self->buttons_value_length, 0,
sizeof (gint) *(_tmp14_ - self->buttons_value_length)) : NULL;
+ self->buttons_value_length = _tmp14_;
+ self->buttons_value_size = _tmp14_;
+ }
+ self->buttons_type[button] = type;
+ self->buttons_value[button] = parsed_key;
+}
+
+static void
+_vala_array_add3 (GamesGamepadInputType **array,
+ int *length,
+ int *size,
+ GamesGamepadInputType value)
+{
+ if ((*length) == (*size)) {
+ *size = (*size) ? (2 *(*size)) : 4;
+ *array = g_renew (GamesGamepadInputType, *array, *size);
+ }
+ (*array)[(*length)++] = value;
+}
+
+static void
+parse_axis_value (GamesGamepadMapping *self,
+ const gchar *mapping_value,
+ GamesGamepadInputType type,
+ gint parsed_key)
+{
+ const gchar *mapping_value_number;
+ gint axis;
+
+ g_return_if_fail (self != NULL);
+ g_return_if_fail (mapping_value != NULL);
+ g_return_if_fail (*mapping_value == 'a');
+
+ mapping_value_number = mapping_value + 1;
+
+ g_return_if_fail (*mapping_value_number != '\0');
+
+ axis = atoi (mapping_value_number);
+
+ while (self->axes_type_length <= axis)
+ _vala_array_add3 (&self->axes_type, &self->axes_type_length, &self->axes_type_size,
GAMES_GAMEPAD_INPUT_TYPE_INVALID);
+
+ if (self->axes_value_length <= axis) {
+ gint _tmp14_;
+ _tmp14_ = axis + 1;
+ self->axes_value = g_renew (gint, self->axes_value, axis + 1);
+ memset (self->axes_value + self->axes_value_length, 0, sizeof (gint) *(_tmp14_ -
self->axes_value_length));
+ self->axes_value_length = _tmp14_;
+ self->axes_value_size = _tmp14_;
+ }
+ self->axes_type[axis] = type;
+ self->axes_value[axis] = parsed_key;
+}
+
+static GamesGamepadInputType
+parse_input_type (const gchar *mapping_string)
+{
+ const static struct {
+ GamesGamepadInputType enum_value;
+ const gchar *string_value;
+ } text_to_enum[] = {
+ { GAMES_GAMEPAD_INPUT_TYPE_AXIS, "leftx" },
+ { GAMES_GAMEPAD_INPUT_TYPE_AXIS, "lefty" },
+ { GAMES_GAMEPAD_INPUT_TYPE_AXIS, "rightx" },
+ { GAMES_GAMEPAD_INPUT_TYPE_AXIS, "righty" },
+ { GAMES_GAMEPAD_INPUT_TYPE_BUTTON, "a" },
+ { GAMES_GAMEPAD_INPUT_TYPE_BUTTON, "b" },
+ { GAMES_GAMEPAD_INPUT_TYPE_BUTTON, "back" },
+ { GAMES_GAMEPAD_INPUT_TYPE_BUTTON, "dpdown" },
+ { GAMES_GAMEPAD_INPUT_TYPE_BUTTON, "dpleft" },
+ { GAMES_GAMEPAD_INPUT_TYPE_BUTTON, "dpright" },
+ { GAMES_GAMEPAD_INPUT_TYPE_BUTTON, "dpup" },
+ { GAMES_GAMEPAD_INPUT_TYPE_BUTTON, "guide" },
+ { GAMES_GAMEPAD_INPUT_TYPE_BUTTON, "leftshoulder" },
+ { GAMES_GAMEPAD_INPUT_TYPE_BUTTON, "leftstick" },
+ { GAMES_GAMEPAD_INPUT_TYPE_BUTTON, "lefttrigger" },
+ { GAMES_GAMEPAD_INPUT_TYPE_BUTTON, "rightshoulder" },
+ { GAMES_GAMEPAD_INPUT_TYPE_BUTTON, "rightstick" },
+ { GAMES_GAMEPAD_INPUT_TYPE_BUTTON, "righttrigger" },
+ { GAMES_GAMEPAD_INPUT_TYPE_BUTTON, "start" },
+ { GAMES_GAMEPAD_INPUT_TYPE_BUTTON, "x" },
+ { GAMES_GAMEPAD_INPUT_TYPE_BUTTON, "y" },
+ };
+ const gint length = sizeof (text_to_enum) / sizeof (text_to_enum[0]);
+ gint i;
+
+ for (i = 0; i < length; i++)
+ if (g_strcmp0 (mapping_string, text_to_enum[i].string_value) == 0)
+ return text_to_enum[i].enum_value;
+
+ return GAMES_GAMEPAD_INPUT_TYPE_INVALID;
+}
+
+static GamesStandardGamepadAxis
+parse_axis (const gchar *mapping_string)
+{
+ const static struct {
+ GamesStandardGamepadAxis enum_value;
+ const gchar *string_value;
+ } text_to_enum[] = {
+ { GAMES_STANDARD_GAMEPAD_AXIS_LEFT_X, "leftx" },
+ { GAMES_STANDARD_GAMEPAD_AXIS_LEFT_Y, "lefty" },
+ { GAMES_STANDARD_GAMEPAD_AXIS_RIGHT_X, "rightx" },
+ { GAMES_STANDARD_GAMEPAD_AXIS_RIGHT_Y, "righty" },
+ };
+ const gint length = sizeof (text_to_enum) / sizeof (text_to_enum[0]);
+ gint i;
+
+ for (i = 0; i < length; i++)
+ if (g_strcmp0 (mapping_string, text_to_enum[i].string_value) == 0)
+ return text_to_enum[i].enum_value;
+
+ return GAMES_STANDARD_GAMEPAD_AXIS_UNKNOWN;
+}
+
+static GamesStandardGamepadButton
+parse_button (const gchar *mapping_string)
+{
+ const static struct {
+ GamesStandardGamepadButton enum_value;
+ const gchar *string_value;
+ } text_to_enum[] = {
+ { GAMES_STANDARD_GAMEPAD_BUTTON_A, "a" },
+ { GAMES_STANDARD_GAMEPAD_BUTTON_B, "b" },
+ { GAMES_STANDARD_GAMEPAD_BUTTON_DPAD_DOWN, "dpdown" },
+ { GAMES_STANDARD_GAMEPAD_BUTTON_DPAD_LEFT, "dpleft" },
+ { GAMES_STANDARD_GAMEPAD_BUTTON_DPAD_RIGHT, "dpright" },
+ { GAMES_STANDARD_GAMEPAD_BUTTON_DPAD_UP, "dpup" },
+ { GAMES_STANDARD_GAMEPAD_BUTTON_HOME, "guide" },
+ { GAMES_STANDARD_GAMEPAD_BUTTON_SELECT, "back" },
+ { GAMES_STANDARD_GAMEPAD_BUTTON_SHOULDER_L, "leftshoulder" },
+ { GAMES_STANDARD_GAMEPAD_BUTTON_SHOULDER_R, "rightshoulder" },
+ { GAMES_STANDARD_GAMEPAD_BUTTON_START, "start" },
+ { GAMES_STANDARD_GAMEPAD_BUTTON_STICK_L, "leftstick" },
+ { GAMES_STANDARD_GAMEPAD_BUTTON_STICK_R, "rightstick" },
+ { GAMES_STANDARD_GAMEPAD_BUTTON_TRIGGER_L, "lefttrigger" },
+ { GAMES_STANDARD_GAMEPAD_BUTTON_TRIGGER_R, "righttrigger" },
+ { GAMES_STANDARD_GAMEPAD_BUTTON_X, "x" },
+ { GAMES_STANDARD_GAMEPAD_BUTTON_Y, "y" },
+ };
+ const gint length = sizeof (text_to_enum) / sizeof (text_to_enum[0]);
+ gint i;
+
+ for (i = 0; i < length; i++)
+ if (g_strcmp0 (mapping_string, text_to_enum[i].string_value) == 0)
+ return text_to_enum[i].enum_value;
+
+ return GAMES_STANDARD_GAMEPAD_BUTTON_UNKNOWN;
+}
+
+/* Public */
+
+GamesGamepadMapping *
+games_gamepad_mapping_new_from_sdl_string (const gchar *mapping_string,
+ GError **error)
+{
+ GamesGamepadMapping *self = NULL;
+ const gchar *_tmp0_;
+ const gchar *_tmp2_;
+ gchar **mappings;
+ const gchar *_tmp4_;
+ gchar **_tmp5_;
+ gchar **_tmp6_;
+ gint mappings_length1;
+ gint _mappings_size_;
+ gchar **_tmp7_;
+ gint _tmp7__length1;
+ GError *_inner_error_ = NULL;
+ self = (GamesGamepadMapping*) g_object_new (GAMES_TYPE_GAMEPAD_MAPPING, NULL);
+ _tmp0_ = mapping_string;
+ if (_tmp0_ == NULL) {
+ GError *_tmp1_;
+ _tmp1_ = g_error_new_literal (GAMES_GAMEPAD_MAPPING_ERROR, GAMES_GAMEPAD_MAPPING_ERROR_NOT_A_MAPPING, _
("The mapping string can’t be null."));
+ _inner_error_ = _tmp1_;
+ if (_inner_error_->domain == GAMES_GAMEPAD_MAPPING_ERROR) {
+ g_propagate_error (error, _inner_error_);
+ _g_object_unref0 (self);
+ return NULL;
+ } else {
+ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__,
_inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
+ g_clear_error (&_inner_error_);
+ return NULL;
+ }
+ }
+ _tmp2_ = mapping_string;
+ if (g_strcmp0 (_tmp2_, "") == 0) {
+ GError *_tmp3_;
+ _tmp3_ = g_error_new_literal (GAMES_GAMEPAD_MAPPING_ERROR, GAMES_GAMEPAD_MAPPING_ERROR_NOT_A_MAPPING, _
("The mapping string can’t be empty."));
+ _inner_error_ = _tmp3_;
+ if (_inner_error_->domain == GAMES_GAMEPAD_MAPPING_ERROR) {
+ g_propagate_error (error, _inner_error_);
+ _g_object_unref0 (self);
+ return NULL;
+ } else {
+ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__,
_inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
+ g_clear_error (&_inner_error_);
+ return NULL;
+ }
+ }
+ _tmp4_ = mapping_string;
+ _tmp6_ = _tmp5_ = g_strsplit (_tmp4_, ",", 0);
+ mappings = _tmp6_;
+ mappings_length1 = _vala_array_length (_tmp5_);
+ _mappings_size_ = mappings_length1;
+ _tmp7_ = mappings;
+ _tmp7__length1 = mappings_length1;
+ {
+ gchar **mapping_collection = NULL;
+ gint mapping_collection_length1 = 0;
+ gint _mapping_collection_size_ = 0;
+ gint mapping_it = 0;
+ mapping_collection = _tmp7_;
+ mapping_collection_length1 = _tmp7__length1;
+ for (mapping_it = 0; mapping_it < _tmp7__length1; mapping_it = mapping_it + 1) {
+ gchar *_tmp8_;
+ gchar *mapping = NULL;
+ _tmp8_ = g_strdup (mapping_collection[mapping_it]);
+ mapping = _tmp8_;
+ {
+ gchar **splitted_mapping;
+ const gchar *_tmp9_;
+ gchar **_tmp10_;
+ gchar **_tmp11_;
+ gint splitted_mapping_length1;
+ gint _splitted_mapping_size_;
+ gchar **_tmp12_;
+ gint _tmp12__length1;
+ gchar *mapping_key;
+ const gchar *_tmp13_;
+ gchar **_tmp14_;
+ gchar **_tmp15_;
+ gchar **_tmp16_;
+ gint _tmp16__length1;
+ const gchar *_tmp17_;
+ gchar *_tmp18_;
+ gchar *_tmp19_;
+ gchar *mapping_value;
+ const gchar *_tmp20_;
+ gchar **_tmp21_;
+ gchar **_tmp22_;
+ gchar **_tmp23_;
+ gint _tmp23__length1;
+ const gchar *_tmp24_;
+ gchar *_tmp25_;
+ gchar *_tmp26_;
+ GamesGamepadInputType type;
+ const gchar *_tmp27_;
+ GamesGamepadInputType _tmp28_;
+ GamesGamepadInputType _tmp29_;
+ gint parsed_key = 0;
+ GamesGamepadInputType _tmp32_;
+ const gchar *_tmp37_;
+ gchar _tmp38_;
+ _tmp9_ = mapping;
+ _tmp11_ = _tmp10_ = g_strsplit (_tmp9_, ":", 0);
+ splitted_mapping = _tmp11_;
+ splitted_mapping_length1 = _vala_array_length (_tmp10_);
+ _splitted_mapping_size_ = splitted_mapping_length1;
+ _tmp12_ = splitted_mapping;
+ _tmp12__length1 = splitted_mapping_length1;
+ if (_tmp12__length1 != 2) {
+ splitted_mapping = (_vala_array_free (splitted_mapping, splitted_mapping_length1, (GDestroyNotify)
g_free), NULL);
+ _g_free0 (mapping);
+ continue;
+ }
+ _tmp13_ = mapping;
+ _tmp15_ = _tmp14_ = g_strsplit (_tmp13_, ":", 0);
+ _tmp16_ = _tmp15_;
+ _tmp16__length1 = _vala_array_length (_tmp14_);
+ _tmp17_ = _tmp16_[0];
+ _tmp18_ = g_strdup (_tmp17_);
+ _tmp19_ = _tmp18_;
+ _tmp16_ = (_vala_array_free (_tmp16_, _tmp16__length1, (GDestroyNotify) g_free), NULL);
+ mapping_key = _tmp19_;
+ _tmp20_ = mapping;
+ _tmp22_ = _tmp21_ = g_strsplit (_tmp20_, ":", 0);
+ _tmp23_ = _tmp22_;
+ _tmp23__length1 = _vala_array_length (_tmp21_);
+ _tmp24_ = _tmp23_[1];
+ _tmp25_ = g_strdup (_tmp24_);
+ _tmp26_ = _tmp25_;
+ _tmp23_ = (_vala_array_free (_tmp23_, _tmp23__length1, (GDestroyNotify) g_free), NULL);
+ mapping_value = _tmp26_;
+ _tmp27_ = mapping_key;
+ _tmp28_ = parse_input_type (_tmp27_);
+ type = _tmp28_;
+ _tmp29_ = type;
+ if (_tmp29_ == GAMES_GAMEPAD_INPUT_TYPE_INVALID) {
+ const gchar *_tmp30_;
+ _tmp30_ = mapping_key;
+ if (g_strcmp0 (_tmp30_, "platform") != 0) {
+ const gchar *_tmp31_;
+ _tmp31_ = mapping_key;
+ g_debug ("gamepad-mapping.vala:28: Invalid token : %s", _tmp31_);
+ }
+ _g_free0 (mapping_value);
+ _g_free0 (mapping_key);
+ splitted_mapping = (_vala_array_free (splitted_mapping, splitted_mapping_length1, (GDestroyNotify)
g_free), NULL);
+ _g_free0 (mapping);
+ continue;
+ }
+ _tmp32_ = type;
+ switch (_tmp32_) {
+ case GAMES_GAMEPAD_INPUT_TYPE_BUTTON:
+ {
+ const gchar *_tmp33_;
+ GamesStandardGamepadButton _tmp34_;
+ _tmp33_ = mapping_key;
+ _tmp34_ = parse_button (_tmp33_);
+ parsed_key = (gint) _tmp34_;
+ break;
+ }
+ case GAMES_GAMEPAD_INPUT_TYPE_AXIS:
+ {
+ const gchar *_tmp35_;
+ GamesStandardGamepadAxis _tmp36_;
+ _tmp35_ = mapping_key;
+ _tmp36_ = parse_axis (_tmp35_);
+ parsed_key = (gint) _tmp36_;
+ break;
+ }
+ default:
+ {
+ continue;
+ }
+ }
+ _tmp37_ = mapping_value;
+ _tmp38_ = string_get (_tmp37_, (glong) 0);
+ switch (_tmp38_) {
+ case 'h':
+ {
+ const gchar *_tmp39_;
+ GamesGamepadInputType _tmp40_;
+ gint _tmp41_;
+ _tmp39_ = mapping_value;
+ _tmp40_ = type;
+ _tmp41_ = parsed_key;
+ parse_dpad_value (self, _tmp39_, _tmp40_, _tmp41_);
+ break;
+ }
+ case 'b':
+ {
+ const gchar *_tmp42_;
+ GamesGamepadInputType _tmp43_;
+ gint _tmp44_;
+ _tmp42_ = mapping_value;
+ _tmp43_ = type;
+ _tmp44_ = parsed_key;
+ parse_button_value (self, _tmp42_, _tmp43_, _tmp44_);
+ break;
+ }
+ case 'a':
+ {
+ const gchar *_tmp45_;
+ GamesGamepadInputType _tmp46_;
+ gint _tmp47_;
+ _tmp45_ = mapping_value;
+ _tmp46_ = type;
+ _tmp47_ = parsed_key;
+ parse_axis_value (self, _tmp45_, _tmp46_, _tmp47_);
+ break;
+ }
+ default:
+ break;
+ }
+ _g_free0 (mapping_value);
+ _g_free0 (mapping_key);
+ splitted_mapping = (_vala_array_free (splitted_mapping, splitted_mapping_length1, (GDestroyNotify)
g_free), NULL);
+ _g_free0 (mapping);
+ }
+ }
+ }
+ mappings = (_vala_array_free (mappings, mappings_length1, (GDestroyNotify) g_free), NULL);
+ return self;
+}
+
+void
+games_gamepad_mapping_get_dpad_mapping (GamesGamepadMapping *self,
+ gint dpad_index,
+ gint dpad_axis,
+ gint dpad_value,
+ GamesGamepadMappedEvent *event)
+{
+ GamesGamepadDPad dpad;
+ gint dpad_changed_value;
+ gint dpad_position;
+
+ g_return_if_fail (self != NULL);
+ g_return_if_fail (event != NULL);
+
+ memset (event, 0, sizeof (GamesGamepadMappedEvent));
+
+ dpad = self->dpads[dpad_index];
+ dpad_changed_value = (dpad_value == 0) ?
+ dpad.axis_values[dpad_axis] :
+ dpad_value;
+ // We add 4 so that the remainder is always positive.
+ dpad_position = (dpad_changed_value + dpad_axis + 4) % 4;
+ dpad.axis_values[dpad_axis] = dpad_value;
+ event->type = dpad.types[dpad_position];
+
+ switch (event->type)
+ {
+ case GAMES_GAMEPAD_INPUT_TYPE_AXIS:
+ event->axis = (GamesStandardGamepadAxis) dpad.values[dpad_position];
+
+ break;
+ case GAMES_GAMEPAD_INPUT_TYPE_BUTTON:
+ event->button = (GamesStandardGamepadButton) dpad.values[dpad_position];
+
+ break;
+ default:
+ break;
+ }
+}
+
+void
+games_gamepad_mapping_get_axis_mapping (GamesGamepadMapping *self,
+ gint axis_number,
+ GamesGamepadMappedEvent *event)
+{
+ g_return_if_fail (self != NULL);
+ g_return_if_fail (event != NULL);
+
+ memset (event, 0, sizeof (GamesGamepadMappedEvent));
+
+ event->type = (axis_number < self->axes_type_length) ?
+ self->axes_type[axis_number] :
+ GAMES_GAMEPAD_INPUT_TYPE_INVALID;
+
+ switch (event->type)
+ {
+ case GAMES_GAMEPAD_INPUT_TYPE_AXIS:
+ event->axis = (GamesStandardGamepadAxis) self->axes_value[axis_number];
+
+ break;
+ case GAMES_GAMEPAD_INPUT_TYPE_BUTTON:
+ event->button = (GamesStandardGamepadButton) self->axes_value[axis_number];
+
+ break;
+ default:
+ break;
+ }
+}
+
+void
+games_gamepad_mapping_get_button_mapping (GamesGamepadMapping *self,
+ gint button_number,
+ GamesGamepadMappedEvent *event)
+{
+ g_return_if_fail (self != NULL);
+ g_return_if_fail (event != NULL);
+
+ memset (event, 0, sizeof (GamesGamepadMappedEvent));
+
+ event->type = (button_number < self->buttons_type_length) ?
+ self->buttons_type[button_number] :
+ GAMES_GAMEPAD_INPUT_TYPE_INVALID;
+
+ switch (event->type)
+ {
+ case GAMES_GAMEPAD_INPUT_TYPE_AXIS:
+ event->axis = (GamesStandardGamepadAxis) self->buttons_value[button_number];
+
+ break;
+ case GAMES_GAMEPAD_INPUT_TYPE_BUTTON:
+ event->button = (GamesStandardGamepadButton) self->buttons_value[button_number];
+
+ break;
+ default:
+ break;
+ }
+}
+
+/* Type */
+
+static void
+games_gamepad_mapping_finalize (GObject *obj)
+{
+ GamesGamepadMapping *self;
+ self = G_TYPE_CHECK_INSTANCE_CAST (obj, GAMES_TYPE_GAMEPAD_MAPPING, GamesGamepadMapping);
+ self->buttons_type = (g_free (self->buttons_type), NULL);
+ self->buttons_value = (g_free (self->buttons_value), NULL);
+ self->axes_type = (g_free (self->axes_type), NULL);
+ self->axes_value = (g_free (self->axes_value), NULL);
+ self->dpads = (g_free (self->dpads), NULL);
+ G_OBJECT_CLASS (games_gamepad_mapping_parent_class)->finalize (obj);
+}
+
+static void
+games_gamepad_mapping_class_init (GamesGamepadMappingClass *klass)
+{
+ games_gamepad_mapping_parent_class = g_type_class_peek_parent (klass);
+ G_OBJECT_CLASS (klass)->finalize = games_gamepad_mapping_finalize;
+}
+
+static void
+_vala_array_destroy (gpointer array,
+ gint array_length,
+ GDestroyNotify destroy_func)
+{
+ if ((array != NULL) && (destroy_func != NULL)) {
+ int i;
+ for (i = 0; i < array_length; i = i + 1) {
+ if (((gpointer*) array)[i] != NULL) {
+ destroy_func (((gpointer*) array)[i]);
+ }
+ }
+ }
+}
+
+static void
+_vala_array_free (gpointer array,
+ gint array_length,
+ GDestroyNotify destroy_func)
+{
+ _vala_array_destroy (array, array_length, destroy_func);
+ g_free (array);
+}
+
+static gint
+_vala_array_length (gpointer array)
+{
+ int length;
+ length = 0;
+ if (array) {
+ while (((gpointer*) array)[length]) {
+ length++;
+ }
+ }
+ return length;
+}
+
+static void
+games_gamepad_mapping_init (GamesGamepadMapping *self)
+{
+}
diff --git a/src/gamepad/gamepad-mapping.h b/src/gamepad/gamepad-mapping.h
new file mode 100644
index 0000000..6e601b5
--- /dev/null
+++ b/src/gamepad/gamepad-mapping.h
@@ -0,0 +1,31 @@
+// This file is part of GNOME Games. License: GPL-3.0+.
+
+#ifndef GAMES_GAMEPAD_MAPPING_H
+#define GAMES_GAMEPAD_MAPPING_H
+
+#include <glib-object.h>
+#include "gamepad-mapped-event.h"
+
+G_BEGIN_DECLS
+
+#define GAMES_TYPE_GAMEPAD_MAPPING (games_gamepad_mapping_get_type())
+
+G_DECLARE_FINAL_TYPE (GamesGamepadMapping, games_gamepad_mapping, GAMES, GAMEPAD_MAPPING, GObject)
+
+GamesGamepadMapping *games_gamepad_mapping_new_from_sdl_string (const gchar *mapping_string,
+ GError **error);
+void games_gamepad_mapping_get_dpad_mapping (GamesGamepadMapping *self,
+ gint dpad_index,
+ gint dpad_axis,
+ gint dpad_value,
+ GamesGamepadMappedEvent *result);
+void games_gamepad_mapping_get_axis_mapping (GamesGamepadMapping *self,
+ gint axis_number,
+ GamesGamepadMappedEvent *result);
+void games_gamepad_mapping_get_button_mapping (GamesGamepadMapping *self,
+ gint button_number,
+ GamesGamepadMappedEvent *result);
+
+G_END_DECLS
+
+#endif /* GAMES_GAMEPAD_MAPPING_H */
diff --git a/src/gamepad/gamepad-mapping.vala b/src/gamepad/gamepad-mapping.vala
index cba06fb..4fc3a8a 100644
--- a/src/gamepad/gamepad-mapping.vala
+++ b/src/gamepad/gamepad-mapping.vala
@@ -153,7 +153,7 @@ private class Games.GamepadMapping : Object {
axes_value[axis] = parsed_key;
}
- public static GamepadInputType parse_input_type (string mapping_string) {
+ private static GamepadInputType parse_input_type (string mapping_string) {
switch (mapping_string) {
case "leftx":
case "lefty":
@@ -183,7 +183,7 @@ private class Games.GamepadMapping : Object {
}
}
- public static StandardGamepadAxis parse_axis (string mapping_string) {
+ private static StandardGamepadAxis parse_axis (string mapping_string) {
switch (mapping_string) {
case "leftx":
return StandardGamepadAxis.LEFT_X;
@@ -198,7 +198,7 @@ private class Games.GamepadMapping : Object {
}
}
- public static StandardGamepadButton parse_button (string mapping_string) {
+ private static StandardGamepadButton parse_button (string mapping_string) {
switch (mapping_string) {
case "a":
return StandardGamepadButton.A;
diff --git a/src/gamepad/gamepad-mapping.vapi b/src/gamepad/gamepad-mapping.vapi
new file mode 100644
index 0000000..fe5a41a
--- /dev/null
+++ b/src/gamepad/gamepad-mapping.vapi
@@ -0,0 +1,9 @@
+// This file is part of GNOME Games. License: GPL-3.0+.
+
+[CCode (cheader_filename = "gamepad-mapping.h")]
+private class Games.GamepadMapping : GLib.Object {
+ public GamepadMapping.from_sdl_string (string? mapping_string) throws GamepadMappingError;
+ public GamepadMappedEvent get_dpad_mapping (int dpad_index, int dpad_axis, int dpad_value);
+ public GamepadMappedEvent get_axis_mapping (int axis_number);
+ public GamepadMappedEvent get_button_mapping (int button_number);
+}
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
