/* See LICENSE file for copyright and license details. */
#include "libgamepad.h"
#include <sys/ioctl.h>
#include <assert.h>
#include <poll.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
struct abs_axis {
intmax_t min;
intmax_t max;
intmax_t value;
size_t max_len;
size_t min_len;
};
static volatile sig_atomic_t sigwinch_received = 0;
static volatile sig_atomic_t sigint_received = 0;
static void
sigwinch_handler(int signo)
{
(void) signo;
sigwinch_received = 1;
}
static void
sigint_handler(int signo)
{
(void) signo;
sigint_received = 1;
}
static const char *
draw_axis(char buffer[], const struct abs_axis *axis, size_t len)
{
char value_buf[sizeof(intmax_t) * 3 + 2];
size_t width, x, value_len;
#ifdef __GNUC__
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wformat-overflow"
#endif
sprintf(buffer, "%-*ji%ji", (int)(len - axis->max_len), axis->min, axis->max);
#ifdef __GNUC__
# pragma GCC diagnostic pop
#endif
width = len - axis->max_len - axis->min_len;
value_len = (size_t)sprintf(value_buf, "%ji", axis->value);
x = axis->max_len + (width - value_len) / 2;
memcpy(&buffer[x], value_buf, value_len);
x = (size_t)(axis->value < axis->min ? 0 : /* this actually happens */
axis->value > axis->max ? axis->max - axis->min :
axis->value - axis->min) * len;
x += (size_t)(axis->max - axis->min) / 2;
x /= (size_t)(axis->max - axis->min);
memmove(&buffer[x + sizeof("\033[m") - 1], &buffer[x], len + 1 - x);
memcpy(&buffer[x], "\033[m", sizeof("\033[m") - 1);
return buffer;
}
int
main(int argc, char *argv[])
{
const struct input_absinfo *absinfo;
struct libgamepad_input_event event;
struct libgamepad_device gamepad;
const char **button_names;
size_t max_button_name_len;
size_t len, x, y, i;
struct winsize size;
size_t button_columns;
size_t button_rows;
size_t max_abs_axis_name_len;
struct abs_axis *abs_axes;
char *buffer;
ssize_t saxis_len;
size_t axis_len, req_axis_len;
size_t max_max_len, max_min_len;
ssize_t r;
struct pollfd pfd;
struct sigaction action;
if (argc != 2) {
fprintf(stderr, "Please provide the path to the subdevice as the only command line argument\n");
return 1;
}
if (libgamepad_open_device(&gamepad, AT_FDCWD, argv[1], O_RDONLY | O_NONBLOCK)) {
perror("libgamepad_open_device");
return 1;
}
pfd.fd = gamepad.fd;
pfd.events = POLLIN;
pfd.revents = 0;
memset(&action, 0, sizeof(action));
action.sa_handler = sigwinch_handler;
if (sigaction(SIGWINCH, &action, NULL)) {
perror("sigaction");
return 1;
}
memset(&action, 0, sizeof(action));
action.sa_handler = sigint_handler;
if (sigaction(SIGINT, &action, NULL)) {
perror("sigaction");
return 1;
}
redraw:
button_names = NULL;
max_button_name_len = 0;
button_columns = 0;
button_rows = 0;
max_abs_axis_name_len = 0;
abs_axes = NULL;
max_max_len = 0;
max_min_len = 0;
while (ioctl(STDOUT_FILENO, TIOCGWINSZ, &size)) {
if (errno != EINTR) {
perror("TIOCGWINSZ");
return 1;
}
sigwinch_received = 0;
if (sigint_received)
goto out;
}
size.ws_row = size.ws_row < 1 ? 1 : size.ws_row;
size.ws_col = size.ws_col < 1 ? 1 : size.ws_col;
if (gamepad.nbuttons) {
button_names = calloc(gamepad.nbuttons, sizeof(*button_names));
if (!button_names) {
perror("calloc");
return 1;
}
for (i = 0; i < gamepad.nbuttons; i++) {
button_names[i] = libgamepad_get_button_name(NULL, gamepad.buttons[i]);
len = strlen(button_names[i]);
max_button_name_len = max_button_name_len > len ? max_button_name_len : len;
}
button_columns = (size.ws_col + 1) / (max_button_name_len + 3);
button_columns = button_columns < 1 ? 1 : button_columns;
button_rows = (gamepad.nbuttons + button_columns - 1) / button_columns;
}
if (gamepad.nabsolute_axes) {
abs_axes = calloc(gamepad.nabsolute_axes, sizeof(*abs_axes));
if (!abs_axes) {
perror("calloc");
return 1;
}
for (i = 0; i < gamepad.nabsolute_axes; i++) {
len = strlen(libgamepad_get_absolute_axis_name(NULL, gamepad.absolute_axes[i]));
max_abs_axis_name_len = max_abs_axis_name_len > len ? max_abs_axis_name_len : len;
absinfo = libgamepad_get_absolute_axis_info(&gamepad, gamepad.absolute_axes[i]);
assert(absinfo);
abs_axes[i].min = (intmax_t)absinfo->minimum;
abs_axes[i].max = (intmax_t)absinfo->maximum;
abs_axes[i].value = (intmax_t)absinfo->value;
abs_axes[i].min_len = (size_t)snprintf(NULL, 0, "%ji", abs_axes[i].min);
max_min_len = max_min_len > abs_axes[i].min_len ? max_min_len : abs_axes[i].min_len;
abs_axes[i].max_len = (size_t)snprintf(NULL, 0, "%ji", abs_axes[i].max);
max_max_len = max_max_len > abs_axes[i].max_len ? max_max_len : abs_axes[i].max_len;
}
}
req_axis_len = max_max_len + max_min_len + 2;
req_axis_len += max_max_len > max_min_len ? max_max_len : max_min_len;
saxis_len = (ssize_t)size.ws_col - (ssize_t)max_abs_axis_name_len - 3;
if (saxis_len < (ssize_t)req_axis_len)
saxis_len = (ssize_t)req_axis_len;
axis_len = (size_t)saxis_len;
buffer = malloc(axis_len + sizeof("\033[m"));
if (!buffer) {
perror("malloc");
return 1;
}
printf("\033[m\033[H\033[J\033[?25l");
for (i = 0; i < gamepad.nbuttons; i++) {
x = i % button_columns;
y = i / button_columns;
printf("\033[%zu;%zuH%s¿%s?\033[m", y + 1, x * (max_button_name_len + 3) + 1,
libgamepad_get_button_is_pressed(&gamepad, gamepad.buttons[i]) ? "\033[7m" : "\033[m",
button_names[i]);
}
printf("\033[%zuH", button_rows + 1);
for (i = 0; i < gamepad.nabsolute_axes; i++) {
printf("\n%-*s ¿\033[7m%s?", (int)max_abs_axis_name_len,
libgamepad_get_absolute_axis_name(NULL, gamepad.absolute_axes[i]),
draw_axis(buffer, &abs_axes[i], axis_len));
}
fflush(stdout);
for (;;) {
if (sigwinch_received) {
sigwinch_received = 0;
free(button_names);
free(abs_axes);
free(buffer);
goto redraw;
}
if (sigint_received)
break;
if (poll(&pfd, 1, -1) < 0) {
if (errno == EINTR)
continue;
break;
}
r = libgamepad_next_event(&gamepad, &event, 1);
if (r <= 0) {
if (!r || errno == EINTR)
continue;
if (errno == EAGAIN)
break;
perror("libgamepad_next_event");
return 1;
}
if (event.type == LIBGAMEPAD_BUTTON) {
i = (size_t)gamepad.button_map[event.code];
x = i % button_columns;
y = i / button_columns;
printf("\033[%zu;%zuH%s[%s]\033[m", y + 1, x * (max_button_name_len + 3) + 1,
event.value ? "\033[7m" : "\033[m", button_names[i]);
fflush(stdout);
} else if (event.type == LIBGAMEPAD_ABSOLUTE_AXIS) {
i = (size_t)gamepad.absolute_axis_map[event.code];
y = button_rows + 1 + i;
x = max_abs_axis_name_len + 1;
abs_axes[i].value = (intmax_t)event.value;
printf("\033[%zu;%zuH[\033[7m%s]", y + 1, x + 1, draw_axis(buffer, &abs_axes[i], axis_len));
fflush(stdout);
}
/* TODO add relative axis */
}
out:
free(buffer);
free(button_names);
free(abs_axes);
libgamepad_close_device(&gamepad);
return 0;
}
