X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=common%2Finput.c;h=5250535500026d669f0f892686fa69ec7a411c89;hb=2e307a073fd703e88a264b86a541dc5c5f3db110;hp=8950535545ef3c14bbf9ee12dc1cacf84ed81a31;hpb=8ced8d2b38431e23be1b26457110febbe10d14c7;p=libpicofe.git

diff --git a/common/input.c b/common/input.c
index 8950535..5250535 100644
--- a/common/input.c
+++ b/common/input.c
@@ -1,12 +1,30 @@
+/*
+ * (C) Gražvydas "notaz" Ignotas, 2008-2010
+ *
+ * This work is licensed under the terms of any of these licenses
+ * (at your option):
+ *  - GNU GPL, version 2 or later.
+ *  - GNU LGPL, version 2.1 or later.
+ * See the COPYING file in the top-level directory.
+ */
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "input.h"
 #include "plat.h"
+#include "lprintf.h"
+
+#ifdef IN_EVDEV
 #include "../linux/in_evdev.h"
+#endif
+#ifdef IN_GP2X
 #include "../gp2x/in_gp2x.h"
+#endif
+#ifdef IN_VK
 #include "../win32/in_vk.h"
+#endif
 
 typedef struct
 {
@@ -16,8 +34,9 @@ typedef struct
 	char *name;
 	int key_count;
 	int *binds;	/* total = key_count * bindtypes * 2 */
-	int probed:1;
-	int does_combos:1;
+	const char * const *key_names;
+	unsigned int probed:1;
+	unsigned int does_combos:1;
 } in_dev_t;
 
 static in_drv_t in_drivers[IN_DRVID_COUNT];
@@ -60,7 +79,7 @@ static void in_free(in_dev_t *dev)
 /* to be called by drivers
  * async devices must set drv_fd_hnd to -1 */
 void in_register(const char *nname, int drv_id, int drv_fd_hnd, void *drv_data,
-		int key_count, int combos)
+		int key_count, const char * const *key_names, int combos)
 {
 	int i, ret, dupe_count = 0, *binds;
 	char name[256], *name_end, *tmp;
@@ -90,7 +109,7 @@ void in_register(const char *nname, int drv_id, int drv_fd_hnd, void *drv_data,
 		for (i = 0; i < IN_MAX_DEVS; i++)
 			if (!in_devices[i].probed) break;
 		if (i >= IN_MAX_DEVS) {
-			printf("input: too many devices, can't add %s\n", name);
+			lprintf("input: too many devices, can't add %s\n", name);
 			return;
 		}
 		in_free(&in_devices[i]);
@@ -112,12 +131,13 @@ void in_register(const char *nname, int drv_id, int drv_fd_hnd, void *drv_data,
 	if (i + 1 > in_dev_count)
 		in_dev_count = i + 1;
 
-	printf("input: new device #%d \"%s\"\n", i, name);
+	lprintf("input: new device #%d \"%s\"\n", i, name);
 update:
 	in_devices[i].probed = 1;
 	in_devices[i].does_combos = combos;
 	in_devices[i].drv_id = drv_id;
 	in_devices[i].drv_fd_hnd = drv_fd_hnd;
+	in_devices[i].key_names = key_names;
 	in_devices[i].drv_data = drv_data;
 
 	if (in_devices[i].binds != NULL) {
@@ -227,7 +247,9 @@ void in_probe(void)
 	}
 
 	if (in_have_async_devs)
-		printf("input: async-only devices detected..\n");
+		lprintf("input: async-only devices detected..\n");
+
+	in_debug_dump();
 }
 
 /* async update */
@@ -250,9 +272,11 @@ int in_update(int *result)
 				ret |= in_gp2x_update(dev->drv_data, dev->binds, result);
 				break;
 #endif
+#ifdef IN_VK
 			case IN_DRVID_VK:
 				ret |= in_vk_update(dev->drv_data, dev->binds, result);
 				break;
+#endif
 			}
 		}
 	}
@@ -260,26 +284,6 @@ int in_update(int *result)
 	return ret;
 }
 
-void in_set_blocking(int is_blocking)
-{
-	int i, ret;
-
-	/* have_async_devs means we will have to do all reads async anyway.. */
-	if (!in_have_async_devs) {
-		for (i = 0; i < in_dev_count; i++) {
-			if (in_devices[i].probed)
-				DRV(in_devices[i].drv_id).set_blocking(in_devices[i].drv_data, is_blocking);
-		}
-	}
-
-	menu_key_state = 0;
-
-	/* flush events */
-	do {
-		ret = in_update_keycode(NULL, NULL, 0);
-	} while (ret >= 0);
-}
-
 static int in_update_kc_async(int *dev_id_out, int *is_down_out, int timeout_ms)
 {
 	int i, is_down, result;
@@ -342,7 +346,7 @@ int in_update_keycode(int *dev_id_out, int *is_down_out, int timeout_ms)
 
 	if (count == 0) {
 		/* don't deadlock, fail */
-		printf("input: failed to find devices to read\n");
+		lprintf("input: failed to find devices to read\n");
 		exit(1);
 	}
 
@@ -361,9 +365,6 @@ int in_update_keycode(int *dev_id_out, int *is_down_out, int timeout_ms)
 
 		drv = &DRV(in_devices[dev_id].drv_id);
 		result = drv->update_keycode(in_devices[dev_id].drv_data, &is_down);
-
-		/* update_keycode() might return -1 when some not interesting
-		 * event happened, like sync event for evdev. */
 		if (result >= 0)
 			break;
 
@@ -376,12 +377,12 @@ int in_update_keycode(int *dev_id_out, int *is_down_out, int timeout_ms)
 		}
 	}
 
-	if (result == -1)
+	if (result < 0)
 		return -1;
 finish:
 	/* keep track of menu key state, to allow mixing
 	 * in_update_keycode() and in_menu_wait_any() calls */
-	result_menu = drv->menu_translate(result);
+	result_menu = drv->menu_translate(in_devices[dev_id].drv_data, result);
 	if (result_menu != 0) {
 		if (is_down)
 			menu_key_state |=  result_menu;
@@ -406,16 +407,13 @@ int in_menu_wait_any(int timeout_ms)
 		int code, is_down = 0, dev_id = 0;
 
 		code = in_update_keycode(&dev_id, &is_down, timeout_ms);
-		if (code >= 0)
-			code = DRV(in_devices[dev_id].drv_id).menu_translate(code);
-
-		if (timeout_ms >= 0)
-			break;
 		if (code < 0)
-			continue;
-		menu_last_used_dev = dev_id;
-		if (keys_old != menu_key_state)
 			break;
+
+		if (keys_old != menu_key_state) {
+			menu_last_used_dev = dev_id;
+			break;
+		}
 	}
 
 	return menu_key_state;
@@ -470,21 +468,83 @@ const int *in_get_dev_def_binds(int dev_id)
 	return in_devices[dev_id].binds + in_devices[dev_id].key_count * IN_BINDTYPE_COUNT;
 }
 
-int in_get_dev_info(int dev_id, int what)
+int in_get_config(int dev_id, int what, void *val)
 {
-	if (dev_id < 0 || dev_id >= IN_MAX_DEVS)
-		return 0;
+	int *ival = val;
+	in_dev_t *dev;
 
+	if (dev_id < 0 || dev_id >= IN_MAX_DEVS || val == NULL)
+		return -1;
+
+	dev = &in_devices[dev_id];
 	switch (what) {
-	case IN_INFO_BIND_COUNT:
-		return in_devices[dev_id].key_count;
-	case IN_INFO_DOES_COMBOS:
-		return in_devices[dev_id].does_combos;
+	case IN_CFG_BIND_COUNT:
+		*ival = dev->key_count;
+		break;
+	case IN_CFG_DOES_COMBOS:
+		*ival = dev->does_combos;
+		break;
+	case IN_CFG_BLOCKING:
+	case IN_CFG_KEY_NAMES:
+		return -1; /* not implemented */
+	default:
+		return DRV(dev->drv_id).get_config(dev->drv_data, what, ival);
 	}
 
 	return 0;
 }
 
+static int in_set_blocking(int is_blocking)
+{
+	int i, ret;
+
+	/* have_async_devs means we will have to do all reads async anyway.. */
+	if (!in_have_async_devs) {
+		for (i = 0; i < in_dev_count; i++) {
+			if (in_devices[i].probed)
+				DRV(in_devices[i].drv_id).set_config(in_devices[i].drv_data,
+								     IN_CFG_BLOCKING, is_blocking);
+		}
+	}
+
+	menu_key_state = 0;
+
+	/* flush events */
+	do {
+		ret = in_update_keycode(NULL, NULL, 0);
+	} while (ret >= 0);
+
+	return 0;
+}
+
+int in_set_config(int dev_id, int what, const void *val, int size)
+{
+	const int *ival = val;
+	in_dev_t *dev;
+
+	if (what == IN_CFG_BLOCKING)
+		return in_set_blocking(*ival);
+
+	if (dev_id < 0 || dev_id >= IN_MAX_DEVS)
+		return -1;
+
+	dev = &in_devices[dev_id];
+	if (what == IN_CFG_KEY_NAMES) {
+		const char * const *names = val;
+		int count = size / sizeof(names[0]);
+
+		if (count < dev->key_count) {
+			lprintf("input: set_key_names: not enough keys\n");
+			return -1;
+		}
+
+		dev->key_names = names;
+		return 0;
+	}
+
+	return DRV(dev->drv_id).set_config(dev->drv_data, what, *ival);
+}
+
 const char *in_get_dev_name(int dev_id, int must_be_active, int skip_pfix)
 {
 	const char *name, *tmp;
@@ -507,11 +567,28 @@ const char *in_get_dev_name(int dev_id, int must_be_active, int skip_pfix)
 	return name;
 }
 
+int in_name_to_id(const char *dev_name)
+{
+	int i;
+
+	for (i = 0; i < in_dev_count; i++)
+		if (strcmp(dev_name, in_devices[i].name) == 0)
+			break;
+
+	if (i >= in_dev_count) {
+		lprintf("input: in_name_to_id: no such device: %s\n", dev_name);
+		return -1;
+	}
+
+	return i;
+}
+
 /* never returns NULL */
 const char *in_get_key_name(int dev_id, int keycode)
 {
+	const char *name = NULL;
 	static char xname[16];
-	const char *name;
+	in_dev_t *dev;
 
 	if (dev_id < 0)		/* want last used dev? */
 		dev_id = menu_last_used_dev;
@@ -519,10 +596,16 @@ const char *in_get_key_name(int dev_id, int keycode)
 	if (dev_id < 0 || dev_id >= IN_MAX_DEVS)
 		return "Unkn0";
 
+	dev = &in_devices[dev_id];
 	if (keycode < 0)	/* want name for menu key? */
-		keycode = DRV(in_devices[dev_id].drv_id).menu_translate(keycode);
+		keycode = DRV(dev->drv_id).menu_translate(dev->drv_data, keycode);
+
+	if (dev->key_names != NULL && 0 <= keycode && keycode < dev->key_count)
+		name = dev->key_names[keycode];
+	if (name != NULL)
+		return name;
 
-	name = DRV(in_devices[dev_id].drv_id).get_key_name(keycode);
+	name = DRV(dev->drv_id).get_key_name(keycode);
 	if (name != NULL)
 		return name;
 
@@ -535,6 +618,28 @@ const char *in_get_key_name(int dev_id, int keycode)
 	return xname;
 }
 
+int in_get_key_code(int dev_id, const char *key_name)
+{
+	in_dev_t *dev;
+	int i;
+
+	if (dev_id < 0)		/* want last used dev? */
+		dev_id = menu_last_used_dev;
+
+	if (dev_id < 0 || dev_id >= IN_MAX_DEVS)
+		return -1;
+
+	dev = &in_devices[dev_id];
+	if (dev->key_names == NULL)
+		return -1;
+
+	for (i = 0; i < dev->key_count; i++)
+		if (dev->key_names[i] && strcasecmp(dev->key_names[i], key_name) == 0)
+			return i;
+
+	return -1;
+}
+
 int in_bind_key(int dev_id, int keycode, int mask, int bind_type, int force_unbind)
 {
 	int ret, count;
@@ -572,22 +677,39 @@ int in_bind_key(int dev_id, int keycode, int mask, int bind_type, int force_unbi
 	return 0;
 }
 
-void in_unbind_all(int dev_id, int act_mask, int bind_type)
+/*
+ * Unbind act_mask on binds with type bind_type
+ * - if dev_id_ < 0, affects all devices
+ *   else only affects dev_id_
+ * - if act_mask == -1, unbind all keys
+ *   else only actions in mask
+ */
+void in_unbind_all(int dev_id_, int act_mask, int bind_type)
 {
+	int dev_id = 0, dev_last = IN_MAX_DEVS - 1;
 	int i, count;
 	in_dev_t *dev;
 
-	if (dev_id < 0 || dev_id >= IN_MAX_DEVS || bind_type >= IN_BINDTYPE_COUNT)
+	if (dev_id_ >= 0)
+		dev_id = dev_last = dev_id_;
+
+	if (bind_type >= IN_BINDTYPE_COUNT)
 		return;
 
-	dev = &in_devices[dev_id];
-	count = dev->key_count;
+	for (; dev_id <= dev_last; dev_id++) {
+		dev = &in_devices[dev_id];
+		count = dev->key_count;
 
-	if (dev->binds == NULL)
-		return;
+		if (dev->binds == NULL)
+			continue;
 
-	for (i = 0; i < count; i++)
-		dev->binds[IN_BIND_OFFS(i, bind_type)] &= ~act_mask;
+		if (act_mask != -1) {
+			for (i = 0; i < count; i++)
+				dev->binds[IN_BIND_OFFS(i, bind_type)] &= ~act_mask;
+		}
+		else
+			memset(dev->binds, 0, sizeof(dev->binds[0]) * count * IN_BINDTYPE_COUNT);
+	}
 }
 
 /* returns device id, or -1 on error */
@@ -604,7 +726,7 @@ int in_config_parse_dev(const char *name)
 	}
 
 	if (drv_id < 0) {
-		printf("input: missing driver for %s\n", name);
+		lprintf("input: missing driver for %s\n", name);
 		return -1;
 	}
 
@@ -622,7 +744,7 @@ int in_config_parse_dev(const char *name)
 		for (i = 0; i < IN_MAX_DEVS; i++)
 			if (in_devices[i].name == NULL) break;
 		if (i >= IN_MAX_DEVS) {
-			printf("input: too many devices, can't add %s\n", name);
+			lprintf("input: too many devices, can't add %s\n", name);
 			return -1;
 		}
 	}
@@ -693,7 +815,19 @@ int in_config_bind_key(int dev_id, const char *key, int acts, int bind_type)
 			in_config_start();
 		}
 
-		kc = DRV(dev->drv_id).get_key_code(key);
+		kc = -1;
+		if (dev->key_names != NULL) {
+			for (i = 0; i < dev->key_count; i++) {
+				const char *k = dev->key_names[i];
+				if (k != NULL && strcasecmp(k, key) == 0) {
+					kc = i;
+					break;
+				}
+			}
+		}
+
+		if (kc < 0)
+			kc = DRV(dev->drv_id).get_key_code(key);
 		if (kc < 0 && strlen(key) == 1) {
 			/* assume scancode */
 			kc = key[0];
@@ -701,7 +835,7 @@ int in_config_bind_key(int dev_id, const char *key, int acts, int bind_type)
 	}
 
 	if (kc < 0 || kc >= dev->key_count) {
-		printf("input: bad key: %s\n", key);
+		lprintf("input: bad key: %s\n", key);
 		return -1;
 	}
 
@@ -762,12 +896,12 @@ void in_debug_dump(void)
 {
 	int i;
 
-	printf("# drv probed binds name\n");
+	lprintf("# drv probed binds name\n");
 	for (i = 0; i < IN_MAX_DEVS; i++) {
 		in_dev_t *d = &in_devices[i];
 		if (!d->probed && d->name == NULL && d->binds == NULL)
 			continue;
-		printf("%d %3d %6c %5c %s\n", i, d->drv_id, d->probed ? 'y' : 'n',
+		lprintf("%d %3d %6c %5c %s\n", i, d->drv_id, d->probed ? 'y' : 'n',
 			d->binds ? 'y' : 'n', d->name);
 	}
 }
@@ -779,10 +913,11 @@ static void in_def_free(void *drv_data) {}
 static int  in_def_get_bind_count(void) { return 0; }
 static void in_def_get_def_binds(int *binds) {}
 static int  in_def_clean_binds(void *drv_data, int *b, int *db) { return 0; }
-static void in_def_set_blocking(void *data, int y) {}
+static int  in_def_get_config(void *drv_data, int what, int *val) { return -1; }
+static int  in_def_set_config(void *drv_data, int what, int val) { return -1; }
 static int  in_def_update_keycode(void *drv_data, int *is_down) { return 0; }
-static int  in_def_menu_translate(int keycode) { return keycode; }
-static int  in_def_get_key_code(const char *key_name) { return 0; }
+static int  in_def_menu_translate(void *drv_data, int keycode) { return keycode; }
+static int  in_def_get_key_code(const char *key_name) { return -1; }
 static const char *in_def_get_key_name(int keycode) { return NULL; }
 
 void in_init(void)
@@ -800,7 +935,8 @@ void in_init(void)
 		in_drivers[i].get_bind_count = in_def_get_bind_count;
 		in_drivers[i].get_def_binds = in_def_get_def_binds;
 		in_drivers[i].clean_binds = in_def_clean_binds;
-		in_drivers[i].set_blocking = in_def_set_blocking;
+		in_drivers[i].get_config = in_def_get_config;
+		in_drivers[i].set_config = in_def_set_config;
 		in_drivers[i].update_keycode = in_def_update_keycode;
 		in_drivers[i].menu_translate = in_def_menu_translate;
 		in_drivers[i].get_key_code = in_def_get_key_code;
@@ -813,7 +949,9 @@ void in_init(void)
 #ifdef IN_EVDEV
 	in_evdev_init(&in_drivers[IN_DRVID_EVDEV]);
 #endif
+#ifdef IN_VK
 	in_vk_init(&in_drivers[IN_DRVID_VK]);
+#endif
 }
 
 #if 0
@@ -830,12 +968,12 @@ int main(void)
 	while (1) {
 		int dev = 0, down;
 		ret = in_update_keycode(&dev, &down);
-		printf("#%i: %i %i (%s)\n", dev, down, ret, in_get_key_name(dev, ret));
+		lprintf("#%i: %i %i (%s)\n", dev, down, ret, in_get_key_name(dev, ret));
 	}
 #else
 	while (1) {
 		ret = in_menu_wait_any();
-		printf("%08x\n", ret);
+		lprintf("%08x\n", ret);
 	}
 #endif