libinput.h
Go to the documentation of this file.
1 /*
2 * Copyright © 2013 Jonas Ådahl
3 * Copyright © 2013-2015 Red Hat, Inc.
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice (including the next
13 * paragraph) shall be included in all copies or substantial portions of the
14 * Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
23 */
24
25 #ifndef LIBINPUT_H
26 #define LIBINPUT_H
27
28 #ifdef __cplusplus
29 extern "C" {
30 #endif
31
32 #include <stdlib.h>
33 #include <stdint.h>
34 #include <stdarg.h>
35 #include <libudev.h>
36
37 #define LIBINPUT_ATTRIBUTE_PRINTF(_format, _args) \
38 __attribute__ ((format (printf, _format, _args)))
39 #define LIBINPUT_ATTRIBUTE_DEPRECATED __attribute__ ((deprecated))
40
48 struct libinput;
49
57 struct libinput_device;
58
67 struct libinput_device_group;
68
76 struct libinput_seat;
77
93 struct libinput_tablet_tool;
94
105 struct libinput_event;
106
113 struct libinput_event_device_notify;
114
121 struct libinput_event_keyboard;
122
130 struct libinput_event_pointer;
131
142 struct libinput_event_touch;
143
154 struct libinput_event_tablet_tool;
155
165 struct libinput_event_tablet_pad;
166
172 enum libinput_log_priority {
173 LIBINPUT_LOG_PRIORITY_DEBUG = 10,
174 LIBINPUT_LOG_PRIORITY_INFO = 20,
175 LIBINPUT_LOG_PRIORITY_ERROR = 30,
176 };
177
184 enum libinput_device_capability {
185 LIBINPUT_DEVICE_CAP_KEYBOARD = 0,
186 LIBINPUT_DEVICE_CAP_POINTER = 1,
187 LIBINPUT_DEVICE_CAP_TOUCH = 2,
188 LIBINPUT_DEVICE_CAP_TABLET_TOOL = 3,
189 LIBINPUT_DEVICE_CAP_TABLET_PAD = 4,
190 LIBINPUT_DEVICE_CAP_GESTURE = 5,
191 LIBINPUT_DEVICE_CAP_SWITCH = 6,
192 };
193
200 enum libinput_key_state {
201 LIBINPUT_KEY_STATE_RELEASED = 0,
202 LIBINPUT_KEY_STATE_PRESSED = 1
203 };
204
210 enum libinput_led {
211 LIBINPUT_LED_NUM_LOCK = (1 << 0),
212 LIBINPUT_LED_CAPS_LOCK = (1 << 1),
213 LIBINPUT_LED_SCROLL_LOCK = (1 << 2)
214 };
215
222 enum libinput_button_state {
223 LIBINPUT_BUTTON_STATE_RELEASED = 0,
224 LIBINPUT_BUTTON_STATE_PRESSED = 1
225 };
226
239 enum libinput_pointer_axis {
240 LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL = 0,
241 LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL = 1,
242 };
243
250 enum libinput_pointer_axis_source {
254 LIBINPUT_POINTER_AXIS_SOURCE_WHEEL = 1,
259 LIBINPUT_POINTER_AXIS_SOURCE_FINGER,
263 LIBINPUT_POINTER_AXIS_SOURCE_CONTINUOUS,
269 LIBINPUT_POINTER_AXIS_SOURCE_WHEEL_TILT,
270 };
271
278 enum libinput_tablet_pad_ring_axis_source {
279 LIBINPUT_TABLET_PAD_RING_SOURCE_UNKNOWN = 1,
284 LIBINPUT_TABLET_PAD_RING_SOURCE_FINGER,
285 };
286
293 enum libinput_tablet_pad_strip_axis_source {
294 LIBINPUT_TABLET_PAD_STRIP_SOURCE_UNKNOWN = 1,
299 LIBINPUT_TABLET_PAD_STRIP_SOURCE_FINGER,
300 };
301
322 enum libinput_tablet_tool_type {
323 LIBINPUT_TABLET_TOOL_TYPE_PEN = 1,
324 LIBINPUT_TABLET_TOOL_TYPE_ERASER,
325 LIBINPUT_TABLET_TOOL_TYPE_BRUSH,
326 LIBINPUT_TABLET_TOOL_TYPE_PENCIL,
328 LIBINPUT_TABLET_TOOL_TYPE_AIRBRUSH,
329 LIBINPUT_TABLET_TOOL_TYPE_MOUSE,
330 LIBINPUT_TABLET_TOOL_TYPE_LENS,
331 };
332
347 enum libinput_tablet_tool_proximity_state {
348 LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_OUT = 0,
349 LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_IN = 1,
350 };
351
361 enum libinput_tablet_tool_tip_state {
362 LIBINPUT_TABLET_TOOL_TIP_UP = 0,
363 LIBINPUT_TABLET_TOOL_TIP_DOWN = 1,
364 };
365
391 struct libinput_tablet_pad_mode_group;
392
406 int
407 libinput_device_tablet_pad_get_num_mode_groups(struct libinput_device *device);
408
429 struct libinput_tablet_pad_mode_group*
430 libinput_device_tablet_pad_get_mode_group(struct libinput_device *device,
431 unsigned int index);
432
443 unsigned int
444 libinput_tablet_pad_mode_group_get_index(struct libinput_tablet_pad_mode_group *group);
445
461 unsigned int
462 libinput_tablet_pad_mode_group_get_num_modes(struct libinput_tablet_pad_mode_group *group);
463
481 unsigned int
482 libinput_tablet_pad_mode_group_get_mode(struct libinput_tablet_pad_mode_group *group);
483
494 int
495 libinput_tablet_pad_mode_group_has_button(struct libinput_tablet_pad_mode_group *group,
496 unsigned int button);
497
508 int
509 libinput_tablet_pad_mode_group_has_ring(struct libinput_tablet_pad_mode_group *group,
510 unsigned int ring);
511
522 int
523 libinput_tablet_pad_mode_group_has_strip(struct libinput_tablet_pad_mode_group *group,
524 unsigned int strip);
525
542 int
543 libinput_tablet_pad_mode_group_button_is_toggle(struct libinput_tablet_pad_mode_group *group,
544 unsigned int button);
545
555 struct libinput_tablet_pad_mode_group *
556 libinput_tablet_pad_mode_group_ref(
557 struct libinput_tablet_pad_mode_group *group);
558
568 struct libinput_tablet_pad_mode_group *
569 libinput_tablet_pad_mode_group_unref(
570 struct libinput_tablet_pad_mode_group *group);
571
584 void
585 libinput_tablet_pad_mode_group_set_user_data(
586 struct libinput_tablet_pad_mode_group *group,
587 void *user_data);
588
598 void *
599 libinput_tablet_pad_mode_group_get_user_data(
600 struct libinput_tablet_pad_mode_group *group);
601
611 enum libinput_switch_state {
612 LIBINPUT_SWITCH_STATE_OFF = 0,
613 LIBINPUT_SWITCH_STATE_ON = 1,
614 };
615
621 enum libinput_switch {
627 LIBINPUT_SWITCH_LID = 1,
628
643 LIBINPUT_SWITCH_TABLET_MODE,
644 };
645
652 struct libinput_event_switch;
653
659 enum libinput_event_type {
665 LIBINPUT_EVENT_NONE = 0,
666
675 LIBINPUT_EVENT_DEVICE_ADDED,
676
681 LIBINPUT_EVENT_DEVICE_REMOVED,
682
683 LIBINPUT_EVENT_KEYBOARD_KEY = 300,
684
685 LIBINPUT_EVENT_POINTER_MOTION = 400,
686 LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE,
687 LIBINPUT_EVENT_POINTER_BUTTON,
688 LIBINPUT_EVENT_POINTER_AXIS,
689
690 LIBINPUT_EVENT_TOUCH_DOWN = 500,
691 LIBINPUT_EVENT_TOUCH_UP,
692 LIBINPUT_EVENT_TOUCH_MOTION,
693 LIBINPUT_EVENT_TOUCH_CANCEL,
698 LIBINPUT_EVENT_TOUCH_FRAME,
699
717 LIBINPUT_EVENT_TABLET_TOOL_AXIS = 600,
742 LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY,
765 LIBINPUT_EVENT_TABLET_TOOL_TIP,
781 LIBINPUT_EVENT_TABLET_TOOL_BUTTON,
782
790 LIBINPUT_EVENT_TABLET_PAD_BUTTON = 700,
795 LIBINPUT_EVENT_TABLET_PAD_RING,
796
801 LIBINPUT_EVENT_TABLET_PAD_STRIP,
802
803 LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN = 800,
804 LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE,
805 LIBINPUT_EVENT_GESTURE_SWIPE_END,
806 LIBINPUT_EVENT_GESTURE_PINCH_BEGIN,
807 LIBINPUT_EVENT_GESTURE_PINCH_UPDATE,
808 LIBINPUT_EVENT_GESTURE_PINCH_END,
809
810 LIBINPUT_EVENT_SWITCH_TOGGLE = 900,
811 };
812
829 void
830 libinput_event_destroy(struct libinput_event *event);
831
839 enum libinput_event_type
840 libinput_event_get_type(struct libinput_event *event);
841
850 struct libinput *
851 libinput_event_get_context(struct libinput_event *event);
852
866 struct libinput_device *
867 libinput_event_get_device(struct libinput_event *event);
868
879 struct libinput_event_pointer *
880 libinput_event_get_pointer_event(struct libinput_event *event);
881
892 struct libinput_event_keyboard *
893 libinput_event_get_keyboard_event(struct libinput_event *event);
894
905 struct libinput_event_touch *
906 libinput_event_get_touch_event(struct libinput_event *event);
907
918 struct libinput_event_gesture *
919 libinput_event_get_gesture_event(struct libinput_event *event);
920
931 struct libinput_event_tablet_tool *
932 libinput_event_get_tablet_tool_event(struct libinput_event *event);
933
944 struct libinput_event_tablet_pad *
945 libinput_event_get_tablet_pad_event(struct libinput_event *event);
946
957 struct libinput_event_switch *
958 libinput_event_get_switch_event(struct libinput_event *event);
959
971 struct libinput_event_device_notify *
972 libinput_event_get_device_notify_event(struct libinput_event *event);
973
979 struct libinput_event *
980 libinput_event_device_notify_get_base_event(struct libinput_event_device_notify *event);
981
997 uint32_t
998 libinput_event_keyboard_get_time(struct libinput_event_keyboard *event);
999
1008 uint64_t
1009 libinput_event_keyboard_get_time_usec(struct libinput_event_keyboard *event);
1010
1016 uint32_t
1017 libinput_event_keyboard_get_key(struct libinput_event_keyboard *event);
1018
1024 enum libinput_key_state
1025 libinput_event_keyboard_get_key_state(struct libinput_event_keyboard *event);
1026
1032 struct libinput_event *
1033 libinput_event_keyboard_get_base_event(struct libinput_event_keyboard *event);
1034
1047 uint32_t
1048 libinput_event_keyboard_get_seat_key_count(
1049 struct libinput_event_keyboard *event);
1050
1066 uint32_t
1067 libinput_event_pointer_get_time(struct libinput_event_pointer *event);
1068
1077 uint64_t
1078 libinput_event_pointer_get_time_usec(struct libinput_event_pointer *event);
1079
1098 double
1099 libinput_event_pointer_get_dx(struct libinput_event_pointer *event);
1100
1119 double
1120 libinput_event_pointer_get_dy(struct libinput_event_pointer *event);
1121
1143 double
1144 libinput_event_pointer_get_dx_unaccelerated(
1145 struct libinput_event_pointer *event);
1146
1168 double
1169 libinput_event_pointer_get_dy_unaccelerated(
1170 struct libinput_event_pointer *event);
1171
1187 double
1188 libinput_event_pointer_get_absolute_x(struct libinput_event_pointer *event);
1189
1205 double
1206 libinput_event_pointer_get_absolute_y(struct libinput_event_pointer *event);
1207
1225 double
1226 libinput_event_pointer_get_absolute_x_transformed(
1227 struct libinput_event_pointer *event,
1228 uint32_t width);
1229
1247 double
1248 libinput_event_pointer_get_absolute_y_transformed(
1249 struct libinput_event_pointer *event,
1250 uint32_t height);
1251
1264 uint32_t
1265 libinput_event_pointer_get_button(struct libinput_event_pointer *event);
1266
1279 enum libinput_button_state
1280 libinput_event_pointer_get_button_state(struct libinput_event_pointer *event);
1281
1295 uint32_t
1296 libinput_event_pointer_get_seat_button_count(
1297 struct libinput_event_pointer *event);
1298
1316 int
1317 libinput_event_pointer_has_axis(struct libinput_event_pointer *event,
1318 enum libinput_pointer_axis axis);
1319
1344 double
1345 libinput_event_pointer_get_axis_value(struct libinput_event_pointer *event,
1346 enum libinput_pointer_axis axis);
1347
1392 enum libinput_pointer_axis_source
1393 libinput_event_pointer_get_axis_source(struct libinput_event_pointer *event);
1394
1411 double
1412 libinput_event_pointer_get_axis_value_discrete(struct libinput_event_pointer *event,
1413 enum libinput_pointer_axis axis);
1414
1420 struct libinput_event *
1421 libinput_event_pointer_get_base_event(struct libinput_event_pointer *event);
1422
1437 uint32_t
1438 libinput_event_touch_get_time(struct libinput_event_touch *event);
1439
1448 uint64_t
1449 libinput_event_touch_get_time_usec(struct libinput_event_touch *event);
1450
1470 int32_t
1471 libinput_event_touch_get_slot(struct libinput_event_touch *event);
1472
1492 int32_t
1493 libinput_event_touch_get_seat_slot(struct libinput_event_touch *event);
1494
1512 double
1513 libinput_event_touch_get_x(struct libinput_event_touch *event);
1514
1532 double
1533 libinput_event_touch_get_y(struct libinput_event_touch *event);
1534
1552 double
1553 libinput_event_touch_get_x_transformed(struct libinput_event_touch *event,
1554 uint32_t width);
1555
1573 double
1574 libinput_event_touch_get_y_transformed(struct libinput_event_touch *event,
1575 uint32_t height);
1576
1582 struct libinput_event *
1583 libinput_event_touch_get_base_event(struct libinput_event_touch *event);
1584
1607 uint32_t
1608 libinput_event_gesture_get_time(struct libinput_event_gesture *event);
1609
1618 uint64_t
1619 libinput_event_gesture_get_time_usec(struct libinput_event_gesture *event);
1620
1626 struct libinput_event *
1627 libinput_event_gesture_get_base_event(struct libinput_event_gesture *event);
1628
1640 int
1641 libinput_event_gesture_get_finger_count(struct libinput_event_gesture *event);
1642
1657 int
1658 libinput_event_gesture_get_cancelled(struct libinput_event_gesture *event);
1659
1675 double
1676 libinput_event_gesture_get_dx(struct libinput_event_gesture *event);
1677
1693 double
1694 libinput_event_gesture_get_dy(struct libinput_event_gesture *event);
1695
1714 double
1715 libinput_event_gesture_get_dx_unaccelerated(
1716 struct libinput_event_gesture *event);
1717
1736 double
1737 libinput_event_gesture_get_dy_unaccelerated(
1738 struct libinput_event_gesture *event);
1739
1766 double
1767 libinput_event_gesture_get_scale(struct libinput_event_gesture *event);
1768
1790 double
1791 libinput_event_gesture_get_angle_delta(struct libinput_event_gesture *event);
1792
1815 struct libinput_event *
1816 libinput_event_tablet_tool_get_base_event(struct libinput_event_tablet_tool *event);
1817
1835 int
1836 libinput_event_tablet_tool_x_has_changed(
1837 struct libinput_event_tablet_tool *event);
1838
1856 int
1857 libinput_event_tablet_tool_y_has_changed(
1858 struct libinput_event_tablet_tool *event);
1859
1877 int
1878 libinput_event_tablet_tool_pressure_has_changed(
1879 struct libinput_event_tablet_tool *event);
1880
1900 int
1901 libinput_event_tablet_tool_distance_has_changed(
1902 struct libinput_event_tablet_tool *event);
1903
1921 int
1922 libinput_event_tablet_tool_tilt_x_has_changed(
1923 struct libinput_event_tablet_tool *event);
1924
1942 int
1943 libinput_event_tablet_tool_tilt_y_has_changed(
1944 struct libinput_event_tablet_tool *event);
1962 int
1963 libinput_event_tablet_tool_rotation_has_changed(
1964 struct libinput_event_tablet_tool *event);
1982 int
1983 libinput_event_tablet_tool_slider_has_changed(
1984 struct libinput_event_tablet_tool *event);
2002 int
2003 libinput_event_tablet_tool_wheel_has_changed(
2004 struct libinput_event_tablet_tool *event);
2005
2020 double
2021 libinput_event_tablet_tool_get_x(struct libinput_event_tablet_tool *event);
2022
2037 double
2038 libinput_event_tablet_tool_get_y(struct libinput_event_tablet_tool *event);
2039
2054 double
2055 libinput_event_tablet_tool_get_dx(struct libinput_event_tablet_tool *event);
2056
2071 double
2072 libinput_event_tablet_tool_get_dy(struct libinput_event_tablet_tool *event);
2073
2085 double
2086 libinput_event_tablet_tool_get_pressure(struct libinput_event_tablet_tool *event);
2087
2099 double
2100 libinput_event_tablet_tool_get_distance(struct libinput_event_tablet_tool *event);
2101
2117 double
2118 libinput_event_tablet_tool_get_tilt_x(struct libinput_event_tablet_tool *event);
2119
2135 double
2136 libinput_event_tablet_tool_get_tilt_y(struct libinput_event_tablet_tool *event);
2137
2155 double
2156 libinput_event_tablet_tool_get_rotation(struct libinput_event_tablet_tool *event);
2157
2171 double
2172 libinput_event_tablet_tool_get_slider_position(struct libinput_event_tablet_tool *event);
2173
2184 double
2185 libinput_event_tablet_tool_get_wheel_delta(
2186 struct libinput_event_tablet_tool *event);
2187
2198 int
2199 libinput_event_tablet_tool_get_wheel_delta_discrete(
2200 struct libinput_event_tablet_tool *event);
2201
2219 double
2220 libinput_event_tablet_tool_get_x_transformed(struct libinput_event_tablet_tool *event,
2221 uint32_t width);
2222
2240 double
2241 libinput_event_tablet_tool_get_y_transformed(struct libinput_event_tablet_tool *event,
2242 uint32_t height);
2243
2264 struct libinput_tablet_tool *
2265 libinput_event_tablet_tool_get_tool(struct libinput_event_tablet_tool *event);
2266
2279 enum libinput_tablet_tool_proximity_state
2280 libinput_event_tablet_tool_get_proximity_state(struct libinput_event_tablet_tool *event);
2281
2293 enum libinput_tablet_tool_tip_state
2294 libinput_event_tablet_tool_get_tip_state(struct libinput_event_tablet_tool *event);
2295
2308 uint32_t
2309 libinput_event_tablet_tool_get_button(struct libinput_event_tablet_tool *event);
2310
2322 enum libinput_button_state
2323 libinput_event_tablet_tool_get_button_state(struct libinput_event_tablet_tool *event);
2324
2338 uint32_t
2339 libinput_event_tablet_tool_get_seat_button_count(struct libinput_event_tablet_tool *event);
2340
2350 uint32_t
2351 libinput_event_tablet_tool_get_time(struct libinput_event_tablet_tool *event);
2352
2362 uint64_t
2363 libinput_event_tablet_tool_get_time_usec(struct libinput_event_tablet_tool *event);
2364
2376 enum libinput_tablet_tool_type
2377 libinput_tablet_tool_get_type(struct libinput_tablet_tool *tool);
2378
2395 uint64_t
2396 libinput_tablet_tool_get_tool_id(struct libinput_tablet_tool *tool);
2397
2409 struct libinput_tablet_tool *
2410 libinput_tablet_tool_ref(struct libinput_tablet_tool *tool);
2411
2424 struct libinput_tablet_tool *
2425 libinput_tablet_tool_unref(struct libinput_tablet_tool *tool);
2426
2435 int
2436 libinput_tablet_tool_has_pressure(struct libinput_tablet_tool *tool);
2437
2446 int
2447 libinput_tablet_tool_has_distance(struct libinput_tablet_tool *tool);
2448
2457 int
2458 libinput_tablet_tool_has_tilt(struct libinput_tablet_tool *tool);
2459
2468 int
2469 libinput_tablet_tool_has_rotation(struct libinput_tablet_tool *tool);
2470
2479 int
2480 libinput_tablet_tool_has_slider(struct libinput_tablet_tool *tool);
2481
2490 int
2491 libinput_tablet_tool_has_wheel(struct libinput_tablet_tool *tool);
2492
2504 int
2505 libinput_tablet_tool_has_button(struct libinput_tablet_tool *tool,
2506 uint32_t code);
2507
2522 int
2523 libinput_tablet_tool_is_unique(struct libinput_tablet_tool *tool);
2524
2537 uint64_t
2538 libinput_tablet_tool_get_serial(struct libinput_tablet_tool *tool);
2539
2550 void *
2551 libinput_tablet_tool_get_user_data(struct libinput_tablet_tool *tool);
2552
2561 void
2562 libinput_tablet_tool_set_user_data(struct libinput_tablet_tool *tool,
2563 void *user_data);
2564
2577 struct libinput_event *
2578 libinput_event_tablet_pad_get_base_event(struct libinput_event_tablet_pad *event);
2579
2600 double
2601 libinput_event_tablet_pad_get_ring_position(struct libinput_event_tablet_pad *event);
2602
2617 unsigned int
2618 libinput_event_tablet_pad_get_ring_number(struct libinput_event_tablet_pad *event);
2619
2634 enum libinput_tablet_pad_ring_axis_source
2635 libinput_event_tablet_pad_get_ring_source(struct libinput_event_tablet_pad *event);
2636
2657 double
2658 libinput_event_tablet_pad_get_strip_position(struct libinput_event_tablet_pad *event);
2659
2674 unsigned int
2675 libinput_event_tablet_pad_get_strip_number(struct libinput_event_tablet_pad *event);
2676
2691 enum libinput_tablet_pad_strip_axis_source
2692 libinput_event_tablet_pad_get_strip_source(struct libinput_event_tablet_pad *event);
2693
2712 uint32_t
2713 libinput_event_tablet_pad_get_button_number(struct libinput_event_tablet_pad *event);
2714
2727 enum libinput_button_state
2728 libinput_event_tablet_pad_get_button_state(struct libinput_event_tablet_pad *event);
2729
2758 unsigned int
2759 libinput_event_tablet_pad_get_mode(struct libinput_event_tablet_pad *event);
2760
2779 struct libinput_tablet_pad_mode_group *
2780 libinput_event_tablet_pad_get_mode_group(struct libinput_event_tablet_pad *event);
2781
2791 uint32_t
2792 libinput_event_tablet_pad_get_time(struct libinput_event_tablet_pad *event);
2793
2803 uint64_t
2804 libinput_event_tablet_pad_get_time_usec(struct libinput_event_tablet_pad *event);
2805
2825 enum libinput_switch
2826 libinput_event_switch_get_switch(struct libinput_event_switch *event);
2827
2841 enum libinput_switch_state
2842 libinput_event_switch_get_switch_state(struct libinput_event_switch *event);
2843
2849 struct libinput_event *
2850 libinput_event_switch_get_base_event(struct libinput_event_switch *event);
2851
2861 uint32_t
2862 libinput_event_switch_get_time(struct libinput_event_switch *event);
2863
2873 uint64_t
2874 libinput_event_switch_get_time_usec(struct libinput_event_switch *event);
2875
2891 struct libinput_interface {
2903 int (*open_restricted)(const char *path, int flags, void *user_data);
2911 void (*close_restricted)(int fd, void *user_data);
2912 };
2913
2927 struct libinput *
2928 libinput_udev_create_context(const struct libinput_interface *interface,
2929 void *user_data,
2930 struct udev *udev);
2931
2953 int
2954 libinput_udev_assign_seat(struct libinput *libinput,
2955 const char *seat_id);
2956
2976 struct libinput *
2977 libinput_path_create_context(const struct libinput_interface *interface,
2978 void *user_data);
2979
3000 struct libinput_device *
3001 libinput_path_add_device(struct libinput *libinput,
3002 const char *path);
3003
3022 void
3023 libinput_path_remove_device(struct libinput_device *device);
3024
3033 int
3034 libinput_get_fd(struct libinput *libinput);
3035
3053 int
3054 libinput_dispatch(struct libinput *libinput);
3055
3067 struct libinput_event *
3068 libinput_get_event(struct libinput *libinput);
3069
3081 enum libinput_event_type
3082 libinput_next_event_type(struct libinput *libinput);
3083
3095 void
3096 libinput_set_user_data(struct libinput *libinput,
3097 void *user_data);
3098
3108 void *
3109 libinput_get_user_data(struct libinput *libinput);
3110
3122 int
3123 libinput_resume(struct libinput *libinput);
3124
3134 void
3135 libinput_suspend(struct libinput *libinput);
3136
3146 struct libinput *
3147 libinput_ref(struct libinput *libinput);
3148
3180 struct libinput *
3181 libinput_unref(struct libinput *libinput);
3182
3198 void
3199 libinput_log_set_priority(struct libinput *libinput,
3200 enum libinput_log_priority priority);
3201
3216 enum libinput_log_priority
3217 libinput_log_get_priority(const struct libinput *libinput);
3218
3233 typedef void (*libinput_log_handler)(struct libinput *libinput,
3234 enum libinput_log_priority priority,
3235 const char *format, va_list args)
3236 LIBINPUT_ATTRIBUTE_PRINTF(3, 0);
3237
3253 void
3254 libinput_log_set_handler(struct libinput *libinput,
3255 libinput_log_handler log_handler);
3256
3277 struct libinput_seat *
3278 libinput_seat_ref(struct libinput_seat *seat);
3279
3291 struct libinput_seat *
3292 libinput_seat_unref(struct libinput_seat *seat);
3293
3305 void
3306 libinput_seat_set_user_data(struct libinput_seat *seat, void *user_data);
3307
3317 void *
3318 libinput_seat_get_user_data(struct libinput_seat *seat);
3319
3328 struct libinput *
3329 libinput_seat_get_context(struct libinput_seat *seat);
3330
3347 const char *
3348 libinput_seat_get_physical_name(struct libinput_seat *seat);
3349
3359 const char *
3360 libinput_seat_get_logical_name(struct libinput_seat *seat);
3361
3377 struct libinput_device *
3378 libinput_device_ref(struct libinput_device *device);
3379
3391 struct libinput_device *
3392 libinput_device_unref(struct libinput_device *device);
3393
3405 void
3406 libinput_device_set_user_data(struct libinput_device *device, void *user_data);
3407
3417 void *
3418 libinput_device_get_user_data(struct libinput_device *device);
3419
3428 struct libinput *
3429 libinput_device_get_context(struct libinput_device *device);
3430
3491 struct libinput_device_group *
3492 libinput_device_get_device_group(struct libinput_device *device);
3493
3505 const char *
3506 libinput_device_get_sysname(struct libinput_device *device);
3507
3521 const char *
3522 libinput_device_get_name(struct libinput_device *device);
3523
3532 unsigned int
3533 libinput_device_get_id_product(struct libinput_device *device);
3534
3543 unsigned int
3544 libinput_device_get_id_vendor(struct libinput_device *device);
3545
3565 const char *
3566 libinput_device_get_output_name(struct libinput_device *device);
3567
3587 struct libinput_seat *
3588 libinput_device_get_seat(struct libinput_device *device);
3589
3615 int
3616 libinput_device_set_seat_logical_name(struct libinput_device *device,
3617 const char *name);
3618
3638 struct udev_device *
3639 libinput_device_get_udev_device(struct libinput_device *device);
3640
3651 void
3652 libinput_device_led_update(struct libinput_device *device,
3653 enum libinput_led leds);
3654
3662 int
3663 libinput_device_has_capability(struct libinput_device *device,
3664 enum libinput_device_capability capability);
3665
3680 int
3681 libinput_device_get_size(struct libinput_device *device,
3682 double *width,
3683 double *height);
3684
3697 int
3698 libinput_device_pointer_has_button(struct libinput_device *device, uint32_t code);
3699
3712 int
3713 libinput_device_keyboard_has_key(struct libinput_device *device,
3714 uint32_t code);
3715
3727 int
3728 libinput_device_touch_get_touch_count(struct libinput_device *device);
3729
3742 int
3743 libinput_device_switch_has_switch(struct libinput_device *device,
3744 enum libinput_switch sw);
3745
3758 int
3759 libinput_device_tablet_pad_get_num_buttons(struct libinput_device *device);
3760
3773 int
3774 libinput_device_tablet_pad_get_num_rings(struct libinput_device *device);
3775
3788 int
3789 libinput_device_tablet_pad_get_num_strips(struct libinput_device *device);
3790
3803 struct libinput_device_group *
3804 libinput_device_group_ref(struct libinput_device_group *group);
3805
3819 struct libinput_device_group *
3820 libinput_device_group_unref(struct libinput_device_group *group);
3821
3833 void
3834 libinput_device_group_set_user_data(struct libinput_device_group *group,
3835 void *user_data);
3836
3847 void *
3848 libinput_device_group_get_user_data(struct libinput_device_group *group);
3849
3896 enum libinput_config_status {
3897 LIBINPUT_CONFIG_STATUS_SUCCESS = 0,
3898 LIBINPUT_CONFIG_STATUS_UNSUPPORTED,
3900 LIBINPUT_CONFIG_STATUS_INVALID,
3901 };
3902
3912 const char *
3913 libinput_config_status_to_str(enum libinput_config_status status);
3914
3918 enum libinput_config_tap_state {
3919 LIBINPUT_CONFIG_TAP_DISABLED,
3921 LIBINPUT_CONFIG_TAP_ENABLED,
3923 };
3924
3940 int
3941 libinput_device_config_tap_get_finger_count(struct libinput_device *device);
3942
3963 enum libinput_config_status
3964 libinput_device_config_tap_set_enabled(struct libinput_device *device,
3965 enum libinput_config_tap_state enable);
3966
3983 enum libinput_config_tap_state
3984 libinput_device_config_tap_get_enabled(struct libinput_device *device);
3985
4000 enum libinput_config_tap_state
4001 libinput_device_config_tap_get_default_enabled(struct libinput_device *device);
4002
4006 enum libinput_config_tap_button_map {
4008 LIBINPUT_CONFIG_TAP_MAP_LRM,
4010 LIBINPUT_CONFIG_TAP_MAP_LMR,
4011 };
4012
4041 enum libinput_config_status
4042 libinput_device_config_tap_set_button_map(struct libinput_device *device,
4043 enum libinput_config_tap_button_map map);
4044
4062 enum libinput_config_tap_button_map
4063 libinput_device_config_tap_get_button_map(struct libinput_device *device);
4064
4082 enum libinput_config_tap_button_map
4083 libinput_device_config_tap_get_default_button_map(struct libinput_device *device);
4084
4092 enum libinput_config_drag_state {
4097 LIBINPUT_CONFIG_DRAG_DISABLED,
4102 LIBINPUT_CONFIG_DRAG_ENABLED,
4103 };
4104
4120 enum libinput_config_status
4121 libinput_device_config_tap_set_drag_enabled(struct libinput_device *device,
4122 enum libinput_config_drag_state enable);
4123
4137 enum libinput_config_drag_state
4138 libinput_device_config_tap_get_drag_enabled(struct libinput_device *device);
4139
4155 enum libinput_config_drag_state
4156 libinput_device_config_tap_get_default_drag_enabled(struct libinput_device *device);
4157
4161 enum libinput_config_drag_lock_state {
4163 LIBINPUT_CONFIG_DRAG_LOCK_DISABLED,
4165 LIBINPUT_CONFIG_DRAG_LOCK_ENABLED,
4166 };
4167
4190 enum libinput_config_status
4191 libinput_device_config_tap_set_drag_lock_enabled(struct libinput_device *device,
4192 enum libinput_config_drag_lock_state enable);
4193
4211 enum libinput_config_drag_lock_state
4212 libinput_device_config_tap_get_drag_lock_enabled(struct libinput_device *device);
4213
4234 enum libinput_config_drag_lock_state
4235 libinput_device_config_tap_get_default_drag_lock_enabled(struct libinput_device *device);
4236
4249 int
4250 libinput_device_config_calibration_has_matrix(struct libinput_device *device);
4251
4301 enum libinput_config_status
4302 libinput_device_config_calibration_set_matrix(struct libinput_device *device,
4303 const float matrix[6]);
4304
4321 int
4322 libinput_device_config_calibration_get_matrix(struct libinput_device *device,
4323 float matrix[6]);
4324
4344 int
4345 libinput_device_config_calibration_get_default_matrix(struct libinput_device *device,
4346 float matrix[6]);
4347
4354 enum libinput_config_send_events_mode {
4360 LIBINPUT_CONFIG_SEND_EVENTS_ENABLED = 0,
4374 LIBINPUT_CONFIG_SEND_EVENTS_DISABLED = (1 << 0),
4380 LIBINPUT_CONFIG_SEND_EVENTS_DISABLED_ON_EXTERNAL_MOUSE = (1 << 1),
4381 };
4382
4397 uint32_t
4398 libinput_device_config_send_events_get_modes(struct libinput_device *device);
4399
4428 enum libinput_config_status
4429 libinput_device_config_send_events_set_mode(struct libinput_device *device,
4430 uint32_t mode);
4431
4451 uint32_t
4452 libinput_device_config_send_events_get_mode(struct libinput_device *device);
4453
4467 uint32_t
4468 libinput_device_config_send_events_get_default_mode(struct libinput_device *device);
4469
4483 int
4484 libinput_device_config_accel_is_available(struct libinput_device *device);
4485
4506 enum libinput_config_status
4507 libinput_device_config_accel_set_speed(struct libinput_device *device,
4508 double speed);
4509
4525 double
4526 libinput_device_config_accel_get_speed(struct libinput_device *device);
4527
4542 double
4543 libinput_device_config_accel_get_default_speed(struct libinput_device *device);
4544
4548 enum libinput_config_accel_profile {
4553 LIBINPUT_CONFIG_ACCEL_PROFILE_NONE = 0,
4561 LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT = (1 << 0),
4562
4567 LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE = (1 << 1),
4568 };
4569
4580 uint32_t
4581 libinput_device_config_accel_get_profiles(struct libinput_device *device);
4582
4594 enum libinput_config_status
4595 libinput_device_config_accel_set_profile(struct libinput_device *device,
4596 enum libinput_config_accel_profile mode);
4597
4607 enum libinput_config_accel_profile
4608 libinput_device_config_accel_get_profile(struct libinput_device *device);
4609
4619 enum libinput_config_accel_profile
4620 libinput_device_config_accel_get_default_profile(struct libinput_device *device);
4621
4651 int
4652 libinput_device_config_scroll_has_natural_scroll(struct libinput_device *device);
4653
4668 enum libinput_config_status
4669 libinput_device_config_scroll_set_natural_scroll_enabled(struct libinput_device *device,
4670 int enable);
4684 int
4685 libinput_device_config_scroll_get_natural_scroll_enabled(struct libinput_device *device);
4686
4700 int
4701 libinput_device_config_scroll_get_default_natural_scroll_enabled(struct libinput_device *device);
4702
4716 int
4717 libinput_device_config_left_handed_is_available(struct libinput_device *device);
4718
4742 enum libinput_config_status
4743 libinput_device_config_left_handed_set(struct libinput_device *device,
4744 int left_handed);
4745
4759 int
4760 libinput_device_config_left_handed_get(struct libinput_device *device);
4761
4775 int
4776 libinput_device_config_left_handed_get_default(struct libinput_device *device);
4777
4785 enum libinput_config_click_method {
4790 LIBINPUT_CONFIG_CLICK_METHOD_NONE = 0,
4795 LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS = (1 << 0),
4799 LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER = (1 << 1),
4800 };
4801
4817 uint32_t
4818 libinput_device_config_click_get_methods(struct libinput_device *device);
4819
4840 enum libinput_config_status
4841 libinput_device_config_click_set_method(struct libinput_device *device,
4842 enum libinput_config_click_method method);
4858 enum libinput_config_click_method
4859 libinput_device_config_click_get_method(struct libinput_device *device);
4860
4876 enum libinput_config_click_method
4877 libinput_device_config_click_get_default_method(struct libinput_device *device);
4878
4882 enum libinput_config_middle_emulation_state {
4887 LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED,
4892 LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED,
4893 };
4894
4914 int
4915 libinput_device_config_middle_emulation_is_available(
4916 struct libinput_device *device);
4917
4940 enum libinput_config_status
4941 libinput_device_config_middle_emulation_set_enabled(
4942 struct libinput_device *device,
4943 enum libinput_config_middle_emulation_state enable);
4944
4967 enum libinput_config_middle_emulation_state
4968 libinput_device_config_middle_emulation_get_enabled(
4969 struct libinput_device *device);
4970
4994 enum libinput_config_middle_emulation_state
4995 libinput_device_config_middle_emulation_get_default_enabled(
4996 struct libinput_device *device);
4997
5004 enum libinput_config_scroll_method {
5009 LIBINPUT_CONFIG_SCROLL_NO_SCROLL = 0,
5014 LIBINPUT_CONFIG_SCROLL_2FG = (1 << 0),
5019 LIBINPUT_CONFIG_SCROLL_EDGE = (1 << 1),
5024 LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN = (1 << 2),
5025 };
5026
5044 uint32_t
5045 libinput_device_config_scroll_get_methods(struct libinput_device *device);
5046
5071 enum libinput_config_status
5072 libinput_device_config_scroll_set_method(struct libinput_device *device,
5073 enum libinput_config_scroll_method method);
5074
5091 enum libinput_config_scroll_method
5092 libinput_device_config_scroll_get_method(struct libinput_device *device);
5093
5110 enum libinput_config_scroll_method
5111 libinput_device_config_scroll_get_default_method(struct libinput_device *device);
5112
5148 enum libinput_config_status
5149 libinput_device_config_scroll_set_button(struct libinput_device *device,
5150 uint32_t button);
5151
5176 uint32_t
5177 libinput_device_config_scroll_get_button(struct libinput_device *device);
5178
5199 uint32_t
5200 libinput_device_config_scroll_get_default_button(struct libinput_device *device);
5201
5208 enum libinput_config_dwt_state {
5209 LIBINPUT_CONFIG_DWT_DISABLED,
5210 LIBINPUT_CONFIG_DWT_ENABLED,
5211 };
5212
5228 int
5229 libinput_device_config_dwt_is_available(struct libinput_device *device);
5230
5252 enum libinput_config_status
5253 libinput_device_config_dwt_set_enabled(struct libinput_device *device,
5254 enum libinput_config_dwt_state enable);
5255
5271 enum libinput_config_dwt_state
5272 libinput_device_config_dwt_get_enabled(struct libinput_device *device);
5273
5289 enum libinput_config_dwt_state
5290 libinput_device_config_dwt_get_default_enabled(struct libinput_device *device);
5291
5304 int
5305 libinput_device_config_rotation_is_available(struct libinput_device *device);
5306
5337 enum libinput_config_status
5338 libinput_device_config_rotation_set_angle(struct libinput_device *device,
5339 unsigned int degrees_cw);
5340
5355 unsigned int
5356 libinput_device_config_rotation_get_angle(struct libinput_device *device);
5357
5372 unsigned int
5373 libinput_device_config_rotation_get_default_angle(struct libinput_device *device);
5374
5375 #ifdef __cplusplus
5376 }
5377 #endif
5378 #endif /* LIBINPUT_H */
LIBINPUT_EVENT_GESTURE_PINCH_BEGIN
Definition: libinput.h:806
libinput_config_dwt_state
libinput_config_dwt_state
Possible states for the disable-while-typing feature.
Definition: libinput.h:5208
libinput_seat_get_physical_name
const char * libinput_seat_get_physical_name(struct libinput_seat *seat)
Return the physical name of the seat.
libinput_event_tablet_pad_get_base_event
struct libinput_event * libinput_event_tablet_pad_get_base_event(struct libinput_event_tablet_pad *event)
LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED
Middle mouse button emulation is to be disabled, or is currently disabled.
Definition: libinput.h:4887
libinput_event_tablet_pad_get_ring_source
enum libinput_tablet_pad_ring_axis_source libinput_event_tablet_pad_get_ring_source(struct libinput_event_tablet_pad *event)
Returns the source of the interaction with the ring.
libinput_device
A base handle for accessing libinput devices.
Definition: libinput.h:48
LIBINPUT_CONFIG_SCROLL_NO_SCROLL
Never send scroll events instead of pointer motion events.
Definition: libinput.h:5009
LIBINPUT_SWITCH_STATE_OFF
Definition: libinput.h:612
libinput_event_get_tablet_pad_event
struct libinput_event_tablet_pad * libinput_event_get_tablet_pad_event(struct libinput_event *event)
Return the tablet pad event that is this input event.
libinput_device_config_accel_get_profiles
uint32_t libinput_device_config_accel_get_profiles(struct libinput_device *device)
Returns a bitmask of the configurable acceleration modes available on this device.
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY
Signals that a tool has come in or out of proximity of a device with the LIBINPUT_DEVICE_CAP_TABLET_T...
Definition: libinput.h:742
libinput_event_switch_get_time_usec
uint64_t libinput_event_switch_get_time_usec(struct libinput_event_switch *event)
libinput_event_tablet_tool_pressure_has_changed
int libinput_event_tablet_tool_pressure_has_changed(struct libinput_event_tablet_tool *event)
Check if the pressure axis was updated in this event.
libinput_event_tablet_tool_get_time
uint32_t libinput_event_tablet_tool_get_time(struct libinput_event_tablet_tool *event)
LIBINPUT_TABLET_TOOL_TYPE_AIRBRUSH
An airbrush-like tool.
Definition: libinput.h:328
libinput_device_get_id_product
unsigned int libinput_device_get_id_product(struct libinput_device *device)
Get the product ID for this device.
LIBINPUT_DEVICE_CAP_TOUCH
Definition: libinput.h:187
libinput_config_accel_profile
libinput_config_accel_profile
Definition: libinput.h:4548
libinput_event_switch_get_time
uint32_t libinput_event_switch_get_time(struct libinput_event_switch *event)
libinput_event_tablet_tool_get_rotation
double libinput_event_tablet_tool_get_rotation(struct libinput_event_tablet_tool *event)
Returns the current z rotation of the tool in degrees, clockwise from the tool&#39;s logical neutral posi...
libinput_event_pointer_get_button
uint32_t libinput_event_pointer_get_button(struct libinput_event_pointer *event)
Return the button that triggered this event.
libinput_event_tablet_pad_get_strip_position
double libinput_event_tablet_pad_get_strip_position(struct libinput_event_tablet_pad *event)
Returns the current position of the strip, normalized to the range [0, 1], with 0 being the top/left-...
LIBINPUT_EVENT_TOUCH_MOTION
Definition: libinput.h:692
libinput_device_config_rotation_set_angle
enum libinput_config_status libinput_device_config_rotation_set_angle(struct libinput_device *device, unsigned int degrees_cw)
Set the rotation of a device in degrees clockwise off the logical neutral position.
libinput_dispatch
int libinput_dispatch(struct libinput *libinput)
Main event dispatchment function.
libinput_ref
struct libinput * libinput_ref(struct libinput *libinput)
Add a reference to the context.
libinput_tablet_pad_mode_group_unref
struct libinput_tablet_pad_mode_group * libinput_tablet_pad_mode_group_unref(struct libinput_tablet_pad_mode_group *group)
Decrease the refcount of the mode group.
libinput_event_gesture_get_angle_delta
double libinput_event_gesture_get_angle_delta(struct libinput_event_gesture *event)
Return the angle delta in degrees between the last and the current LIBINPUT_EVENT_GESTURE_PINCH_UPDAT...
libinput_event_tablet_tool_get_pressure
double libinput_event_tablet_tool_get_pressure(struct libinput_event_tablet_tool *event)
Returns the current pressure being applied on the tool in use, normalized to the range [0...
libinput_interface
libinput does not open file descriptors to devices directly, instead open_restricted() and close_rest...
Definition: libinput.h:2891
libinput_device_config_accel_set_profile
enum libinput_config_status libinput_device_config_accel_set_profile(struct libinput_device *device, enum libinput_config_accel_profile mode)
Set the pointer acceleration profile of this pointer device to the given mode.
LIBINPUT_DEVICE_CAP_TABLET_PAD
Definition: libinput.h:189
LIBINPUT_LOG_PRIORITY_DEBUG
Definition: libinput.h:173
LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER
The number of fingers decides which button press to generate.
Definition: libinput.h:4799
LIBINPUT_EVENT_POINTER_AXIS
Definition: libinput.h:688
LIBINPUT_CONFIG_DRAG_ENABLED
Drag is to be enabled, or is currently enabled.
Definition: libinput.h:4102
LIBINPUT_BUTTON_STATE_PRESSED
Definition: libinput.h:224
libinput_switch_state
libinput_switch_state
The state of a switch.
Definition: libinput.h:611
libinput_event_tablet_tool_get_distance
double libinput_event_tablet_tool_get_distance(struct libinput_event_tablet_tool *event)
Returns the current distance from the tablet&#39;s sensor, normalized to the range [0, 1].
libinput_device_config_rotation_is_available
int libinput_device_config_rotation_is_available(struct libinput_device *device)
Check whether a device can have a custom rotation applied.
libinput_led
libinput_led
Mask reflecting LEDs on a device.
Definition: libinput.h:210
libinput_pointer_axis_source
libinput_pointer_axis_source
The source for a libinput_pointer_axis event.
Definition: libinput.h:250
libinput_event_touch
Touch event representing a touch down, move or up, as well as a touch cancel and touch frame events...
Definition: libinput.h:130
libinput_event_gesture_get_base_event
struct libinput_event * libinput_event_gesture_get_base_event(struct libinput_event_gesture *event)
libinput_device_config_rotation_get_default_angle
unsigned int libinput_device_config_rotation_get_default_angle(struct libinput_device *device)
Get the default rotation of a device in degrees clockwise off the logical neutral position...
LIBINPUT_EVENT_TOUCH_DOWN
Definition: libinput.h:690
libinput_event_tablet_pad_get_ring_position
double libinput_event_tablet_pad_get_ring_position(struct libinput_event_tablet_pad *event)
Returns the current position of the ring, in degrees counterclockwise from the northern-most point of...
libinput_event_tablet_tool_get_y
double libinput_event_tablet_tool_get_y(struct libinput_event_tablet_tool *event)
Returns the Y coordinate of the tablet tool, in mm from the top left corner of the tablet in its curr...
libinput_event_touch_get_slot
int32_t libinput_event_touch_get_slot(struct libinput_event_touch *event)
Get the slot of this touch event.
libinput_device_config_tap_set_button_map
enum libinput_config_status libinput_device_config_tap_set_button_map(struct libinput_device *device, enum libinput_config_tap_button_map map)
Set the finger number to button number mapping for tap-to-click.
libinput_device_get_user_data
void * libinput_device_get_user_data(struct libinput_device *device)
Get the caller-specific data associated with this input device, if any.
libinput_seat_ref
struct libinput_seat * libinput_seat_ref(struct libinput_seat *seat)
Increase the refcount of the seat.
LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL
Definition: libinput.h:241
libinput_tablet_tool_type
libinput_tablet_tool_type
Available tool types for a device with the LIBINPUT_DEVICE_CAP_TABLET_TOOL capability.
Definition: libinput.h:322
LIBINPUT_EVENT_TOUCH_FRAME
Signals the end of a set of touchpoints at one device sample time.
Definition: libinput.h:698
libinput_event_tablet_tool_get_tip_state
enum libinput_tablet_tool_tip_state libinput_event_tablet_tool_get_tip_state(struct libinput_event_tablet_tool *event)
Returns the new tip state of a tool from a tip event.
libinput_event_tablet_tool_get_wheel_delta_discrete
int libinput_event_tablet_tool_get_wheel_delta_discrete(struct libinput_event_tablet_tool *event)
Return the delta for the wheel in discrete steps (e.g.
libinput_event_keyboard_get_time_usec
uint64_t libinput_event_keyboard_get_time_usec(struct libinput_event_keyboard *event)
LIBINPUT_CONFIG_STATUS_SUCCESS
Config applied successfully.
Definition: libinput.h:3897
libinput_tablet_tool_has_pressure
int libinput_tablet_tool_has_pressure(struct libinput_tablet_tool *tool)
Return whether the tablet tool supports pressure.
libinput_event_switch
A switch event representing a changed state in a switch.
libinput_device_config_scroll_get_button
uint32_t libinput_device_config_scroll_get_button(struct libinput_device *device)
Get the button for the LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN method for this device.
libinput_device_get_name
const char * libinput_device_get_name(struct libinput_device *device)
The descriptive device name as advertised by the kernel and/or the hardware itself.
libinput_device_config_calibration_set_matrix
enum libinput_config_status libinput_device_config_calibration_set_matrix(struct libinput_device *device, const float matrix[6])
Apply the 3x3 transformation matrix to absolute device coordinates.
libinput_event_tablet_tool_rotation_has_changed
int libinput_event_tablet_tool_rotation_has_changed(struct libinput_event_tablet_tool *event)
Check if the z-rotation axis was updated in this event.
LIBINPUT_LED_SCROLL_LOCK
Definition: libinput.h:213
LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS
Use software-button areas (see Clickfinger behavior) to generate button events.
Definition: libinput.h:4795
libinput_event_keyboard_get_seat_key_count
uint32_t libinput_event_keyboard_get_seat_key_count(struct libinput_event_keyboard *event)
For the key of a LIBINPUT_EVENT_KEYBOARD_KEY event, return the total number of keys pressed on all de...
libinput_event_tablet_pad_get_button_number
uint32_t libinput_event_tablet_pad_get_button_number(struct libinput_event_tablet_pad *event)
Return the button number that triggered this event, starting at 0.
libinput_tablet_tool_unref
struct libinput_tablet_tool * libinput_tablet_tool_unref(struct libinput_tablet_tool *tool)
Decrement the reference count of the tool by one.
libinput_event_gesture_get_scale
double libinput_event_gesture_get_scale(struct libinput_event_gesture *event)
Return the absolute scale of a pinch gesture, the scale is the division of the current distance betwe...
libinput_device_config_dwt_set_enabled
enum libinput_config_status libinput_device_config_dwt_set_enabled(struct libinput_device *device, enum libinput_config_dwt_state enable)
Enable or disable the disable-while-typing feature.
libinput_event_tablet_tool_get_dy
double libinput_event_tablet_tool_get_dy(struct libinput_event_tablet_tool *event)
Return the delta between the last event and the current event.
libinput_seat_get_user_data
void * libinput_seat_get_user_data(struct libinput_seat *seat)
Get the caller-specific data associated with this seat, if any.
LIBINPUT_POINTER_AXIS_SOURCE_WHEEL_TILT
The event is caused by the tilting of a mouse wheel rather than its rotation.
Definition: libinput.h:269
LIBINPUT_POINTER_AXIS_SOURCE_FINGER
The event is caused by the movement of one or more fingers on a device.
Definition: libinput.h:259
libinput_device_tablet_pad_get_mode_group
struct libinput_tablet_pad_mode_group * libinput_device_tablet_pad_get_mode_group(struct libinput_device *device, unsigned int index)
The returned mode group is not refcounted and may become invalid after the next call to libinput...
libinput_config_drag_state
libinput_config_drag_state
A config status to distinguish or set dragging on a device.
Definition: libinput.h:4092
LIBINPUT_CONFIG_TAP_ENABLED
Tapping is to be enabled, or is currently enabled.
Definition: libinput.h:3921
libinput_tablet_tool_get_serial
uint64_t libinput_tablet_tool_get_serial(struct libinput_tablet_tool *tool)
Return the serial number of a tool.
libinput_device_config_accel_get_profile
enum libinput_config_accel_profile libinput_device_config_accel_get_profile(struct libinput_device *device)
Get the current pointer acceleration profile for this pointer device.
libinput_event_gesture_get_finger_count
int libinput_event_gesture_get_finger_count(struct libinput_event_gesture *event)
Return the number of fingers used for a gesture.
libinput_event_device_notify_get_base_event
struct libinput_event * libinput_event_device_notify_get_base_event(struct libinput_event_device_notify *event)
libinput_device_config_middle_emulation_get_enabled
enum libinput_config_middle_emulation_state libinput_device_config_middle_emulation_get_enabled(struct libinput_device *device)
Check if configurable middle button emulation is enabled on this device.
libinput_device_config_dwt_get_default_enabled
enum libinput_config_dwt_state libinput_device_config_dwt_get_default_enabled(struct libinput_device *device)
Check if the disable-while typing feature is enabled on this device by default.
LIBINPUT_CONFIG_CLICK_METHOD_NONE
Do not send software-emulated button events.
Definition: libinput.h:4790
libinput_event_tablet_tool_x_has_changed
int libinput_event_tablet_tool_x_has_changed(struct libinput_event_tablet_tool *event)
Check if the x axis was updated in this event.
LIBINPUT_EVENT_KEYBOARD_KEY
Definition: libinput.h:683
libinput_device_config_scroll_get_default_button
uint32_t libinput_device_config_scroll_get_default_button(struct libinput_device *device)
Get the default button for the LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN method for this device...
libinput_log_handler
void(* libinput_log_handler)(struct libinput *libinput, enum libinput_log_priority priority, const char *format, va_list args) LIBINPUT_ATTRIBUTE_PRINTF(3
Log handler type for custom logging.
Definition: libinput.h:3233
libinput_event_tablet_tool_get_tool
struct libinput_tablet_tool * libinput_event_tablet_tool_get_tool(struct libinput_event_tablet_tool *event)
Returns the tool that was in use during this event.
libinput_event_tablet_tool_get_slider_position
double libinput_event_tablet_tool_get_slider_position(struct libinput_event_tablet_tool *event)
Returns the current position of the slider on the tool, normalized to the range [-1, 1].
LIBINPUT_EVENT_GESTURE_PINCH_UPDATE
Definition: libinput.h:807
libinput_device_touch_get_touch_count
int libinput_device_touch_get_touch_count(struct libinput_device *device)
Check how many touches a LIBINPUT_DEVICE_CAP_TOUCH device supports simultaneously.
libinput_device_config_tap_get_button_map
enum libinput_config_tap_button_map libinput_device_config_tap_get_button_map(struct libinput_device *device)
Get the finger number to button number mapping for tap-to-click.
libinput_event_tablet_tool_get_x_transformed
double libinput_event_tablet_tool_get_x_transformed(struct libinput_event_tablet_tool *event, uint32_t width)
Return the current absolute x coordinate of the tablet tool event, transformed to screen coordinates...
libinput_event_pointer_get_axis_value
double libinput_event_pointer_get_axis_value(struct libinput_event_pointer *event, enum libinput_pointer_axis axis)
Return the axis value of the given axis.
libinput_event_tablet_tool_get_y_transformed
double libinput_event_tablet_tool_get_y_transformed(struct libinput_event_tablet_tool *event, uint32_t height)
Return the current absolute y coordinate of the tablet tool event, transformed to screen coordinates...
LIBINPUT_EVENT_DEVICE_ADDED
Signals that a device has been added to the context.
Definition: libinput.h:675
libinput_tablet_pad_mode_group_set_user_data
void libinput_tablet_pad_mode_group_set_user_data(struct libinput_tablet_pad_mode_group *group, void *user_data)
Set caller-specific data associated with this mode group.
libinput_event_gesture_get_dy_unaccelerated
double libinput_event_gesture_get_dy_unaccelerated(struct libinput_event_gesture *event)
Return the relative delta of the unaccelerated motion vector of the current event.
LIBINPUT_CONFIG_STATUS_UNSUPPORTED
Configuration not available on this device.
Definition: libinput.h:3898
libinput_interface::close_restricted
void(* close_restricted)(int fd, void *user_data)
Close the file descriptor.
Definition: libinput.h:2911
libinput_tablet_tool_proximity_state
libinput_tablet_tool_proximity_state
The state of proximity for a tool on a device.
Definition: libinput.h:347
LIBINPUT_EVENT_POINTER_MOTION
Definition: libinput.h:685
libinput_event_pointer_get_dy
double libinput_event_pointer_get_dy(struct libinput_event_pointer *event)
Return the delta between the last event and the current event.
libinput_device_config_click_get_default_method
enum libinput_config_click_method libinput_device_config_click_get_default_method(struct libinput_device *device)
Get the default button click method for this device.
LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT
A flat acceleration profile.
Definition: libinput.h:4561
libinput_device_tablet_pad_get_num_buttons
int libinput_device_tablet_pad_get_num_buttons(struct libinput_device *device)
Return the number of buttons on a device with the LIBINPUT_DEVICE_CAP_TABLET_PAD capability.
libinput_event_gesture_get_time
uint32_t libinput_event_gesture_get_time(struct libinput_event_gesture *event)
libinput_path_remove_device
void libinput_path_remove_device(struct libinput_device *device)
Remove a device from a libinput context initialized with libinput_path_create_context() or added to s...
LIBINPUT_EVENT_DEVICE_REMOVED
Signals that a device has been removed.
Definition: libinput.h:681
libinput_device_config_calibration_get_default_matrix
int libinput_device_config_calibration_get_default_matrix(struct libinput_device *device, float matrix[6])
Return the default calibration matrix for this device.
libinput_log_set_priority
void libinput_log_set_priority(struct libinput *libinput, enum libinput_log_priority priority)
Set the log priority for the libinput context.
libinput_device_config_scroll_get_natural_scroll_enabled
int libinput_device_config_scroll_get_natural_scroll_enabled(struct libinput_device *device)
Get the current mode for scrolling on this device.
libinput_device_config_scroll_set_method
enum libinput_config_status libinput_device_config_scroll_set_method(struct libinput_device *device, enum libinput_config_scroll_method method)
Set the scroll method for this device.
libinput_event_tablet_tool_get_button_state
enum libinput_button_state libinput_event_tablet_tool_get_button_state(struct libinput_event_tablet_tool *event)
Return the button state of the event.
LIBINPUT_EVENT_GESTURE_PINCH_END
Definition: libinput.h:808
LIBINPUT_LOG_PRIORITY_INFO
Definition: libinput.h:174
libinput_config_send_events_mode
libinput_config_send_events_mode
The send-event mode of a device defines when a device may generate events and pass those events to th...
Definition: libinput.h:4354
libinput_device_set_seat_logical_name
int libinput_device_set_seat_logical_name(struct libinput_device *device, const char *name)
Change the logical seat associated with this device by removing the device and adding it to the new s...
libinput_button_state
libinput_button_state
Logical state of a physical button.
Definition: libinput.h:222
libinput_config_status_to_str
const char * libinput_config_status_to_str(enum libinput_config_status status)
Return a string describing the error.
LIBINPUT_DEVICE_CAP_SWITCH
Definition: libinput.h:191
libinput_device_config_tap_get_enabled
enum libinput_config_tap_state libinput_device_config_tap_get_enabled(struct libinput_device *device)
Check if tap-to-click is enabled on this device.
libinput_event_tablet_tool_wheel_has_changed
int libinput_event_tablet_tool_wheel_has_changed(struct libinput_event_tablet_tool *event)
Check if the wheel axis was updated in this event.
libinput_device_ref
struct libinput_device * libinput_device_ref(struct libinput_device *device)
Increase the refcount of the input device.
libinput_tablet_tool_get_type
enum libinput_tablet_tool_type libinput_tablet_tool_get_type(struct libinput_tablet_tool *tool)
Return the tool type for a tool object, see Vendor-specific tablet tool types for details...
LIBINPUT_CONFIG_SCROLL_2FG
Send scroll events when two fingers are logically down on the device.
Definition: libinput.h:5014
libinput_event_touch_get_time
uint32_t libinput_event_touch_get_time(struct libinput_event_touch *event)
libinput_event_pointer
A pointer event representing relative or absolute pointer movement, a button press/release or scroll ...
Definition: libinput.h:121
libinput_device_config_accel_get_speed
double libinput_device_config_accel_get_speed(struct libinput_device *device)
Get the current pointer acceleration setting for this pointer device.
libinput_event_touch_get_x
double libinput_event_touch_get_x(struct libinput_event_touch *event)
Return the current absolute x coordinate of the touch event, in mm from the top left corner of the de...
libinput_event_tablet_tool_tilt_x_has_changed
int libinput_event_tablet_tool_tilt_x_has_changed(struct libinput_event_tablet_tool *event)
Check if the tilt x axis was updated in this event.
LIBINPUT_EVENT_TABLET_TOOL_TIP
Signals that a tool has come in contact with the surface of a device with the LIBINPUT_DEVICE_CAP_TAB...
Definition: libinput.h:765
libinput_event_pointer_get_seat_button_count
uint32_t libinput_event_pointer_get_seat_button_count(struct libinput_event_pointer *event)
For the button of a LIBINPUT_EVENT_POINTER_BUTTON event, return the total number of buttons pressed o...
libinput_event_gesture_get_dx_unaccelerated
double libinput_event_gesture_get_dx_unaccelerated(struct libinput_event_gesture *event)
Return the relative delta of the unaccelerated motion vector of the current event.
libinput_tablet_tool_is_unique
int libinput_tablet_tool_is_unique(struct libinput_tablet_tool *tool)
Return nonzero if the physical tool can be uniquely identified by libinput, or nonzero otherwise...
libinput_device_config_calibration_get_matrix
int libinput_device_config_calibration_get_matrix(struct libinput_device *device, float matrix[6])
Return the current calibration matrix for this device.
libinput_tablet_tool_tip_state
libinput_tablet_tool_tip_state
The tip contact state for a tool on a device.
Definition: libinput.h:361
libinput_event_tablet_pad_get_time
uint32_t libinput_event_tablet_pad_get_time(struct libinput_event_tablet_pad *event)
libinput_tablet_pad_mode_group_get_mode
unsigned int libinput_tablet_pad_mode_group_get_mode(struct libinput_tablet_pad_mode_group *group)
Return the current mode this mode group is in.
libinput_device_config_scroll_set_button
enum libinput_config_status libinput_device_config_scroll_set_button(struct libinput_device *device, uint32_t button)
Set the button for the LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN method for this device.
libinput_event_tablet_tool_get_tilt_x
double libinput_event_tablet_tool_get_tilt_x(struct libinput_event_tablet_tool *event)
Returns the current tilt along the X axis of the tablet&#39;s current logical orientation, in degrees off the tablet&#39;s z axis.
libinput_tablet_pad_mode_group_get_user_data
void * libinput_tablet_pad_mode_group_get_user_data(struct libinput_tablet_pad_mode_group *group)
Get the caller-specific data associated with this mode group, if any.
LIBINPUT_EVENT_POINTER_BUTTON
Definition: libinput.h:687
libinput_device_config_middle_emulation_get_default_enabled
enum libinput_config_middle_emulation_state libinput_device_config_middle_emulation_get_default_enabled(struct libinput_device *device)
Check if configurable middle button emulation is enabled by default on this device.
libinput_event_keyboard_get_key_state
enum libinput_key_state libinput_event_keyboard_get_key_state(struct libinput_event_keyboard *event)
libinput_device_config_left_handed_is_available
int libinput_device_config_left_handed_is_available(struct libinput_device *device)
Check if a device has a configuration that supports left-handed usage.
libinput_event_pointer_get_dx
double libinput_event_pointer_get_dx(struct libinput_event_pointer *event)
Return the delta between the last event and the current event.
libinput_event_pointer_get_absolute_y_transformed
double libinput_event_pointer_get_absolute_y_transformed(struct libinput_event_pointer *event, uint32_t height)
Return the current absolute y coordinate of the pointer event, transformed to screen coordinates...
libinput_event_pointer_get_absolute_x
double libinput_event_pointer_get_absolute_x(struct libinput_event_pointer *event)
Return the current absolute x coordinate of the pointer event, in mm from the top left corner of the ...
libinput_event_get_device_notify_event
struct libinput_event_device_notify * libinput_event_get_device_notify_event(struct libinput_event *event)
Return the device event that is this input event.
libinput_pointer_axis
libinput_pointer_axis
Axes on a device with the capability LIBINPUT_DEVICE_CAP_POINTER that are not x or y coordinates...
Definition: libinput.h:239
libinput_device_group_set_user_data
void libinput_device_group_set_user_data(struct libinput_device_group *group, void *user_data)
Set caller-specific data associated with this device group.
libinput_device_config_calibration_has_matrix
int libinput_device_config_calibration_has_matrix(struct libinput_device *device)
Check if the device can be calibrated via a calibration matrix.
libinput_device_config_dwt_is_available
int libinput_device_config_dwt_is_available(struct libinput_device *device)
Check if this device supports configurable disable-while-typing feature.
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_OUT
Definition: libinput.h:348
libinput_config_tap_state
libinput_config_tap_state
Definition: libinput.h:3918
LIBINPUT_TABLET_TOOL_TYPE_LENS
A mouse tool with a lens.
Definition: libinput.h:330
LIBINPUT_DEVICE_CAP_KEYBOARD
Definition: libinput.h:185
libinput_set_user_data
void libinput_set_user_data(struct libinput *libinput, void *user_data)
Set caller-specific data associated with this context.
LIBINPUT_TABLET_TOOL_TYPE_ERASER
Eraser.
Definition: libinput.h:324
libinput_tablet_tool
An object representing a tool being used by a device with the LIBINPUT_DEVICE_CAP_TABLET_TOOL capabil...
Definition: libinput.h:76
libinput_device_tablet_pad_get_num_rings
int libinput_device_tablet_pad_get_num_rings(struct libinput_device *device)
Return the number of rings a device with the LIBINPUT_DEVICE_CAP_TABLET_PAD capability provides...
LIBINPUT_TABLET_TOOL_TYPE_PEN
A generic pen.
Definition: libinput.h:323
LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED
Middle mouse button emulation is to be enabled, or is currently enabled.
Definition: libinput.h:4892
libinput_event_tablet_pad_get_button_state
enum libinput_button_state libinput_event_tablet_pad_get_button_state(struct libinput_event_tablet_pad *event)
Return the button state of the event.
libinput_tablet_pad_mode_group
A mode on a tablet pad is a virtual grouping of functionality, usually based on some visual feedback ...
libinput_device_config_send_events_get_default_mode
uint32_t libinput_device_config_send_events_get_default_mode(struct libinput_device *device)
Get the default send-event mode for this device.
libinput_event_pointer_get_axis_source
enum libinput_pointer_axis_source libinput_event_pointer_get_axis_source(struct libinput_event_pointer *event)
Return the source for a given axis event.
libinput_event_pointer_has_axis
int libinput_event_pointer_has_axis(struct libinput_event_pointer *event, enum libinput_pointer_axis axis)
Check if the event has a valid value for the given axis.
libinput_device_config_tap_set_enabled
enum libinput_config_status libinput_device_config_tap_set_enabled(struct libinput_device *device, enum libinput_config_tap_state enable)
Enable or disable tap-to-click on this device, with a default mapping of 1, 2, 3 finger tap mapping t...
LIBINPUT_KEY_STATE_RELEASED
Definition: libinput.h:201
libinput_device_capability
libinput_device_capability
Capabilities on a device.
Definition: libinput.h:184
LIBINPUT_POINTER_AXIS_SOURCE_WHEEL
The event is caused by the rotation of a wheel.
Definition: libinput.h:254
LIBINPUT_EVENT_TOUCH_UP
Definition: libinput.h:691
libinput_config_status
libinput_config_status
Status codes returned when applying configuration settings.
Definition: libinput.h:3896
libinput_event_tablet_tool_distance_has_changed
int libinput_event_tablet_tool_distance_has_changed(struct libinput_event_tablet_tool *event)
Check if the distance axis was updated in this event.
libinput_device_config_tap_get_default_button_map
enum libinput_config_tap_button_map libinput_device_config_tap_get_default_button_map(struct libinput_device *device)
Get the default finger number to button number mapping for tap-to-click.
libinput_event_tablet_tool_tilt_y_has_changed
int libinput_event_tablet_tool_tilt_y_has_changed(struct libinput_event_tablet_tool *event)
Check if the tilt y axis was updated in this event.
libinput_tablet_pad_mode_group_ref
struct libinput_tablet_pad_mode_group * libinput_tablet_pad_mode_group_ref(struct libinput_tablet_pad_mode_group *group)
Increase the refcount of the mode group.
LIBINPUT_KEY_STATE_PRESSED
Definition: libinput.h:202
libinput_tablet_pad_ring_axis_source
libinput_tablet_pad_ring_axis_source
The source for a LIBINPUT_EVENT_TABLET_PAD_RING event.
Definition: libinput.h:278
LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE
Definition: libinput.h:804
libinput_event_touch_get_y
double libinput_event_touch_get_y(struct libinput_event_touch *event)
Return the current absolute y coordinate of the touch event, in mm from the top left corner of the de...
libinput_event_tablet_tool_get_base_event
struct libinput_event * libinput_event_tablet_tool_get_base_event(struct libinput_event_tablet_tool *event)
libinput_device_config_middle_emulation_is_available
int libinput_device_config_middle_emulation_is_available(struct libinput_device *device)
Check if middle mouse button emulation configuration is available on this device. ...
libinput_device_config_scroll_get_method
enum libinput_config_scroll_method libinput_device_config_scroll_get_method(struct libinput_device *device)
Get the scroll method for this device.
libinput_config_tap_button_map
libinput_config_tap_button_map
Definition: libinput.h:4006
libinput_event_tablet_pad_get_strip_number
unsigned int libinput_event_tablet_pad_get_strip_number(struct libinput_event_tablet_pad *event)
Returns the number of the strip that has changed state, with 0 being the first strip.
libinput_event_tablet_tool_get_wheel_delta
double libinput_event_tablet_tool_get_wheel_delta(struct libinput_event_tablet_tool *event)
Return the delta for the wheel in degrees.
libinput_event_touch_get_seat_slot
int32_t libinput_event_touch_get_seat_slot(struct libinput_event_touch *event)
Get the seat slot of the touch event.
libinput_event_pointer_get_axis_value_discrete
double libinput_event_pointer_get_axis_value_discrete(struct libinput_event_pointer *event, enum libinput_pointer_axis axis)
Return the axis value in discrete steps for a given axis event.
libinput_device_tablet_pad_get_num_mode_groups
int libinput_device_tablet_pad_get_num_mode_groups(struct libinput_device *device)
Most devices only provide a single mode group, however devices such as the Wacom Cintiq 22HD provide ...
LIBINPUT_LOG_PRIORITY_ERROR
Definition: libinput.h:175
libinput_event_pointer_get_absolute_y
double libinput_event_pointer_get_absolute_y(struct libinput_event_pointer *event)
Return the current absolute y coordinate of the pointer event, in mm from the top left corner of the ...
libinput_device_config_send_events_get_mode
uint32_t libinput_device_config_send_events_get_mode(struct libinput_device *device)
Get the send-event mode for this device.
libinput_event_gesture_get_cancelled
int libinput_event_gesture_get_cancelled(struct libinput_event_gesture *event)
Return if the gesture ended normally, or if it was cancelled.
LIBINPUT_EVENT_SWITCH_TOGGLE
Definition: libinput.h:810
libinput_device_led_update
void libinput_device_led_update(struct libinput_device *device, enum libinput_led leds)
Update the LEDs on the device, if any.
libinput_device_config_click_set_method
enum libinput_config_status libinput_device_config_click_set_method(struct libinput_device *device, enum libinput_config_click_method method)
Set the button click method for this device.
libinput_path_add_device
struct libinput_device * libinput_path_add_device(struct libinput *libinput, const char *path)
Add a device to a libinput context initialized with libinput_path_create_context().
libinput_event_tablet_tool
Tablet tool event representing an axis update, button press, or tool update.
Definition: libinput.h:142
libinput_event_tablet_tool_get_time_usec
uint64_t libinput_event_tablet_tool_get_time_usec(struct libinput_event_tablet_tool *event)
libinput_event_touch_get_x_transformed
double libinput_event_touch_get_x_transformed(struct libinput_event_touch *event, uint32_t width)
Return the current absolute x coordinate of the touch event, transformed to screen coordinates...
libinput_event_gesture_get_dy
double libinput_event_gesture_get_dy(struct libinput_event_gesture *event)
Return the delta between the last event and the current event.
libinput_event_tablet_pad_get_ring_number
unsigned int libinput_event_tablet_pad_get_ring_number(struct libinput_event_tablet_pad *event)
Returns the number of the ring that has changed state, with 0 being the first ring.
libinput_tablet_tool_set_user_data
void libinput_tablet_tool_set_user_data(struct libinput_tablet_tool *tool, void *user_data)
Set the user data associated with a tool object, if any.
libinput_event_get_context
struct libinput * libinput_event_get_context(struct libinput_event *event)
Get the libinput context from the event.
LIBINPUT_CONFIG_DRAG_LOCK_ENABLED
Drag lock is to be enabled, or is currently disabled.
Definition: libinput.h:4165
LIBINPUT_CONFIG_TAP_MAP_LMR
1/2/3 finger tap maps to left/middle/right
Definition: libinput.h:4010
LIBINPUT_SWITCH_LID
The laptop lid was closed when the switch state is LIBINPUT_SWITCH_STATE_ON, or was opened when it is...
Definition: libinput.h:627
libinput_device_config_tap_get_default_drag_lock_enabled
enum libinput_config_drag_lock_state libinput_device_config_tap_get_default_drag_lock_enabled(struct libinput_device *device)
Check if drag-lock during tapping is enabled by default on this device.
libinput_device_config_click_get_method
enum libinput_config_click_method libinput_device_config_click_get_method(struct libinput_device *device)
Get the button click method for this device.
LIBINPUT_DEVICE_CAP_TABLET_TOOL
Definition: libinput.h:188
LIBINPUT_EVENT_TOUCH_CANCEL
Definition: libinput.h:693
libinput_event_get_gesture_event
struct libinput_event_gesture * libinput_event_get_gesture_event(struct libinput_event *event)
Return the gesture event that is this input event.
libinput_event
The base event type.
Definition: libinput.h:93
LIBINPUT_ATTRIBUTE_PRINTF
#define LIBINPUT_ATTRIBUTE_PRINTF(_format, _args)
Definition: libinput.h:37
libinput_config_click_method
libinput_config_click_method
The click method defines when to generate software-emulated buttons, usually on a device that does no...
Definition: libinput.h:4785
libinput_device_config_accel_set_speed
enum libinput_config_status libinput_device_config_accel_set_speed(struct libinput_device *device, double speed)
Set the pointer acceleration speed of this pointer device within a range of [-1, 1], where 0 is the default acceleration for this device, -1 is the slowest acceleration and 1 is the maximum acceleration available on this device.
libinput_event_tablet_tool_get_proximity_state
enum libinput_tablet_tool_proximity_state libinput_event_tablet_tool_get_proximity_state(struct libinput_event_tablet_tool *event)
Returns the new proximity state of a tool from a proximity event.
libinput_device_config_tap_get_drag_enabled
enum libinput_config_drag_state libinput_device_config_tap_get_drag_enabled(struct libinput_device *device)
Return whether tap-and-drag is enabled or disabled on this device.
libinput_device_group
A base handle for accessing libinput device groups.
Definition: libinput.h:57
libinput_device_config_left_handed_get_default
int libinput_device_config_left_handed_get_default(struct libinput_device *device)
Get the default left-handed configuration of the device.
libinput_path_create_context
struct libinput * libinput_path_create_context(const struct libinput_interface *interface, void *user_data)
Create a new libinput context that requires the caller to manually add or remove devices with libinpu...
LIBINPUT_TABLET_TOOL_TYPE_BRUSH
A paintbrush-like tool.
Definition: libinput.h:325
LIBINPUT_EVENT_TABLET_PAD_BUTTON
A button pressed on a device with the LIBINPUT_DEVICE_CAP_TABLET_PAD capability.
Definition: libinput.h:790
LIBINPUT_TABLET_PAD_RING_SOURCE_FINGER
The event is caused by the movement of one or more fingers on the ring.
Definition: libinput.h:284
libinput_event_tablet_pad_get_mode
unsigned int libinput_event_tablet_pad_get_mode(struct libinput_event_tablet_pad *event)
Returns the mode the button, ring, or strip that triggered this event is in, at the time of the event...
libinput_seat_unref
struct libinput_seat * libinput_seat_unref(struct libinput_seat *seat)
Decrease the refcount of the seat.
LIBINPUT_CONFIG_SEND_EVENTS_ENABLED
Send events from this device normally.
Definition: libinput.h:4360
libinput_device_config_tap_get_finger_count
int libinput_device_config_tap_get_finger_count(struct libinput_device *device)
Check if the device supports tap-to-click and how many fingers can be used for tapping.
LIBINPUT_CONFIG_DWT_DISABLED
Definition: libinput.h:5209
libinput_device_get_context
struct libinput * libinput_device_get_context(struct libinput_device *device)
Get the libinput context from the device.
LIBINPUT_CONFIG_STATUS_INVALID
Invalid parameter range.
Definition: libinput.h:3900
libinput_device_get_id_vendor
unsigned int libinput_device_get_id_vendor(struct libinput_device *device)
Get the vendor ID for this device.
libinput_tablet_pad_mode_group_has_ring
int libinput_tablet_pad_mode_group_has_ring(struct libinput_tablet_pad_mode_group *group, unsigned int ring)
Devices without mode switching capabilities return true for every ring.
libinput_tablet_pad_mode_group_button_is_toggle
int libinput_tablet_pad_mode_group_button_is_toggle(struct libinput_tablet_pad_mode_group *group, unsigned int button)
The toggle button in a mode group is the button assigned to cycle to or directly assign a new mode wh...
libinput_event_get_switch_event
struct libinput_event_switch * libinput_event_get_switch_event(struct libinput_event *event)
Return the switch event that is this input event.
LIBINPUT_CONFIG_ACCEL_PROFILE_NONE
Placeholder for devices that don&#39;t have a configurable pointer acceleration profile.
Definition: libinput.h:4553
libinput_event_get_type
enum libinput_event_type libinput_event_get_type(struct libinput_event *event)
Get the type of the event.
libinput_device_group_ref
struct libinput_device_group * libinput_device_group_ref(struct libinput_device_group *group)
Increase the refcount of the device group.
libinput_event_tablet_tool_get_seat_button_count
uint32_t libinput_event_tablet_tool_get_seat_button_count(struct libinput_event_tablet_tool *event)
For the button of a LIBINPUT_EVENT_TABLET_TOOL_BUTTON event, return the total number of buttons pres...
libinput
A handle for accessing libinput.
LIBINPUT_EVENT_TABLET_PAD_RING
A status change on a tablet ring with the LIBINPUT_DEVICE_CAP_TABLET_PAD capability.
Definition: libinput.h:795
libinput_event_gesture_get_dx
double libinput_event_gesture_get_dx(struct libinput_event_gesture *event)
Return the delta between the last event and the current event.
libinput_device_config_dwt_get_enabled
enum libinput_config_dwt_state libinput_device_config_dwt_get_enabled(struct libinput_device *device)
Check if the disable-while typing feature is currently enabled on this device.
libinput_switch
libinput_switch
The type of a switch.
Definition: libinput.h:621
libinput_event_get_device
struct libinput_device * libinput_event_get_device(struct libinput_event *event)
Return the device associated with this event.
libinput_event_tablet_tool_get_dx
double libinput_event_tablet_tool_get_dx(struct libinput_event_tablet_tool *event)
Return the delta between the last event and the current event.
libinput_get_user_data
void * libinput_get_user_data(struct libinput *libinput)
Get the caller-specific data associated with this context, if any.
libinput_tablet_pad_mode_group_has_button
int libinput_tablet_pad_mode_group_has_button(struct libinput_tablet_pad_mode_group *group, unsigned int button)
Devices without mode switching capabilities return true for every button.
LIBINPUT_CONFIG_DRAG_LOCK_DISABLED
Drag lock is to be disabled, or is currently disabled.
Definition: libinput.h:4163
LIBINPUT_DEVICE_CAP_POINTER
Definition: libinput.h:186
libinput_event_tablet_tool_get_tilt_y
double libinput_event_tablet_tool_get_tilt_y(struct libinput_event_tablet_tool *event)
Returns the current tilt along the Y axis of the tablet&#39;s current logical orientation, in degrees off the tablet&#39;s z axis.
libinput_tablet_tool_has_button
int libinput_tablet_tool_has_button(struct libinput_tablet_tool *tool, uint32_t code)
Check if a tablet tool has a button with the passed-in code (see linux/input.h).
libinput_tablet_tool_has_wheel
int libinput_tablet_tool_has_wheel(struct libinput_tablet_tool *tool)
Return whether the tablet tool has a relative wheel.
LIBINPUT_EVENT_TABLET_TOOL_AXIS
One or more axes have changed state on a device with the LIBINPUT_DEVICE_CAP_TABLET_TOOL capability...
Definition: libinput.h:717
libinput_event_destroy
void libinput_event_destroy(struct libinput_event *event)
Destroy the event, freeing all associated resources.
LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE
Definition: libinput.h:686
libinput_device_config_middle_emulation_set_enabled
enum libinput_config_status libinput_device_config_middle_emulation_set_enabled(struct libinput_device *device, enum libinput_config_middle_emulation_state enable)
Enable or disable middle button emulation on this device.
libinput_event_tablet_pad
Tablet pad event representing a button press, or ring/strip update on the tablet pad itself...
Definition: libinput.h:154
LIBINPUT_TABLET_TOOL_TYPE_PENCIL
Physical drawing tool, e.g.
Definition: libinput.h:326
libinput_suspend
void libinput_suspend(struct libinput *libinput)
Suspend monitoring for new devices and close existing devices.
libinput_event_switch_get_base_event
struct libinput_event * libinput_event_switch_get_base_event(struct libinput_event_switch *event)
libinput_device_config_scroll_get_default_method
enum libinput_config_scroll_method libinput_device_config_scroll_get_default_method(struct libinput_device *device)
Get the default scroll method for this device.
LIBINPUT_CONFIG_DRAG_DISABLED
Drag is to be disabled, or is currently disabled.
Definition: libinput.h:4097
libinput_device_config_scroll_has_natural_scroll
int libinput_device_config_scroll_has_natural_scroll(struct libinput_device *device)
Return non-zero if the device supports "natural scrolling".
LIBINPUT_LED_NUM_LOCK
Definition: libinput.h:211
libinput_device_config_accel_get_default_profile
enum libinput_config_accel_profile libinput_device_config_accel_get_default_profile(struct libinput_device *device)
Return the default pointer acceleration profile for this pointer device.
libinput_device_config_tap_set_drag_lock_enabled
enum libinput_config_status libinput_device_config_tap_set_drag_lock_enabled(struct libinput_device *device, enum libinput_config_drag_lock_state enable)
Enable or disable drag-lock during tapping on this device.
libinput_event_get_tablet_tool_event
struct libinput_event_tablet_tool * libinput_event_get_tablet_tool_event(struct libinput_event *event)
Return the tablet tool event that is this input event.
LIBINPUT_TABLET_PAD_STRIP_SOURCE_UNKNOWN
Definition: libinput.h:294
libinput_event_pointer_get_time_usec
uint64_t libinput_event_pointer_get_time_usec(struct libinput_event_pointer *event)
libinput_device_tablet_pad_get_num_strips
int libinput_device_tablet_pad_get_num_strips(struct libinput_device *device)
Return the number of strips a device with the LIBINPUT_DEVICE_CAP_TABLET_PAD capability provides...
libinput_event_gesture_get_time_usec
uint64_t libinput_event_gesture_get_time_usec(struct libinput_event_gesture *event)
libinput_event_keyboard_get_key
uint32_t libinput_event_keyboard_get_key(struct libinput_event_keyboard *event)
LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN
Send scroll events when a button is down and the device moves along a scroll-capable axis...
Definition: libinput.h:5024
libinput_config_scroll_method
libinput_config_scroll_method
The scroll method of a device selects when to generate scroll axis events instead of pointer motion e...
Definition: libinput.h:5004
LIBINPUT_CONFIG_SCROLL_EDGE
Send scroll events when a finger moves along the bottom or right edge of a device.
Definition: libinput.h:5019
LIBINPUT_CONFIG_TAP_DISABLED
Tapping is to be disabled, or is currently disabled.
Definition: libinput.h:3919
LIBINPUT_BUTTON_STATE_RELEASED
Definition: libinput.h:223
libinput_get_fd
int libinput_get_fd(struct libinput *libinput)
libinput keeps a single file descriptor for all events.
libinput_device_config_tap_get_drag_lock_enabled
enum libinput_config_drag_lock_state libinput_device_config_tap_get_drag_lock_enabled(struct libinput_device *device)
Check if drag-lock during tapping is enabled on this device.
libinput_tablet_tool_ref
struct libinput_tablet_tool * libinput_tablet_tool_ref(struct libinput_tablet_tool *tool)
Increment the reference count of the tool by one.
libinput_device_config_rotation_get_angle
unsigned int libinput_device_config_rotation_get_angle(struct libinput_device *device)
Get the current rotation of a device in degrees clockwise off the logical neutral position...
libinput_resume
int libinput_resume(struct libinput *libinput)
Resume a suspended libinput context.
libinput_tablet_tool_has_slider
int libinput_tablet_tool_has_slider(struct libinput_tablet_tool *tool)
Return whether the tablet tool has a slider axis.
LIBINPUT_EVENT_GESTURE_SWIPE_END
Definition: libinput.h:805
libinput_seat
The base handle for accessing libinput seats.
Definition: libinput.h:67
LIBINPUT_DEVICE_CAP_GESTURE
Definition: libinput.h:190
libinput_event_tablet_pad_get_time_usec
uint64_t libinput_event_tablet_pad_get_time_usec(struct libinput_event_tablet_pad *event)
libinput_udev_create_context
struct libinput * libinput_udev_create_context(const struct libinput_interface *interface, void *user_data, struct udev *udev)
Create a new libinput context from udev.
libinput_event_type
libinput_event_type
Event type for events returned by libinput_get_event().
Definition: libinput.h:659
libinput_device_config_click_get_methods
uint32_t libinput_device_config_click_get_methods(struct libinput_device *device)
Check which button click methods a device supports.
libinput_get_event
struct libinput_event * libinput_get_event(struct libinput *libinput)
Retrieve the next event from libinput&#39;s internal event queue.
libinput_next_event_type
enum libinput_event_type libinput_next_event_type(struct libinput *libinput)
Return the type of the next event in the internal queue.
libinput_device_has_capability
int libinput_device_has_capability(struct libinput_device *device, enum libinput_device_capability capability)
Check if the given device has the specified capability.
LIBINPUT_POINTER_AXIS_SOURCE_CONTINUOUS
The event is caused by the motion of some device.
Definition: libinput.h:263
LIBINPUT_SWITCH_STATE_ON
Definition: libinput.h:613
LIBINPUT_SWITCH_TABLET_MODE
This switch indicates whether the device is in normal laptop mode or behaves like a tablet-like devic...
Definition: libinput.h:643
libinput_event_pointer_get_absolute_x_transformed
double libinput_event_pointer_get_absolute_x_transformed(struct libinput_event_pointer *event, uint32_t width)
Return the current absolute x coordinate of the pointer event, transformed to screen coordinates...
libinput_event_tablet_tool_slider_has_changed
int libinput_event_tablet_tool_slider_has_changed(struct libinput_event_tablet_tool *event)
Check if the slider axis was updated in this event.
libinput_event_keyboard_get_time
uint32_t libinput_event_keyboard_get_time(struct libinput_event_keyboard *event)
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED
Do not send events through this device.
Definition: libinput.h:4374
libinput_event_tablet_tool_get_x
double libinput_event_tablet_tool_get_x(struct libinput_event_tablet_tool *event)
Returns the X coordinate of the tablet tool, in mm from the top left corner of the tablet in its curr...
libinput_event_get_keyboard_event
struct libinput_event_keyboard * libinput_event_get_keyboard_event(struct libinput_event *event)
Return the keyboard event that is this input event.
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_IN
Definition: libinput.h:349
LIBINPUT_LED_CAPS_LOCK
Definition: libinput.h:212
libinput_device_config_accel_is_available
int libinput_device_config_accel_is_available(struct libinput_device *device)
Check if a device uses libinput-internal pointer-acceleration.
libinput_tablet_tool_has_rotation
int libinput_tablet_tool_has_rotation(struct libinput_tablet_tool *tool)
Return whether the tablet tool supports z-rotation.
libinput_event_pointer_get_dx_unaccelerated
double libinput_event_pointer_get_dx_unaccelerated(struct libinput_event_pointer *event)
Return the relative delta of the unaccelerated motion vector of the current event.
libinput_config_middle_emulation_state
libinput_config_middle_emulation_state
Definition: libinput.h:4882
libinput_device_get_seat
struct libinput_seat * libinput_device_get_seat(struct libinput_device *device)
Get the seat associated with this input device, see Seats for details.
libinput_event_tablet_tool_get_button
uint32_t libinput_event_tablet_tool_get_button(struct libinput_event_tablet_tool *event)
Return the button that triggered this event.
libinput_event_pointer_get_button_state
enum libinput_button_state libinput_event_pointer_get_button_state(struct libinput_event_pointer *event)
Return the button state that triggered this event.
LIBINPUT_TABLET_PAD_STRIP_SOURCE_FINGER
The event is caused by the movement of one or more fingers on the strip.
Definition: libinput.h:299
libinput_tablet_pad_mode_group_has_strip
int libinput_tablet_pad_mode_group_has_strip(struct libinput_tablet_pad_mode_group *group, unsigned int strip)
Devices without mode switching capabilities return true for every strip.
LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL
Definition: libinput.h:240
libinput_device_get_udev_device
struct udev_device * libinput_device_get_udev_device(struct libinput_device *device)
Return a udev handle to the device that is this libinput device, if any.
libinput_device_config_scroll_set_natural_scroll_enabled
enum libinput_config_status libinput_device_config_scroll_set_natural_scroll_enabled(struct libinput_device *device, int enable)
Enable or disable natural scrolling on the device.
libinput_device_config_left_handed_set
enum libinput_config_status libinput_device_config_left_handed_set(struct libinput_device *device, int left_handed)
Set the left-handed configuration of the device.
libinput_unref
struct libinput * libinput_unref(struct libinput *libinput)
Dereference the libinput context.
LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN
Definition: libinput.h:803
libinput_tablet_tool_has_distance
int libinput_tablet_tool_has_distance(struct libinput_tablet_tool *tool)
Return whether the tablet tool supports distance.
libinput_log_set_handler
void(*) voi libinput_log_set_handler)(struct libinput *libinput, libinput_log_handler log_handler)
Set the context&#39;s log handler.
Definition: libinput.h:3254
libinput_log_get_priority
enum libinput_log_priority libinput_log_get_priority(const struct libinput *libinput)
Get the context&#39;s log priority.
libinput_tablet_pad_strip_axis_source
libinput_tablet_pad_strip_axis_source
The source for a LIBINPUT_EVENT_TABLET_PAD_STRIP event.
Definition: libinput.h:293
LIBINPUT_EVENT_TABLET_TOOL_BUTTON
Signals that a tool has changed a logical button state on a device with the LIBINPUT_DEVICE_CAP_TABLE...
Definition: libinput.h:781
libinput_device_get_sysname
const char * libinput_device_get_sysname(struct libinput_device *device)
Get the system name of the device.
libinput_event_tablet_pad_get_mode_group
struct libinput_tablet_pad_mode_group * libinput_event_tablet_pad_get_mode_group(struct libinput_event_tablet_pad *event)
Returns the mode group that the button, ring, or strip that triggered this event is considered in...
libinput_device_unref
struct libinput_device * libinput_device_unref(struct libinput_device *device)
Decrease the refcount of the input device.
libinput_config_drag_lock_state
libinput_config_drag_lock_state
Definition: libinput.h:4161
libinput_device_config_scroll_get_default_natural_scroll_enabled
int libinput_device_config_scroll_get_default_natural_scroll_enabled(struct libinput_device *device)
Get the default mode for scrolling on this device.
libinput_device_get_size
int libinput_device_get_size(struct libinput_device *device, double *width, double *height)
Get the physical size of a device in mm, where meaningful.
libinput_device_config_tap_set_drag_enabled
enum libinput_config_status libinput_device_config_tap_set_drag_enabled(struct libinput_device *device, enum libinput_config_drag_state enable)
Enable or disable tap-and-drag on this device.
LIBINPUT_EVENT_TABLET_PAD_STRIP
A status change on a strip on a device with the LIBINPUT_DEVICE_CAP_TABLET_PAD capability.
Definition: libinput.h:801
libinput_seat_set_user_data
void libinput_seat_set_user_data(struct libinput_seat *seat, void *user_data)
Set caller-specific data associated with this seat.
libinput_seat_get_logical_name
const char * libinput_seat_get_logical_name(struct libinput_seat *seat)
Return the logical name of the seat.
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED_ON_EXTERNAL_MOUSE
If an external pointer device is plugged in, do not send events from this device. ...
Definition: libinput.h:4380
libinput_event_switch_get_switch_state
enum libinput_switch_state libinput_event_switch_get_switch_state(struct libinput_event_switch *event)
Return the switch state that triggered this event.
libinput_tablet_tool_get_user_data
void * libinput_tablet_tool_get_user_data(struct libinput_tablet_tool *tool)
Return the user data associated with a tool object.
LIBINPUT_CONFIG_TAP_MAP_LRM
1/2/3 finger tap maps to left/right/middle
Definition: libinput.h:4008
libinput_log_priority
libinput_log_priority
Log priority for internal logging messages.
Definition: libinput.h:172
LIBINPUT_TABLET_TOOL_TYPE_MOUSE
A mouse bound to the tablet.
Definition: libinput.h:329
libinput_device_keyboard_has_key
int libinput_device_keyboard_has_key(struct libinput_device *device, uint32_t code)
Check if a LIBINPUT_DEVICE_CAP_KEYBOARD device has a key with the given code (see linux/input...
libinput_device_config_tap_get_default_drag_enabled
enum libinput_config_drag_state libinput_device_config_tap_get_default_drag_enabled(struct libinput_device *device)
Return whether tap-and-drag is enabled or disabled by default on this device.
libinput_udev_assign_seat
int libinput_udev_assign_seat(struct libinput *libinput, const char *seat_id)
Assign a seat to this libinput context.
libinput_event_touch_get_y_transformed
double libinput_event_touch_get_y_transformed(struct libinput_event_touch *event, uint32_t height)
Return the current absolute y coordinate of the touch event, transformed to screen coordinates...
libinput_interface::open_restricted
int(* open_restricted)(const char *path, int flags, void *user_data)
Open the device at the given path with the flags provided and return the fd.
Definition: libinput.h:2903
libinput_device_config_tap_get_default_enabled
enum libinput_config_tap_state libinput_device_config_tap_get_default_enabled(struct libinput_device *device)
Return the default setting for whether tap-to-click is enabled on this device.
libinput_event_device_notify
An event notifying the caller of a device being added or removed.
Definition: libinput.h:105
libinput_device_group_unref
struct libinput_device_group * libinput_device_group_unref(struct libinput_device_group *group)
Decrease the refcount of the device group.
libinput_device_config_scroll_get_methods
uint32_t libinput_device_config_scroll_get_methods(struct libinput_device *device)
Check which scroll methods a device supports.
libinput_tablet_pad_mode_group_get_num_modes
unsigned int libinput_tablet_pad_mode_group_get_num_modes(struct libinput_tablet_pad_mode_group *group)
Query the mode group for the number of available modes.
libinput_event_keyboard_get_base_event
struct libinput_event * libinput_event_keyboard_get_base_event(struct libinput_event_keyboard *event)
libinput_device_get_output_name
const char * libinput_device_get_output_name(struct libinput_device *device)
A device may be mapped to a single output, or all available outputs.
libinput_event_pointer_get_time
uint32_t libinput_event_pointer_get_time(struct libinput_event_pointer *event)
libinput_event_touch_get_base_event
struct libinput_event * libinput_event_touch_get_base_event(struct libinput_event_touch *event)
libinput_device_config_accel_get_default_speed
double libinput_device_config_accel_get_default_speed(struct libinput_device *device)
Return the default speed setting for this device, normalized to a range of [-1, 1].
libinput_event_pointer_get_dy_unaccelerated
double libinput_event_pointer_get_dy_unaccelerated(struct libinput_event_pointer *event)
Return the relative delta of the unaccelerated motion vector of the current event.
LIBINPUT_TABLET_TOOL_TIP_UP
Definition: libinput.h:362
libinput_device_config_send_events_set_mode
enum libinput_config_status libinput_device_config_send_events_set_mode(struct libinput_device *device, uint32_t mode)
Set the send-event mode for this device.
libinput_event_switch_get_switch
enum libinput_switch libinput_event_switch_get_switch(struct libinput_event_switch *event)
Return the switch that triggered this event.
libinput_key_state
libinput_key_state
Logical state of a key.
Definition: libinput.h:200
LIBINPUT_EVENT_NONE
This is not a real event type, and is only used to tell the user that no new event is available in th...
Definition: libinput.h:665
libinput_device_set_user_data
void libinput_device_set_user_data(struct libinput_device *device, void *user_data)
Set caller-specific data associated with this input device.
libinput_tablet_tool_has_tilt
int libinput_tablet_tool_has_tilt(struct libinput_tablet_tool *tool)
Return whether the tablet tool supports tilt.
libinput_device_switch_has_switch
int libinput_device_switch_has_switch(struct libinput_device *device, enum libinput_switch sw)
Check if a LIBINPUT_DEVICE_CAP_SWITCH device has a switch of the given type.
LIBINPUT_TABLET_TOOL_TIP_DOWN
Definition: libinput.h:363
libinput_event_touch_get_time_usec
uint64_t libinput_event_touch_get_time_usec(struct libinput_event_touch *event)
LIBINPUT_TABLET_PAD_RING_SOURCE_UNKNOWN
Definition: libinput.h:279
libinput_device_pointer_has_button
int libinput_device_pointer_has_button(struct libinput_device *device, uint32_t code)
Check if a LIBINPUT_DEVICE_CAP_POINTER device has a button with the given code (see linux/input...
libinput_device_config_left_handed_get
int libinput_device_config_left_handed_get(struct libinput_device *device)
Get the current left-handed configuration of the device.
libinput_event_keyboard
A keyboard event representing a key press/release.
Definition: libinput.h:113
LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE
An adaptive acceleration profile.
Definition: libinput.h:4567
libinput_seat_get_context
struct libinput * libinput_seat_get_context(struct libinput_seat *seat)
Get the libinput context from the seat.
libinput_event_pointer_get_base_event
struct libinput_event * libinput_event_pointer_get_base_event(struct libinput_event_pointer *event)
libinput_tablet_pad_mode_group_get_index
unsigned int libinput_tablet_pad_mode_group_get_index(struct libinput_tablet_pad_mode_group *group)
The returned number is the same index as passed to libinput_device_tablet_pad_get_mode_group().
libinput_event_tablet_pad_get_strip_source
enum libinput_tablet_pad_strip_axis_source libinput_event_tablet_pad_get_strip_source(struct libinput_event_tablet_pad *event)
Returns the source of the interaction with the strip.
libinput_event_get_pointer_event
struct libinput_event_pointer * libinput_event_get_pointer_event(struct libinput_event *event)
Return the pointer event that is this input event.
libinput_event_tablet_tool_y_has_changed
int libinput_event_tablet_tool_y_has_changed(struct libinput_event_tablet_tool *event)
Check if the y axis was updated in this event.
libinput_device_get_device_group
struct libinput_device_group * libinput_device_get_device_group(struct libinput_device *device)
Get the device group this device is assigned to.
libinput_device_config_send_events_get_modes
uint32_t libinput_device_config_send_events_get_modes(struct libinput_device *device)
Return the possible send-event modes for this device.
libinput_device_group_get_user_data
void * libinput_device_group_get_user_data(struct libinput_device_group *group)
Get the caller-specific data associated with this input device group, if any.
LIBINPUT_CONFIG_DWT_ENABLED
Definition: libinput.h:5210
libinput_event_get_touch_event
struct libinput_event_touch * libinput_event_get_touch_event(struct libinput_event *event)
Return the touch event that is this input event.
libinput_tablet_tool_get_tool_id
uint64_t libinput_tablet_tool_get_tool_id(struct libinput_tablet_tool *tool)
Return the tool ID for a tool object.