static void set_abs(struct libevdev *dev, unsigned int changes, unsigned int axis, struct input_absinfo *absinfo) { int rc; struct input_absinfo abs; const struct input_absinfo *a; if ((a = libevdev_get_abs_info(dev, axis)) == NULL) { fprintf(stderr, "Device '%s' doesn't have axis %s\n", libevdev_get_name(dev), libevdev_event_code_get_name(EV_ABS, axis)); return; } abs = *a; if (changes & OPT_MIN) abs.minimum = absinfo->minimum; if (changes & OPT_MAX) abs.maximum = absinfo->maximum; if (changes & OPT_FUZZ) abs.fuzz = absinfo->fuzz; if (changes & OPT_FLAT) abs.flat = absinfo->flat; if (changes & OPT_RES) abs.resolution = absinfo->resolution; rc = libevdev_kernel_set_abs_info(dev, axis, &abs); if (rc != 0) fprintf(stderr, "Failed to set absinfo %s: %s", libevdev_event_code_get_name(EV_ABS, axis), strerror(-rc)); }
END_TEST START_TEST(test_code_syn_name) { ck_assert_str_eq(libevdev_event_code_get_name(EV_SYN, SYN_REPORT), "SYN_REPORT"); ck_assert_str_eq(libevdev_event_code_get_name(EV_SYN, SYN_CONFIG), "SYN_CONFIG"); ck_assert_str_eq(libevdev_event_code_get_name(EV_SYN, SYN_MT_REPORT), "SYN_MT_REPORT"); ck_assert_str_eq(libevdev_event_code_get_name(EV_SYN, SYN_DROPPED), "SYN_DROPPED"); /* there is no SYN_MAX */ }
END_TEST START_TEST(test_code_snd_name) { /* pick out a few only */ ck_assert_str_eq(libevdev_event_code_get_name(EV_SND, SND_CLICK), "SND_CLICK"); ck_assert_str_eq(libevdev_event_code_get_name(EV_SND, SND_TONE), "SND_TONE"); ck_assert_str_eq(libevdev_event_code_get_name(EV_SND, SND_MAX), "SND_MAX"); ck_assert(libevdev_event_code_get_name(EV_SND, SND_MAX - 1) == NULL); }
END_TEST START_TEST(test_code_led_name) { /* pick out a few only */ ck_assert_str_eq(libevdev_event_code_get_name(EV_LED, LED_NUML), "LED_NUML"); ck_assert_str_eq(libevdev_event_code_get_name(EV_LED, LED_KANA), "LED_KANA"); ck_assert_str_eq(libevdev_event_code_get_name(EV_LED, LED_MAX), "LED_MAX"); ck_assert(libevdev_event_code_get_name(EV_LED, LED_MAX - 1) == NULL); }
END_TEST START_TEST(test_code_rel_name) { /* pick out a few only */ ck_assert_str_eq(libevdev_event_code_get_name(EV_REL, REL_X), "REL_X"); ck_assert_str_eq(libevdev_event_code_get_name(EV_REL, REL_Y), "REL_Y"); ck_assert_str_eq(libevdev_event_code_get_name(EV_REL, REL_MISC), "REL_MISC"); ck_assert_str_eq(libevdev_event_code_get_name(EV_REL, REL_MAX), "REL_MAX"); ck_assert(libevdev_event_code_get_name(EV_REL, REL_MAX - 1) == NULL); }
END_TEST START_TEST(test_code_ff_name) { /* pick out a few only */ ck_assert_str_eq(libevdev_event_code_get_name(EV_FF, FF_STATUS_STOPPED), "FF_STATUS_STOPPED"); ck_assert_str_eq(libevdev_event_code_get_name(EV_FF, FF_FRICTION), "FF_FRICTION"); ck_assert_str_eq(libevdev_event_code_get_name(EV_FF, FF_CUSTOM), "FF_CUSTOM"); ck_assert_str_eq(libevdev_event_code_get_name(EV_FF, FF_MAX), "FF_MAX"); ck_assert(libevdev_event_code_get_name(EV_FF, FF_MAX - 1) == NULL); }
END_TEST START_TEST(test_code_sw_name) { /* pick out a few only */ ck_assert_str_eq(libevdev_event_code_get_name(EV_SW, SW_LID), "SW_LID"); ck_assert_str_eq(libevdev_event_code_get_name(EV_SW, SW_RFKILL_ALL), "SW_RFKILL_ALL"); ck_assert_str_eq(libevdev_event_code_get_name(EV_SW, SW_LINEIN_INSERT), "SW_LINEIN_INSERT"); ck_assert_str_eq(libevdev_event_code_get_name(EV_SW, SW_MAX), "SW_MAX"); ck_assert(libevdev_event_code_get_name(EV_SW, SW_MAX - 1) == NULL); }
END_TEST START_TEST(test_code_msc_name) { /* pick out a few only */ ck_assert_str_eq(libevdev_event_code_get_name(EV_MSC, MSC_SERIAL), "MSC_SERIAL"); ck_assert_str_eq(libevdev_event_code_get_name(EV_MSC, MSC_RAW), "MSC_RAW"); #ifdef MSC_TIMESTAMP ck_assert_str_eq(libevdev_event_code_get_name(EV_MSC, MSC_TIMESTAMP), "MSC_TIMESTAMP"); #endif ck_assert_str_eq(libevdev_event_code_get_name(EV_MSC, MSC_MAX), "MSC_MAX"); ck_assert(libevdev_event_code_get_name(EV_MSC, MSC_MAX - 1) == NULL); }
int touchpad_handle_event(struct touchpad *tp, void *userdata, const struct input_event *ev) { int rc = 0; #if 0 printf("%s %s: %d\n", libevdev_event_type_get_name(ev->type), libevdev_event_code_get_name(ev->type, ev->code), ev->value); #endif switch(ev->type) { case EV_ABS: touchpad_update_abs_state(tp, ev); break; case EV_KEY: touchpad_update_button_state(tp, ev); break; /* we never get a SYN_DROPPED, it's filtered higer up */ case EV_SYN: touchpad_pre_process_touches(tp); touchpad_post_events(tp, userdata); touchpad_post_process_touches(tp); break; } return rc; }
int tp_process_button(struct tp_dispatch *tp, const struct input_event *e, uint64_t time) { struct libinput *libinput = tp_libinput_context(tp); uint32_t mask = 1 << (e->code - BTN_LEFT); /* Ignore other buttons on clickpads */ if (tp->buttons.is_clickpad && e->code != BTN_LEFT) { log_bug_kernel(libinput, "received %s button event on a clickpad\n", libevdev_event_code_get_name(EV_KEY, e->code)); return 0; } if (e->value) { tp->buttons.state |= mask; tp->queued |= TOUCHPAD_EVENT_BUTTON_PRESS; } else { tp->buttons.state &= ~mask; tp->queued |= TOUCHPAD_EVENT_BUTTON_RELEASE; } return 0; }
static void set_led(struct libevdev *dev, unsigned int led, int led_state) { int rc; enum libevdev_led_value state = led_state ? LIBEVDEV_LED_ON : LIBEVDEV_LED_OFF; if (!libevdev_has_event_code(dev, EV_LED, led)) { fprintf(stderr, "Device '%s' doesn't have %s\n", libevdev_get_name(dev), libevdev_event_code_get_name(EV_LED, led)); return; } rc = libevdev_kernel_set_led_value(dev, led, state); if (rc != 0) fprintf(stderr, "Failed to set LED %s: %s", libevdev_event_code_get_name(EV_LED, led), strerror(-rc)); }
std::string evdevDevice::Button::GetName() const { // Buttons below 0x100 are mostly keyboard keys, and the names make sense if (m_code < 0x100) { const char* name = libevdev_event_code_get_name(EV_KEY, m_code); if (name) return StripSpaces(name); } // But controllers use codes above 0x100, and the standard label often doesn't match. // We are better off with Button 0 and so on. return "Button " + std::to_string(m_index); }
static int forward_event(struct libevdev_uinput *uidev, struct input_event *ev, struct chord* state) { int ret; enum touch t = NUM_TOUCHES; switch(ev->code){ case KEY_A: t = TOUCH_A; break; case KEY_S: t = TOUCH_S; break; case KEY_D: t = TOUCH_E; break; case KEY_F: t = TOUCH_T; break; case KEY_J: t = TOUCH_N; break; case KEY_K: t = TOUCH_I; break; case KEY_L: t = TOUCH_O; break; case KEY_SEMICOLON: t = TOUCH_P; break; } if(t < NUM_TOUCHES){ //fprintf(stderr, "current chord: 0x%02x\n", chord_state_bitmap(state)); switch(ev->value){ case 1: chord_touch_start(state, t); break; case 0: chord_touch_end(state, t); break; } if(chord_state_is_empty(state)){ lookup_key k = chord_accumulator_bitmap(state); int keycode = lookup_keycode(k); if(keycode != KEY_RESERVED){ fprintf(stderr, "chord 0x%02x %s\n", k, libevdev_event_code_get_name(EV_KEY, keycode)); ret = libevdev_uinput_write_event(uidev, EV_KEY, keycode , 1); if (ret < 0) {perror("Failed to write event"); return -1;} ret = libevdev_uinput_write_event(uidev, EV_KEY, keycode , 0); if (ret < 0) {perror("Failed to write event"); return -1;} ret = libevdev_uinput_write_event(uidev, EV_SYN, SYN_REPORT, 0); if (ret < 0) {perror("Failed to write event"); return -1;} } chord_reset(state); } } else { // printf("%s, %s, %d\n", // libevdev_event_type_get_name(ev->type), // libevdev_event_code_get_name(ev->type, ev->code), // ev->value); ret = libevdev_uinput_write_event(uidev, EV_KEY, ev->code , ev->value); if (ret < 0) {perror("Failed to write event"); return -1;} ret = libevdev_uinput_write_event(uidev, EV_SYN, SYN_REPORT, 0); if (ret < 0) {perror("Failed to write event"); return -1;} } return 0; }
END_TEST START_TEST(test_code_abs_name) { /* pick out a few only */ ck_assert_str_eq(libevdev_event_code_get_name(EV_ABS, ABS_X), "ABS_X"); ck_assert_str_eq(libevdev_event_code_get_name(EV_ABS, ABS_Y), "ABS_Y"); ck_assert_str_eq(libevdev_event_code_get_name(EV_ABS, ABS_MT_SLOT), "ABS_MT_SLOT"); ck_assert_str_eq(libevdev_event_code_get_name(EV_ABS, ABS_MISC), "ABS_MISC"); ck_assert_str_eq(libevdev_event_code_get_name(EV_ABS, ABS_MAX), "ABS_MAX"); ck_assert(libevdev_event_code_get_name(EV_ABS, ABS_MAX - 1) == NULL); }
int next_event_wrapper(struct adhoc *adhoc, struct input_event *event) { int r = libevdev_next_event(adhoc->dev, LIBEVDEV_READ_FLAG_NORMAL | LIBEVDEV_READ_FLAG_BLOCKING, event); if (r < 0) { error(0, -r, "libevdev_next_event failed"); return r; } if (r == LIBEVDEV_READ_STATUS_SYNC) { fprintf(stderr, "libevdev_next_event returned LIBEVDEV_READ_STATUS_SYNC, handling not implemented!\n"); return 0; } #ifdef DEBUG fprintf(stderr, "event [type: %s, code: %s, value: %d]\n", libevdev_event_type_get_name(event->type), libevdev_event_code_get_name(event->type, event->code), event->value); #endif return 0; }
std::string evdevDevice::ForceFeedback::GetName() const { // We have some default names. switch (m_type) { case FF_SINE: return "Sine"; case FF_TRIANGLE: return "Triangle"; case FF_SQUARE: return "Square"; case FF_RUMBLE: return "LeftRight"; default: { const char* name = libevdev_event_code_get_name(EV_FF, m_type); if (name) return StripSpaces(name); return "Unknown"; } } }
static void all_codes_create(struct litest_device *d) { int events[KEY_MAX * 2 + 2]; int code, idx; for (idx = 0, code = 0; code < KEY_MAX; code++) { const char *name = libevdev_event_code_get_name(EV_KEY, code); if (name && strneq(name, "BTN_", 4)) continue; events[idx++] = EV_KEY; events[idx++] = code; } events[idx++] = -1; events[idx++] = -1; d->uinput = litest_create_uinput_device_from_description(NAME, &input_id, NULL, events); }
END_TEST START_TEST(test_code_key_name) { /* pick out a few only */ ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, KEY_RESERVED), "KEY_RESERVED"); ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, KEY_ESC), "KEY_ESC"); ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, KEY_1), "KEY_1"); ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, KEY_2), "KEY_2"); ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, KEY_UNKNOWN), "KEY_UNKNOWN"); ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_0), "BTN_0"); ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_LEFT), "BTN_LEFT"); ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_TRIGGER), "BTN_TRIGGER"); ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_A), "BTN_SOUTH"); ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_TOOL_PEN), "BTN_TOOL_PEN"); ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, KEY_TOUCHPAD_TOGGLE), "KEY_TOUCHPAD_TOGGLE"); ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_TRIGGER_HAPPY), "BTN_TRIGGER_HAPPY1"); ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, KEY_MAX), "KEY_MAX"); ck_assert(libevdev_event_code_get_name(EV_KEY, KEY_MAX - 1) == NULL); /* special cases that resolve to something else */ ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, KEY_HANGUEL), "KEY_HANGEUL"); ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, KEY_SCREENLOCK), "KEY_COFFEE"); ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_MISC), "BTN_0"); ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_MOUSE), "BTN_LEFT"); ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_JOYSTICK), "BTN_TRIGGER"); ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_GAMEPAD), "BTN_SOUTH"); ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_DIGI), "BTN_TOOL_PEN"); ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_WHEEL), "BTN_GEAR_DOWN"); ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_TRIGGER_HAPPY), "BTN_TRIGGER_HAPPY1"); }
bool evdev_middlebutton_filter_button(struct evdev_device *device, uint64_t time, int button, enum libinput_button_state state) { enum evdev_middlebutton_event event; bool is_press = state == LIBINPUT_BUTTON_STATE_PRESSED; int rc; unsigned int bit = (button - BTN_LEFT); uint32_t old_mask = 0; if (!device->middlebutton.enabled) return false; switch (button) { case BTN_LEFT: if (is_press) event = MIDDLEBUTTON_EVENT_L_DOWN; else event = MIDDLEBUTTON_EVENT_L_UP; break; case BTN_RIGHT: if (is_press) event = MIDDLEBUTTON_EVENT_R_DOWN; else event = MIDDLEBUTTON_EVENT_R_UP; break; /* BTN_MIDDLE counts as "other" and resets middle button * emulation */ case BTN_MIDDLE: default: event = MIDDLEBUTTON_EVENT_OTHER; break; } if (button < BTN_LEFT || bit >= sizeof(device->middlebutton.button_mask) * 8) { log_bug_libinput(device->base.seat->libinput, "Button mask too small for %d\n", libevdev_event_code_get_name(EV_KEY, button)); return true; } rc = evdev_middlebutton_handle_event(device, time, event); old_mask = device->middlebutton.button_mask; if (is_press) device->middlebutton.button_mask |= 1 << bit; else device->middlebutton.button_mask &= ~(1 << bit); if (old_mask != device->middlebutton.button_mask && device->middlebutton.button_mask == 0) { evdev_middlebutton_handle_event(device, time, MIDDLEBUTTON_EVENT_ALL_UP); evdev_middlebutton_apply_config(device); } return rc; }
int main(int argc, char const *argv[]) { if (argc < 5) { printf("Usage: evmpd HOSTNAME PORT DEVICE HALT_COMMAND\n"); return EXIT_FAILURE; } struct mpd_connection *client = connect(argv[1], strtol(argv[2], NULL, 10)); struct libevdev *dev = NULL; int fd; int rc = 1; fd = open(argv[3], O_RDONLY | O_NONBLOCK); rc = libevdev_new_from_fd(fd, &dev); if (rc < 0) { fprintf(stderr, "Failed to init libevdev (%d)\n", strerror(-rc)); return EXIT_FAILURE; } printf("Input device name: \"%s\"\n", libevdev_get_name(dev)); printf("Input device ID: bus %#x vendor %#x product %#x\n", libevdev_get_id_bustype(dev), libevdev_get_id_vendor(dev), libevdev_get_id_product(dev)); do { struct input_event ev; rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev); if (rc == 0 && ev.value == 0) { if (libevdev_event_is_code(&ev, EV_KEY, KEY_F4)) { system(argv[4]); printf("shutdown\n"); } else if (libevdev_event_is_code(&ev, EV_KEY, KEY_PLAYPAUSE)) { struct mpd_status *status = mpd_run_status(client); enum mpd_state state = mpd_status_get_state(status); if (state != MPD_STATE_PLAY && state != MPD_STATE_PAUSE) { mpd_run_play(client); printf("play\n"); } else { mpd_run_toggle_pause(client); printf("toggle-pause\n"); } } else if (libevdev_event_is_code(&ev, EV_KEY, KEY_STOPCD)) { mpd_run_stop(client); printf("stop\n"); } else if (libevdev_event_is_code(&ev, EV_KEY, KEY_PREVIOUSSONG)) { mpd_run_previous(client); printf("previous\n"); } else if (libevdev_event_is_code(&ev, EV_KEY, KEY_NEXTSONG)) { mpd_run_next(client); printf("next\n"); } else if (libevdev_event_is_code(&ev, EV_KEY, KEY_VOLUMEUP)) { struct mpd_status *status = mpd_run_status(client); int volume = mpd_status_get_volume(status); volume += 5; if (volume > 100) { volume = 100; } mpd_run_set_volume(client, volume); printf("set-volume %d\n", volume); } else if (libevdev_event_is_code(&ev, EV_KEY, KEY_VOLUMEDOWN)) { struct mpd_status *status = mpd_run_status(client); int volume = mpd_status_get_volume(status); volume -= 5; if (volume < 0) { volume = 0; } mpd_run_set_volume(client, volume); printf("set-volume %d\n", volume); } else { printf("Event: %s %s %d\n", libevdev_event_type_get_name(ev.type), libevdev_event_code_get_name(ev.type, ev.code), ev.value); } } } while (rc == LIBEVDEV_READ_STATUS_SUCCESS || rc == LIBEVDEV_READ_STATUS_SYNC || rc == -EAGAIN); printf("rc: %d\n", rc); if (client != NULL) { mpd_connection_free(client); } return EXIT_SUCCESS; }