#include <stdlib.h>
#include <string.h>
-#include "common.h"
#include "input.h"
+#include "plat.h"
#include "../linux/in_evdev.h"
#include "../gp2x/in_gp2x.h"
char *name;
int *binds;
int probed:1;
+ int does_combos:1;
} in_dev_t;
static in_drv_t in_drivers[IN_DRVID_COUNT];
static in_dev_t in_devices[IN_MAX_DEVS];
static int in_dev_count = 0;
static int in_have_async_devs = 0;
+static int menu_key_state = 0;
+static int menu_last_used_dev = 0;
#define DRV(id) in_drivers[(unsigned)(id) < IN_DRVID_COUNT ? (id) : 0]
/* 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)
+void in_register(const char *nname, int drv_id, int drv_fd_hnd, void *drv_data, int combos)
{
int i, ret, dupe_count = 0, *binds;
char name[256], *name_end, *tmp;
printf("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].drv_data = drv_data;
}
}
+/* key combo handling, to be called by drivers that support it */
+void in_combos_find(int *binds, int last_key, int *combo_keys, int *combo_acts)
+{
+ int act, u;
+
+ *combo_keys = *combo_acts = 0;
+ for (act = 0; act < sizeof(binds[0]) * 8; act++)
+ {
+ int keyc = 0;
+ for (u = 0; u <= last_key; u++)
+ if (binds[u] & (1 << act))
+ keyc++;
+
+ if (keyc > 1)
+ {
+ // loop again and mark those keys and actions as combo
+ for (u = 0; u <= last_key; u++)
+ {
+ if (binds[u] & (1 << act)) {
+ *combo_keys |= 1 << u;
+ *combo_acts |= 1 << act;
+ }
+ }
+ }
+ }
+}
+
+int in_combos_do(int keys, int *binds, int last_key, int combo_keys, int combo_acts)
+{
+ int i, ret = 0;
+
+ for (i = 0; i <= last_key; i++)
+ {
+ int acts;
+ if (!(keys & (1 << i)))
+ continue;
+
+ acts = binds[i];
+ if (!acts)
+ continue;
+
+ if (combo_keys & (1 << i))
+ {
+ int acts_c = acts & combo_acts;
+ int u = last_key;
+ if (acts_c) {
+ // let's try to find the other one
+ for (u = i + 1; u <= last_key; u++)
+ if ( (keys & (1 << u)) && (binds[u] & acts_c) ) {
+ ret |= acts_c & binds[u];
+ keys &= ~((1 << i) | (1 << u));
+ break;
+ }
+ }
+ // add non-combo actions if combo ones were not found
+ if (u >= last_key)
+ ret |= acts & ~combo_acts;
+ } else
+ ret |= acts;
+ }
+
+ return ret;
+}
+
void in_probe(void)
{
int i;
return result;
}
-static int menu_key_state = 0;
-
void in_set_blocking(int is_blocking)
{
int i, ret;
} while (ret >= 0);
}
-/* TODO: move.. */
-#include <unistd.h>
-#include <sys/time.h>
-#include <time.h>
-
static int in_update_kc_async(int *dev_id_out, int *is_down_out, int timeout_ms)
{
- struct timeval start, now;
int i, is_down, result;
+ unsigned int ticks;
- gettimeofday(&start, NULL);
+ ticks = plat_get_ticks_ms();
while (1)
{
return result;
}
- if (timeout_ms >= 0) {
- gettimeofday(&now, NULL);
- if ((now.tv_sec - start.tv_sec) * 1000 +
- (now.tv_usec - start.tv_usec) / 1000 > timeout_ms)
- break;
- }
+ if (timeout_ms >= 0 && (int)(plat_get_ticks_ms() - ticks) > timeout_ms)
+ break;
- usleep(10000);
+ plat_sleep_ms(10);
}
return -1;
*/
int in_update_keycode(int *dev_id_out, int *is_down_out, int timeout_ms)
{
- int result = 0, dev_id = 0, is_down, result_menu;
+ int result = -1, dev_id = 0, is_down, result_menu;
int fds_hnds[IN_MAX_DEVS];
int i, ret, count = 0;
- in_drv_t *drv;
+ in_drv_t *drv = NULL;
+ unsigned int ticks;
if (in_have_async_devs) {
result = in_update_kc_async(&dev_id, &is_down, timeout_ms);
goto finish;
}
+ ticks = plat_get_ticks_ms();
+
for (i = 0; i < in_dev_count; i++) {
if (in_devices[i].probed)
fds_hnds[count++] = in_devices[i].drv_fd_hnd;
exit(1);
}
-again:
- /* TODO: move this block to platform/linux */
+ while (1)
{
- struct timeval tv, *timeout = NULL;
- int fdmax = -1;
- fd_set fdset;
-
- if (timeout_ms >= 0) {
- tv.tv_sec = timeout_ms / 1000;
- tv.tv_usec = (timeout_ms % 1000) * 1000;
- timeout = &tv;
- }
-
- FD_ZERO(&fdset);
- for (i = 0; i < count; i++) {
- if (fds_hnds[i] > fdmax) fdmax = fds_hnds[i];
- FD_SET(fds_hnds[i], &fdset);
- }
+ ret = plat_wait_event(fds_hnds, count, timeout_ms);
+ if (ret < 0)
+ break;
- ret = select(fdmax + 1, &fdset, NULL, NULL, timeout);
- if (ret == -1)
- {
- perror("input: select failed");
- sleep(1);
- return -1;
+ for (i = 0; i < in_dev_count; i++) {
+ if (in_devices[i].drv_fd_hnd == ret) {
+ dev_id = i;
+ break;
+ }
}
- if (ret == 0)
- return -1; /* timeout */
-
- for (i = 0; i < count; i++)
- if (FD_ISSET(fds_hnds[i], &fdset))
- ret = fds_hnds[i];
- }
+ drv = &DRV(in_devices[dev_id].drv_id);
+ result = drv->update_keycode(in_devices[dev_id].drv_data, &is_down);
- for (i = 0; i < in_dev_count; i++) {
- if (in_devices[i].drv_fd_hnd == ret) {
- dev_id = i;
+ /* update_keycode() might return -1 when some not interesting
+ * event happened, like sync event for evdev. */
+ if (result >= 0)
break;
+
+ if (timeout_ms >= 0) {
+ unsigned int ticks2 = plat_get_ticks_ms();
+ timeout_ms -= ticks2 - ticks;
+ ticks = ticks2;
+ if (timeout_ms <= 0)
+ break;
}
}
- 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.
- * XXX: timeout restarts.. */
if (result == -1)
- goto again;
-
+ return -1;
finish:
/* keep track of menu key state, to allow mixing
* in_update_keycode() and in_menu_wait_any() calls */
break;
if (code < 0)
continue;
+ menu_last_used_dev = dev_id;
if (keys_old != menu_key_state)
break;
}
{
static int inp_prev = 0;
static int repeats = 0;
- int ret, release = 0, wait = 666;
+ int ret, release = 0, wait = 450;
if (repeats)
wait = autorep_delay_ms;
return in_devices[dev_id].binds + count;
}
-int in_get_dev_bind_count(int dev_id)
+int in_get_dev_info(int dev_id, int what)
{
if (dev_id < 0 || dev_id >= IN_MAX_DEVS)
return 0;
- return in_bind_count(in_devices[dev_id].drv_id);
+ switch (what) {
+ case IN_INFO_BIND_COUNT:
+ return in_bind_count(in_devices[dev_id].drv_id);
+ case IN_INFO_DOES_COMBOS:
+ return in_devices[dev_id].does_combos;
+ }
+
+ return 0;
}
const char *in_get_dev_name(int dev_id, int must_be_active, int skip_pfix)
return NULL;
name = in_devices[dev_id].name;
+ if (name == NULL || !skip_pfix)
+ return name;
+
+ /* skip prefix */
tmp = strchr(name, ':');
if (tmp != NULL)
name = tmp + 1;
static char xname[16];
const char *name;
+ if (dev_id < 0) /* want last used dev? */
+ dev_id = menu_last_used_dev;
+
if (dev_id < 0 || dev_id >= IN_MAX_DEVS)
return "Unkn0";
+ if (keycode < 0) /* want name for menu key? */
+ keycode = DRV(in_devices[dev_id].drv_id).menu_translate(keycode);
+
name = DRV(in_devices[dev_id].drv_id).get_key_name(keycode);
if (name != NULL)
return name;