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 
68 
76 struct libinput_seat;
77 
97 
108 struct libinput_event;
109 
117 
125 
134 
145 struct libinput_event_touch;
146 
160 
173 
183 };
184 
199 };
200 
210 };
211 
220  LIBINPUT_LED_SCROLL_LOCK = (1 << 2)
221 };
222 
232 };
233 
249 };
250 
281 };
282 
298 };
299 
315 };
316 
351 };
352 
372 };
373 
388 };
389 
418 
434 int
436 
461  unsigned int index);
462 
475 unsigned int
477 
495 unsigned int
497 
517 unsigned int
519 
532 int
534  unsigned int button);
535 
548 int
550  unsigned int ring);
551 
564 int
566  unsigned int strip);
567 
586 int
588  unsigned int button);
589 
603  struct libinput_tablet_pad_mode_group *group);
604 
618  struct libinput_tablet_pad_mode_group *group);
619 
633 void
635  struct libinput_tablet_pad_mode_group *group,
636  void *user_data);
637 
649 void *
651  struct libinput_tablet_pad_mode_group *group);
652 
667 };
668 
683 
699 };
700 
709 struct libinput_event_switch;
710 
723 
733 
739 
741 
746 
756 
847 
871 
879 
892 
904 
909 };
910 
927 void
929 
939 
948 struct libinput *
950 
964 struct libinput_device *
966 
977 struct libinput_event_pointer *
979 
992 
1003 struct libinput_event_touch *
1005 
1023 struct libinput_event_gesture *
1025 
1040 
1053 
1066 struct libinput_event_switch *
1068 
1082 
1088 struct libinput_event *
1090 
1106 uint32_t
1108 
1117 uint64_t
1119 
1125 uint32_t
1127 
1133 enum libinput_key_state
1135 
1141 struct libinput_event *
1143 
1156 uint32_t
1158  struct libinput_event_keyboard *event);
1159 
1175 uint32_t
1177 
1186 uint64_t
1188 
1207 double
1209 
1228 double
1230 
1252 double
1254  struct libinput_event_pointer *event);
1255 
1277 double
1279  struct libinput_event_pointer *event);
1280 
1296 double
1298 
1314 double
1316 
1334 double
1336  struct libinput_event_pointer *event,
1337  uint32_t width);
1338 
1356 double
1358  struct libinput_event_pointer *event,
1359  uint32_t height);
1360 
1373 uint32_t
1375 
1390 
1404 uint32_t
1406  struct libinput_event_pointer *event);
1407 
1425 int
1427  enum libinput_pointer_axis axis);
1428 
1453 double
1455  enum libinput_pointer_axis axis);
1456 
1497 
1514 double
1516  enum libinput_pointer_axis axis);
1517 
1523 struct libinput_event *
1525 
1540 uint32_t
1542 
1551 uint64_t
1553 
1573 int32_t
1575 
1595 int32_t
1597 
1615 double
1617 
1635 double
1637 
1655 double
1657  uint32_t width);
1658 
1676 double
1678  uint32_t height);
1679 
1685 struct libinput_event *
1687 
1710 uint32_t
1711 libinput_event_gesture_get_time(struct libinput_event_gesture *event);
1712 
1721 uint64_t
1722 libinput_event_gesture_get_time_usec(struct libinput_event_gesture *event);
1723 
1729 struct libinput_event *
1730 libinput_event_gesture_get_base_event(struct libinput_event_gesture *event);
1731 
1747 int
1748 libinput_event_gesture_get_finger_count(struct libinput_event_gesture *event);
1749 
1764 int
1765 libinput_event_gesture_get_cancelled(struct libinput_event_gesture *event);
1766 
1782 double
1783 libinput_event_gesture_get_dx(struct libinput_event_gesture *event);
1784 
1800 double
1801 libinput_event_gesture_get_dy(struct libinput_event_gesture *event);
1802 
1821 double
1823  struct libinput_event_gesture *event);
1824 
1843 double
1845  struct libinput_event_gesture *event);
1846 
1873 double
1874 libinput_event_gesture_get_scale(struct libinput_event_gesture *event);
1875 
1897 double
1898 libinput_event_gesture_get_angle_delta(struct libinput_event_gesture *event);
1899 
1924 struct libinput_event *
1926 
1946 int
1948  struct libinput_event_tablet_tool *event);
1949 
1969 int
1971  struct libinput_event_tablet_tool *event);
1972 
1992 int
1994  struct libinput_event_tablet_tool *event);
1995 
2017 int
2019  struct libinput_event_tablet_tool *event);
2020 
2040 int
2042  struct libinput_event_tablet_tool *event);
2043 
2063 int
2065  struct libinput_event_tablet_tool *event);
2085 int
2087  struct libinput_event_tablet_tool *event);
2107 int
2109  struct libinput_event_tablet_tool *event);
2110 
2128 int
2130  struct libinput_event_tablet_tool *event);
2131 
2149 int
2151  struct libinput_event_tablet_tool *event);
2152 
2172 int
2174  struct libinput_event_tablet_tool *event);
2175 
2192 double
2194 
2211 double
2213 
2230 double
2232 
2249 double
2251 
2265 double
2267 
2281 double
2283 
2301 double
2303 
2321 double
2323 
2343 double
2345 
2361 double
2363 
2379 double
2381 
2397 double
2399 
2410 double
2412  struct libinput_event_tablet_tool *event);
2413 
2426 int
2428  struct libinput_event_tablet_tool *event);
2429 
2449 double
2451  uint32_t width);
2452 
2472 double
2474  uint32_t height);
2475 
2498 struct libinput_tablet_tool *
2500 
2529 
2545 
2560 uint32_t
2562 
2578 
2594 uint32_t
2596 
2608 uint32_t
2610 
2622 uint64_t
2624 
2650 
2670 uint64_t
2672 
2686 struct libinput_tablet_tool *
2688 
2703 struct libinput_tablet_tool *
2705 
2716 int
2718 
2729 int
2731 
2742 int
2744 
2755 int
2757 
2768 int
2770 
2782 int
2784 
2795 int
2797 
2811 int
2813  uint32_t code);
2814 
2831 int
2833 
2870 uint64_t
2872 
2885 void *
2887 
2898 void
2900  void *user_data);
2901 
2918 struct libinput_event *
2920 
2943 double
2945 
2962 unsigned int
2964 
2983 
3006 double
3008 
3025 unsigned int
3027 
3046 
3067 uint32_t
3069 
3086 
3105 uint32_t
3107 
3122 enum libinput_key_state
3124 
3157 unsigned int
3159 
3185 
3197 uint32_t
3199 
3211 uint64_t
3213 
3235 enum libinput_switch
3237 
3255 
3263 struct libinput_event *
3265 
3277 uint32_t
3279 
3291 uint64_t
3293 
3321  int (*open_restricted)(const char *path, int flags, void *user_data);
3329  void (*close_restricted)(int fd, void *user_data);
3330 };
3331 
3345 struct libinput *
3347  void *user_data,
3348  struct udev *udev);
3349 
3371 int
3373  const char *seat_id);
3374 
3394 struct libinput *
3396  void *user_data);
3397 
3418 struct libinput_device *
3420  const char *path);
3421 
3440 void
3442 
3451 int
3453 
3471 int
3473 
3485 struct libinput_event *
3487 
3501 
3513 void
3515  void *user_data);
3516 
3527 void *
3529 
3541 int
3543 
3553 void
3555 
3565 struct libinput *
3567 
3599 struct libinput *
3601 
3617 void
3619  enum libinput_log_priority priority);
3620 
3637 
3652 typedef void (*libinput_log_handler)(struct libinput *libinput,
3653  enum libinput_log_priority priority,
3654  const char *format, va_list args)
3656 
3672 void
3674  libinput_log_handler log_handler);
3675 
3697 struct libinput_seat *
3699 
3711 struct libinput_seat *
3713 
3725 void
3726 libinput_seat_set_user_data(struct libinput_seat *seat, void *user_data);
3727 
3737 void *
3739 
3748 struct libinput *
3750 
3767 const char *
3769 
3779 const char *
3781 
3797 struct libinput_device *
3799 
3811 struct libinput_device *
3813 
3825 void
3826 libinput_device_set_user_data(struct libinput_device *device, void *user_data);
3827 
3837 void *
3839 
3848 struct libinput *
3850 
3911 struct libinput_device_group *
3913 
3925 const char *
3927 
3941 const char *
3943 
3952 unsigned int
3954 
3963 unsigned int
3965 
3985 const char *
3987 
4008 struct libinput_seat *
4010 
4036 int
4038  const char *name);
4039 
4059 struct udev_device *
4061 
4072 void
4074  enum libinput_led leds);
4075 
4083 int
4085  enum libinput_device_capability capability);
4086 
4101 int
4103  double *width,
4104  double *height);
4105 
4118 int
4120 
4133 int
4135  uint32_t code);
4136 
4150 int
4152 
4167 int
4169  enum libinput_switch sw);
4170 
4185 int
4187 
4202 int
4204 
4219 int
4221 
4236 int
4238  uint32_t code);
4239 
4252 struct libinput_device_group *
4254 
4268 struct libinput_device_group *
4270 
4282 void
4284  void *user_data);
4285 
4296 void *
4298 
4350 };
4351 
4361 const char *
4363 
4372 };
4373 
4389 int
4391 
4414  enum libinput_config_tap_state enable);
4415 
4434 
4451 
4462 };
4463 
4497 
4519 
4541 
4562 };
4563 
4583  enum libinput_config_drag_state enable);
4584 
4602 
4622 
4631 };
4632 
4657  enum libinput_config_drag_lock_state enable);
4658 
4678 
4701 
4714 int
4716 
4768  const float matrix[6]);
4769 
4786 int
4788  float matrix[6]);
4789 
4810 int
4812  float matrix[6]);
4813 
4847 };
4848 
4863 uint32_t
4865 
4896  uint32_t mode);
4897 
4917 uint32_t
4919 
4933 uint32_t
4935 
4949 int
4951 
4974  double speed);
4975 
4991 double
4993 
5008 double
5010 
5030 
5036 };
5037 
5050 uint32_t
5052 
5068  enum libinput_config_accel_profile profile);
5069 
5083 
5097 
5127 int
5129 
5146  int enable);
5160 int
5162 
5176 int
5178 
5192 int
5194 
5220  int left_handed);
5221 
5235 int
5237 
5251 int
5253 
5275 };
5276 
5292 uint32_t
5294 
5317  enum libinput_config_click_method method);
5335 
5353 
5368 };
5369 
5390 int
5392  struct libinput_device *device);
5393 
5418  struct libinput_device *device,
5420 
5446  struct libinput_device *device);
5447 
5474  struct libinput_device *device);
5475 
5503 };
5504 
5522 uint32_t
5524 
5551  enum libinput_config_scroll_method method);
5552 
5571 
5590 
5628  uint32_t button);
5629 
5654 uint32_t
5656 
5677 uint32_t
5679 
5683 };
5684 
5709 
5734 
5754 
5763 };
5764 
5780 int
5782 
5806  enum libinput_config_dwt_state enable);
5807 
5825 
5843 
5858 int
5860 
5895  unsigned int degrees_cw);
5896 
5913 unsigned int
5915 
5932 unsigned int
5934 
5935 #ifdef __cplusplus
5936 }
5937 #endif
5938 #endif /* LIBINPUT_H */
int libinput_dispatch(struct libinput *libinput)
Main event dispatchment function.
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...
void * libinput_get_user_data(struct libinput *libinput)
Get the caller-specific data associated with this context, if any.
int libinput_resume(struct libinput *libinput)
Resume a suspended libinput context.
void libinput_suspend(struct libinput *libinput)
Suspend monitoring for new devices and close existing devices.
int libinput_udev_assign_seat(struct libinput *libinput, const char *seat_id)
Assign a seat to this libinput context.
enum libinput_log_priority libinput_log_get_priority(const struct libinput *libinput)
Get the context's log priority.
struct libinput * libinput_udev_create_context(const struct libinput_interface *interface, void *user_data, struct udev *udev)
Create a new libinput context from udev.
void libinput_log_set_priority(struct libinput *libinput, enum libinput_log_priority priority)
Set the log priority for the libinput context.
struct libinput * libinput_unref(struct libinput *libinput)
Dereference the libinput context.
int libinput_get_fd(struct libinput *libinput)
libinput keeps a single file descriptor for all events.
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...
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:3652
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_log_priority
Log priority for internal logging messages.
Definition: libinput.h:179
void libinput_set_user_data(struct libinput *libinput, void *user_data)
Set caller-specific data associated with this context.
libinput_event_type
Event type for events returned by libinput_get_event().
Definition: libinput.h:716
enum libinput_event_type libinput_next_event_type(struct libinput *libinput)
Return the type of the next event in the internal queue.
struct libinput_event * libinput_get_event(struct libinput *libinput)
Retrieve the next event from libinput's internal event queue.
void(*) voi libinput_log_set_handler)(struct libinput *libinput, libinput_log_handler log_handler)
Set the context's log handler.
Definition: libinput.h:3673
struct libinput * libinput_ref(struct libinput *libinput)
Add a reference to the context.
@ LIBINPUT_LOG_PRIORITY_DEBUG
Definition: libinput.h:180
@ LIBINPUT_LOG_PRIORITY_INFO
Definition: libinput.h:181
@ LIBINPUT_LOG_PRIORITY_ERROR
Definition: libinput.h:182
@ LIBINPUT_EVENT_GESTURE_SWIPE_END
Definition: libinput.h:895
@ LIBINPUT_EVENT_TABLET_PAD_KEY
A key pressed on a device with the LIBINPUT_DEVICE_CAP_TABLET_PAD capability.
Definition: libinput.h:891
@ LIBINPUT_EVENT_POINTER_MOTION
Definition: libinput.h:742
@ LIBINPUT_EVENT_TOUCH_UP
Definition: libinput.h:748
@ LIBINPUT_EVENT_TABLET_PAD_RING
A status change on a tablet ring with the LIBINPUT_DEVICE_CAP_TABLET_PAD capability.
Definition: libinput.h:870
@ LIBINPUT_EVENT_POINTER_BUTTON
Definition: libinput.h:744
@ 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:878
@ LIBINPUT_EVENT_TOUCH_FRAME
Signals the end of a set of touchpoints at one device sample time.
Definition: libinput.h:755
@ LIBINPUT_EVENT_KEYBOARD_KEY
Definition: libinput.h:740
@ LIBINPUT_EVENT_DEVICE_ADDED
Signals that a device has been added to the context.
Definition: libinput.h:732
@ 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:803
@ LIBINPUT_EVENT_POINTER_AXIS
Definition: libinput.h:745
@ LIBINPUT_EVENT_GESTURE_HOLD_END
Definition: libinput.h:903
@ LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE
Definition: libinput.h:743
@ LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN
Definition: libinput.h:893
@ 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:846
@ LIBINPUT_EVENT_GESTURE_HOLD_BEGIN
Definition: libinput.h:902
@ LIBINPUT_EVENT_TABLET_PAD_BUTTON
A button pressed on a device with the LIBINPUT_DEVICE_CAP_TABLET_PAD capability.
Definition: libinput.h:863
@ LIBINPUT_EVENT_DEVICE_REMOVED
Signals that a device has been removed.
Definition: libinput.h:738
@ 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:828
@ LIBINPUT_EVENT_GESTURE_PINCH_END
Definition: libinput.h:898
@ LIBINPUT_EVENT_TOUCH_DOWN
Definition: libinput.h:747
@ LIBINPUT_EVENT_SWITCH_TOGGLE
Definition: libinput.h:908
@ LIBINPUT_EVENT_TOUCH_MOTION
Definition: libinput.h:749
@ LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE
Definition: libinput.h:894
@ LIBINPUT_EVENT_TOUCH_CANCEL
Definition: libinput.h:750
@ 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:722
@ LIBINPUT_EVENT_GESTURE_PINCH_UPDATE
Definition: libinput.h:897
@ LIBINPUT_EVENT_GESTURE_PINCH_BEGIN
Definition: libinput.h:896
@ 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:776
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.
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.
int libinput_device_config_dwt_is_available(struct libinput_device *device)
Check if this device supports configurable disable-while-typing feature.
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.
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.
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.
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],...
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.
int libinput_device_config_rotation_is_available(struct libinput_device *device)
Check whether a device can have a custom rotation applied.
uint32_t libinput_device_config_click_get_methods(struct libinput_device *device)
Check which button click methods a device supports.
libinput_config_status
Status codes returned when applying configuration settings.
Definition: libinput.h:4345
enum libinput_config_status libinput_device_config_scroll_set_button_lock(struct libinput_device *device, enum libinput_config_scroll_button_lock_state state)
Set the scroll button lock.
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...
int libinput_device_config_calibration_get_default_matrix(struct libinput_device *device, float matrix[6])
Return the default calibration matrix for this device.
libinput_config_click_method
The click method defines when to generate software-emulated buttons, usually on a device that does no...
Definition: libinput.h:5261
libinput_config_middle_emulation_state
Definition: libinput.h:5357
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.
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.
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.
enum libinput_config_scroll_method libinput_device_config_scroll_get_method(struct libinput_device *device)
Get the scroll method for this device.
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.
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_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:4820
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.
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.
enum libinput_config_scroll_button_lock_state libinput_device_config_scroll_get_default_button_lock(struct libinput_device *device)
Get the default scroll button lock state.
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.
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_config_scroll_method
The scroll method of a device selects when to generate scroll axis events instead of pointer motion e...
Definition: libinput.h:5482
enum libinput_config_click_method libinput_device_config_click_get_method(struct libinput_device *device)
Get the button click method for this device.
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].
int libinput_device_config_left_handed_is_available(struct libinput_device *device)
Check if a device has a configuration that supports left-handed usage.
int libinput_device_config_accel_is_available(struct libinput_device *device)
Check if a device uses libinput-internal pointer-acceleration.
libinput_config_tap_button_map
Definition: libinput.h:4457
const char * libinput_config_status_to_str(enum libinput_config_status status)
Return a string describing the error.
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.
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.
int libinput_device_config_scroll_has_natural_scroll(struct libinput_device *device)
Return non-zero if the device supports "natural scrolling".
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.
enum libinput_config_scroll_method libinput_device_config_scroll_get_default_method(struct libinput_device *device)
Get the default scroll method for this device.
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.
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.
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.
int libinput_device_config_left_handed_get(struct libinput_device *device)
Get the current left-handed configuration of the device.
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.
uint32_t libinput_device_config_send_events_get_modes(struct libinput_device *device)
Return the possible send-event modes for this device.
int libinput_device_config_calibration_get_matrix(struct libinput_device *device, float matrix[6])
Return the current calibration matrix for this device.
int libinput_device_config_left_handed_get_default(struct libinput_device *device)
Get the default left-handed configuration of the device.
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.
int libinput_device_config_scroll_get_default_natural_scroll_enabled(struct libinput_device *device)
Get the default mode for scrolling on this device.
double libinput_device_config_accel_get_speed(struct libinput_device *device)
Get the current pointer acceleration setting for this pointer device.
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.
int libinput_device_config_scroll_get_natural_scroll_enabled(struct libinput_device *device)
Get the current mode for scrolling on this device.
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.
uint32_t libinput_device_config_accel_get_profiles(struct libinput_device *device)
Returns a bitmask of the configurable acceleration modes available on this device.
enum libinput_config_status libinput_device_config_accel_set_profile(struct libinput_device *device, enum libinput_config_accel_profile profile)
Set the pointer acceleration profile of this pointer device to the given mode.
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_config_tap_state
Definition: libinput.h:4367
uint32_t libinput_device_config_scroll_get_methods(struct libinput_device *device)
Check which scroll methods a device supports.
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_config_dwt_state
Possible states for the disable-while-typing feature.
Definition: libinput.h:5760
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.
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_config_accel_profile
Definition: libinput.h:5016
int libinput_device_config_middle_emulation_is_available(struct libinput_device *device)
Check if middle mouse button emulation configuration is available on this device.
int libinput_device_config_calibration_has_matrix(struct libinput_device *device)
Check if the device can be calibrated via a calibration matrix.
libinput_config_drag_state
A config status to distinguish or set dragging on a device.
Definition: libinput.h:4551
enum libinput_config_scroll_button_lock_state libinput_device_config_scroll_get_button_lock(struct libinput_device *device)
Get the current scroll button lock state.
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.
uint32_t libinput_device_config_send_events_get_mode(struct libinput_device *device)
Get the send-event mode for this device.
libinput_config_drag_lock_state
Definition: libinput.h:4626
uint32_t libinput_device_config_send_events_get_default_mode(struct libinput_device *device)
Get the default send-event mode for this device.
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.
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.
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_CONFIG_STATUS_UNSUPPORTED
Configuration not available on this device.
Definition: libinput.h:4347
@ LIBINPUT_CONFIG_STATUS_SUCCESS
Config applied successfully.
Definition: libinput.h:4346
@ LIBINPUT_CONFIG_STATUS_INVALID
Invalid parameter range.
Definition: libinput.h:4349
@ LIBINPUT_CONFIG_CLICK_METHOD_NONE
Do not send software-emulated button events.
Definition: libinput.h:5266
@ LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS
Use software-button areas to generate button events.
Definition: libinput.h:5270
@ LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER
The number of fingers decides which button press to generate.
Definition: libinput.h:5274
@ LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED
Middle mouse button emulation is to be disabled, or is currently disabled.
Definition: libinput.h:5362
@ LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED
Middle mouse button emulation is to be enabled, or is currently enabled.
Definition: libinput.h:5367
@ LIBINPUT_CONFIG_SEND_EVENTS_ENABLED
Send events from this device normally.
Definition: libinput.h:4826
@ LIBINPUT_CONFIG_SEND_EVENTS_DISABLED
Do not send events through this device.
Definition: libinput.h:4840
@ 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:4846
@ LIBINPUT_CONFIG_SCROLL_EDGE
Send scroll events when a finger moves along the bottom or right edge of a device.
Definition: libinput.h:5497
@ 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:5502
@ LIBINPUT_CONFIG_SCROLL_2FG
Send scroll events when two fingers are logically down on the device.
Definition: libinput.h:5492
@ LIBINPUT_CONFIG_SCROLL_NO_SCROLL
Never send scroll events instead of pointer motion events.
Definition: libinput.h:5487
@ LIBINPUT_CONFIG_TAP_MAP_LRM
1/2/3 finger tap maps to left/right/middle
Definition: libinput.h:4459
@ LIBINPUT_CONFIG_TAP_MAP_LMR
1/2/3 finger tap maps to left/middle/right
Definition: libinput.h:4461
@ LIBINPUT_CONFIG_TAP_DISABLED
Tapping is to be disabled, or is currently disabled.
Definition: libinput.h:4368
@ LIBINPUT_CONFIG_TAP_ENABLED
Tapping is to be enabled, or is currently enabled.
Definition: libinput.h:4370
@ LIBINPUT_CONFIG_DWT_DISABLED
Definition: libinput.h:5761
@ LIBINPUT_CONFIG_DWT_ENABLED
Definition: libinput.h:5762
@ LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE
An adaptive acceleration profile.
Definition: libinput.h:5035
@ LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT
A flat acceleration profile.
Definition: libinput.h:5029
@ LIBINPUT_CONFIG_ACCEL_PROFILE_NONE
Placeholder for devices that don't have a configurable pointer acceleration profile.
Definition: libinput.h:5021
@ LIBINPUT_CONFIG_DRAG_ENABLED
Drag is to be enabled, or is currently enabled.
Definition: libinput.h:4561
@ LIBINPUT_CONFIG_DRAG_DISABLED
Drag is to be disabled, or is currently disabled.
Definition: libinput.h:4556
@ LIBINPUT_CONFIG_DRAG_LOCK_ENABLED
Drag lock is to be enabled, or is currently disabled.
Definition: libinput.h:4630
@ LIBINPUT_CONFIG_DRAG_LOCK_DISABLED
Drag lock is to be disabled, or is currently disabled.
Definition: libinput.h:4628
int libinput_device_tablet_pad_has_key(struct libinput_device *device, uint32_t code)
Check if a LIBINPUT_DEVICE_CAP_TABLET_PAD device has a key with the given code (see linux/input-event...
struct libinput_device_group * libinput_device_get_device_group(struct libinput_device *device)
Get the device group this device is assigned to.
const char * libinput_device_get_sysname(struct libinput_device *device)
Get the system name of the device.
struct libinput_seat * libinput_device_get_seat(struct libinput_device *device)
Get the seat associated with this input device.
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_device_capability
Capabilities on a device.
Definition: libinput.h:191
const char * libinput_device_get_name(struct libinput_device *device)
The descriptive device name as advertised by the kernel and/or the hardware itself.
struct libinput_device * libinput_device_ref(struct libinput_device *device)
Increase the refcount of the input device.
libinput_key_state
Logical state of a key.
Definition: libinput.h:207
struct libinput_device_group * libinput_device_group_unref(struct libinput_device_group *group)
Decrease the refcount of the device group.
libinput_led
Mask reflecting LEDs on a device.
Definition: libinput.h:217
libinput_switch
The type of a switch.
Definition: libinput.h:676
libinput_button_state
Logical state of a physical button.
Definition: libinput.h:229
libinput_tablet_tool_proximity_state
The state of proximity for a tool on a device.
Definition: libinput.h:369
void libinput_device_set_user_data(struct libinput_device *device, void *user_data)
Set caller-specific data associated with this input device.
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_switch_state
The state of a switch.
Definition: libinput.h:664
struct libinput_device_group * libinput_device_group_ref(struct libinput_device_group *group)
Increase the refcount of the device group.
libinput_pointer_axis_source
The source for a libinput_pointer_axis event.
Definition: libinput.h:257
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.
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-event-c...
libinput_pointer_axis
Axes on a device with the capability LIBINPUT_DEVICE_CAP_POINTER that are not x or y coordinates.
Definition: libinput.h:246
libinput_tablet_tool_type
Available tool types for a device with the LIBINPUT_DEVICE_CAP_TABLET_TOOL capability.
Definition: libinput.h:339
struct libinput_device * libinput_device_unref(struct libinput_device *device)
Decrease the refcount of the input device.
struct libinput * libinput_device_get_context(struct libinput_device *device)
Get the libinput context from the device.
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...
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.
int libinput_device_has_capability(struct libinput_device *device, enum libinput_device_capability capability)
Check if the given device has the specified capability.
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-event...
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_tablet_tool_tip_state
The tip contact state for a tool on a device.
Definition: libinput.h:385
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.
int libinput_device_touch_get_touch_count(struct libinput_device *device)
Check how many touches a LIBINPUT_DEVICE_CAP_TOUCH device supports simultaneously.
unsigned int libinput_device_get_id_vendor(struct libinput_device *device)
Get the vendor ID for this device.
unsigned int libinput_device_get_id_product(struct libinput_device *device)
Get the product ID for this 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.
void libinput_device_group_set_user_data(struct libinput_device_group *group, void *user_data)
Set caller-specific data associated with this device group.
const char * libinput_device_get_output_name(struct libinput_device *device)
A device may be mapped to a single output, or all available outputs.
void * libinput_device_get_user_data(struct libinput_device *device)
Get the caller-specific data associated with this input device, if any.
void libinput_device_led_update(struct libinput_device *device, enum libinput_led leds)
Update the LEDs on the device, if any.
@ LIBINPUT_DEVICE_CAP_GESTURE
Definition: libinput.h:197
@ LIBINPUT_DEVICE_CAP_POINTER
Definition: libinput.h:193
@ LIBINPUT_DEVICE_CAP_KEYBOARD
Definition: libinput.h:192
@ LIBINPUT_DEVICE_CAP_TABLET_PAD
Definition: libinput.h:196
@ LIBINPUT_DEVICE_CAP_TOUCH
Definition: libinput.h:194
@ LIBINPUT_DEVICE_CAP_TABLET_TOOL
Definition: libinput.h:195
@ LIBINPUT_DEVICE_CAP_SWITCH
Definition: libinput.h:198
@ LIBINPUT_KEY_STATE_PRESSED
Definition: libinput.h:209
@ LIBINPUT_KEY_STATE_RELEASED
Definition: libinput.h:208
@ LIBINPUT_LED_CAPS_LOCK
Definition: libinput.h:219
@ LIBINPUT_LED_SCROLL_LOCK
Definition: libinput.h:220
@ LIBINPUT_LED_NUM_LOCK
Definition: libinput.h:218
@ 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:698
@ 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:682
@ LIBINPUT_BUTTON_STATE_PRESSED
Definition: libinput.h:231
@ LIBINPUT_BUTTON_STATE_RELEASED
Definition: libinput.h:230
@ LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_IN
Definition: libinput.h:371
@ LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_OUT
Definition: libinput.h:370
@ LIBINPUT_SWITCH_STATE_OFF
Definition: libinput.h:665
@ LIBINPUT_SWITCH_STATE_ON
Definition: libinput.h:666
@ LIBINPUT_POINTER_AXIS_SOURCE_CONTINUOUS
The event is caused by the motion of some device.
Definition: libinput.h:270
@ LIBINPUT_POINTER_AXIS_SOURCE_WHEEL
The event is caused by the rotation of a wheel.
Definition: libinput.h:261
@ LIBINPUT_POINTER_AXIS_SOURCE_FINGER
The event is caused by the movement of one or more fingers on a device.
Definition: libinput.h:266
@ LIBINPUT_POINTER_AXIS_SOURCE_WHEEL_TILT
The event is caused by the tilting of a mouse wheel rather than its rotation.
Definition: libinput.h:280
@ LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL
Definition: libinput.h:247
@ LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL
Definition: libinput.h:248
@ LIBINPUT_TABLET_TOOL_TYPE_MOUSE
A mouse bound to the tablet.
Definition: libinput.h:346
@ LIBINPUT_TABLET_TOOL_TYPE_AIRBRUSH
An airbrush-like tool.
Definition: libinput.h:345
@ LIBINPUT_TABLET_TOOL_TYPE_TOTEM
A rotary device with positional and rotation data.
Definition: libinput.h:348
@ LIBINPUT_TABLET_TOOL_TYPE_LENS
A mouse tool with a lens.
Definition: libinput.h:347
@ LIBINPUT_TABLET_TOOL_TYPE_ERASER
Eraser.
Definition: libinput.h:341
@ LIBINPUT_TABLET_TOOL_TYPE_PEN
A generic pen.
Definition: libinput.h:340
@ LIBINPUT_TABLET_TOOL_TYPE_BRUSH
A paintbrush-like tool.
Definition: libinput.h:342
@ LIBINPUT_TABLET_TOOL_TYPE_PENCIL
Physical drawing tool, e.g.
Definition: libinput.h:343
@ LIBINPUT_TABLET_TOOL_TIP_DOWN
Definition: libinput.h:387
@ LIBINPUT_TABLET_TOOL_TIP_UP
Definition: libinput.h:386
uint64_t libinput_event_gesture_get_time_usec(struct libinput_event_gesture *event)
double libinput_event_gesture_get_dx(struct libinput_event_gesture *event)
Return the delta between the last event and the current event.
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.
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...
uint32_t libinput_event_gesture_get_time(struct libinput_event_gesture *event)
int libinput_event_gesture_get_cancelled(struct libinput_event_gesture *event)
Return if the gesture ended normally, or if it was cancelled.
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.
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...
struct libinput_event * libinput_event_gesture_get_base_event(struct libinput_event_gesture *event)
double libinput_event_gesture_get_dy(struct libinput_event_gesture *event)
Return the delta between the last event and the current event.
int libinput_event_gesture_get_finger_count(struct libinput_event_gesture *event)
Return the number of fingers used for a gesture.
uint32_t libinput_event_keyboard_get_time(struct libinput_event_keyboard *event)
uint64_t libinput_event_keyboard_get_time_usec(struct libinput_event_keyboard *event)
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...
uint32_t libinput_event_keyboard_get_key(struct libinput_event_keyboard *event)
struct libinput_event * libinput_event_keyboard_get_base_event(struct libinput_event_keyboard *event)
enum libinput_key_state libinput_event_keyboard_get_key_state(struct libinput_event_keyboard *event)
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...
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.
enum libinput_pointer_axis_source libinput_event_pointer_get_axis_source(struct libinput_event_pointer *event)
Return the source for a given axis event.
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.
double libinput_event_pointer_get_dx(struct libinput_event_pointer *event)
Return the delta between the last event and the current event.
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.
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.
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 ...
enum libinput_button_state libinput_event_pointer_get_button_state(struct libinput_event_pointer *event)
Return the button state that triggered this event.
struct libinput_event * libinput_event_pointer_get_base_event(struct libinput_event_pointer *event)
uint32_t libinput_event_pointer_get_button(struct libinput_event_pointer *event)
Return the button that triggered this event.
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.
double libinput_event_pointer_get_dy(struct libinput_event_pointer *event)
Return the delta between the last event and the current event.
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.
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 ...
uint32_t libinput_event_pointer_get_time(struct libinput_event_pointer *event)
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.
uint64_t libinput_event_pointer_get_time_usec(struct libinput_event_pointer *event)
enum libinput_switch libinput_event_switch_get_switch(struct libinput_event_switch *event)
Return the switch that triggered this event.
uint64_t libinput_event_switch_get_time_usec(struct libinput_event_switch *event)
uint32_t libinput_event_switch_get_time(struct libinput_event_switch *event)
struct libinput_event * libinput_event_switch_get_base_event(struct libinput_event_switch *event)
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_pad_strip_axis_source
The source for a LIBINPUT_EVENT_TABLET_PAD_STRIP event.
Definition: libinput.h:308
uint32_t libinput_event_tablet_pad_get_time(struct libinput_event_tablet_pad *event)
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.
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.
struct libinput_event * libinput_event_tablet_pad_get_base_event(struct libinput_event_tablet_pad *event)
uint32_t libinput_event_tablet_pad_get_key(struct libinput_event_tablet_pad *event)
Return the key code that triggered this event, e.g.
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.
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...
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...
uint64_t libinput_event_tablet_pad_get_time_usec(struct libinput_event_tablet_pad *event)
enum libinput_button_state libinput_event_tablet_pad_get_button_state(struct libinput_event_tablet_pad *event)
Return the button state of the event.
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.
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.
enum libinput_key_state libinput_event_tablet_pad_get_key_state(struct libinput_event_tablet_pad *event)
Return the key state of the event.
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.
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_tablet_pad_ring_axis_source
The source for a LIBINPUT_EVENT_TABLET_PAD_RING event.
Definition: libinput.h:291
@ LIBINPUT_TABLET_PAD_STRIP_SOURCE_UNKNOWN
Definition: libinput.h:309
@ LIBINPUT_TABLET_PAD_STRIP_SOURCE_FINGER
The event is caused by the movement of one or more fingers on the strip.
Definition: libinput.h:314
@ LIBINPUT_TABLET_PAD_RING_SOURCE_UNKNOWN
Definition: libinput.h:292
@ LIBINPUT_TABLET_PAD_RING_SOURCE_FINGER
The event is caused by the movement of one or more fingers on the ring.
Definition: libinput.h:297
double libinput_event_tablet_tool_get_wheel_delta(struct libinput_event_tablet_tool *event)
Return the delta for the wheel in degrees.
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.
struct libinput_tablet_tool * libinput_tablet_tool_unref(struct libinput_tablet_tool *tool)
Decrement the reference count of the tool by one.
enum libinput_button_state libinput_event_tablet_tool_get_button_state(struct libinput_event_tablet_tool *event)
Return the button state of the event.
int libinput_event_tablet_tool_distance_has_changed(struct libinput_event_tablet_tool *event)
Check if the distance axis was updated in this event.
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.
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's current logical orientation,...
double libinput_event_tablet_tool_get_size_minor(struct libinput_event_tablet_tool *event)
Returns the current size in mm along the minor axis of the touching ellipse.
int libinput_event_tablet_tool_y_has_changed(struct libinput_event_tablet_tool *event)
Check if the y axis was updated in this event.
int libinput_event_tablet_tool_pressure_has_changed(struct libinput_event_tablet_tool *event)
Check if the pressure axis was updated in this event.
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,...
struct libinput_tablet_tool * libinput_tablet_tool_ref(struct libinput_tablet_tool *tool)
Increment the reference count of the tool by one.
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.
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.
int libinput_event_tablet_tool_slider_has_changed(struct libinput_event_tablet_tool *event)
Check if the slider axis was updated in this event.
uint64_t libinput_tablet_tool_get_tool_id(struct libinput_tablet_tool *tool)
Return the tool ID for a tool object.
int libinput_event_tablet_tool_x_has_changed(struct libinput_event_tablet_tool *event)
Check if the x axis was updated in this event.
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's current logical orientation,...
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.
int libinput_tablet_tool_has_distance(struct libinput_tablet_tool *tool)
Return whether the tablet tool supports distance.
double libinput_event_tablet_tool_get_size_major(struct libinput_event_tablet_tool *event)
Returns the current size in mm along the major axis of the touching ellipse.
double libinput_event_tablet_tool_get_dy(struct libinput_event_tablet_tool *event)
Return the delta between the last event and the current event.
uint64_t libinput_event_tablet_tool_get_time_usec(struct libinput_event_tablet_tool *event)
double libinput_event_tablet_tool_get_dx(struct libinput_event_tablet_tool *event)
Return the delta between the last event and the current event.
enum libinput_tablet_tool_type libinput_tablet_tool_get_type(struct libinput_tablet_tool *tool)
Return the high-level tool type for a tool object.
struct libinput_event * libinput_event_tablet_tool_get_base_event(struct libinput_event_tablet_tool *event)
int libinput_event_tablet_tool_size_minor_has_changed(struct libinput_event_tablet_tool *event)
Check if the size minor axis was updated in this event.
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 press...
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.
int libinput_tablet_tool_has_pressure(struct libinput_tablet_tool *tool)
Return whether the tablet tool supports pressure.
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.
int libinput_tablet_tool_has_rotation(struct libinput_tablet_tool *tool)
Return whether the tablet tool supports z-rotation.
int libinput_event_tablet_tool_size_major_has_changed(struct libinput_event_tablet_tool *event)
Check if the size major axis was updated in this event.
double libinput_event_tablet_tool_get_distance(struct libinput_event_tablet_tool *event)
Returns the current distance from the tablet's sensor, normalized to the range [0,...
int libinput_tablet_tool_has_size(struct libinput_tablet_tool *tool)
Return whether the tablet tool has a ellipsis major and minor.
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...
uint32_t libinput_event_tablet_tool_get_time(struct libinput_event_tablet_tool *event)
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...
int libinput_event_tablet_tool_wheel_has_changed(struct libinput_event_tablet_tool *event)
Check if the wheel axis was updated in this event.
int libinput_tablet_tool_has_tilt(struct libinput_tablet_tool *tool)
Return whether the tablet tool supports tilt.
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).
uint64_t libinput_tablet_tool_get_serial(struct libinput_tablet_tool *tool)
Return the serial number of a tool.
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.
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.
int libinput_tablet_tool_has_wheel(struct libinput_tablet_tool *tool)
Return whether the tablet tool has a relative wheel.
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.
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,...
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.
void * libinput_tablet_tool_get_user_data(struct libinput_tablet_tool *tool)
Return the user data associated with a tool object.
int libinput_tablet_tool_has_slider(struct libinput_tablet_tool *tool)
Return whether the tablet tool has a slider axis.
uint32_t libinput_event_tablet_tool_get_button(struct libinput_event_tablet_tool *event)
Return the button that triggered this event.
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's logical neutral posi...
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...
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.
uint32_t libinput_event_touch_get_time(struct libinput_event_touch *event)
uint64_t libinput_event_touch_get_time_usec(struct libinput_event_touch *event)
int32_t libinput_event_touch_get_seat_slot(struct libinput_event_touch *event)
Get the seat slot of the touch event.
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...
struct libinput_event * libinput_event_touch_get_base_event(struct libinput_event_touch *event)
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.
int32_t libinput_event_touch_get_slot(struct libinput_event_touch *event)
Get the slot of this touch event.
struct libinput_event * libinput_event_device_notify_get_base_event(struct libinput_event_device_notify *event)
void libinput_event_destroy(struct libinput_event *event)
Destroy the event, freeing all associated resources.
struct libinput * libinput_event_get_context(struct libinput_event *event)
Get the libinput context from the 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.
enum libinput_event_type libinput_event_get_type(struct libinput_event *event)
Get the type of the event.
struct libinput_event_pointer * libinput_event_get_pointer_event(struct libinput_event *event)
Return the pointer event that is this input event.
struct libinput_event_keyboard * libinput_event_get_keyboard_event(struct libinput_event *event)
Return the keyboard event that is this input event.
struct libinput_device * libinput_event_get_device(struct libinput_event *event)
Return the device associated with this event.
struct libinput_event_touch * libinput_event_get_touch_event(struct libinput_event *event)
Return the touch event that is this input event.
struct libinput_event_switch * libinput_event_get_switch_event(struct libinput_event *event)
Return the switch event that is this input 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.
struct libinput_event_gesture * libinput_event_get_gesture_event(struct libinput_event *event)
Return the gesture event that is this input 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.
struct libinput_seat * libinput_seat_ref(struct libinput_seat *seat)
Increase the refcount of the seat.
const char * libinput_seat_get_logical_name(struct libinput_seat *seat)
Return the logical name of the seat.
struct libinput * libinput_seat_get_context(struct libinput_seat *seat)
Get the libinput context from the seat.
void libinput_seat_set_user_data(struct libinput_seat *seat, void *user_data)
Set caller-specific data associated with this seat.
struct libinput_seat * libinput_seat_unref(struct libinput_seat *seat)
Decrease the refcount of the seat.
void * libinput_seat_get_user_data(struct libinput_seat *seat)
Get the caller-specific data associated with this seat, if any.
const char * libinput_seat_get_physical_name(struct libinput_seat *seat)
Return the physical name of the seat.
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.
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.
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.
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.
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.
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 ...
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.
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.
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.
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.
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().
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.
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...
#define LIBINPUT_ATTRIBUTE_PRINTF(_format, _args)
Definition: libinput.h:37
libinput_config_scroll_button_lock_state
Definition: libinput.h:5680
@ LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_ENABLED
Definition: libinput.h:5682
@ LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_DISABLED
Definition: libinput.h:5681
A base handle for accessing libinput device groups.
Definition: libinput.h:57
A base handle for accessing libinput devices.
Definition: libinput.h:48
An event notifying the caller of a device being added or removed.
Definition: libinput.h:108
A keyboard event representing a key press/release.
Definition: libinput.h:116
A pointer event representing relative or absolute pointer movement, a button press/release or scroll ...
Definition: libinput.h:124
A switch event representing a changed state in a switch.
Tablet pad event representing a button press, or ring/strip update on the tablet pad itself.
Definition: libinput.h:159
Tablet tool event representing an axis update, button press, or tool update.
Definition: libinput.h:145
Touch event representing a touch down, move or up, as well as a touch cancel and touch frame events.
Definition: libinput.h:133
The base event type.
Definition: libinput.h:96
libinput does not open file descriptors to devices directly, instead open_restricted() and close_rest...
Definition: libinput.h:3309
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:3321
void(* close_restricted)(int fd, void *user_data)
Close the file descriptor.
Definition: libinput.h:3329
The base handle for accessing libinput seats.
Definition: libinput.h:67
A mode on a tablet pad is a virtual grouping of functionality, usually based on some visual feedback ...
An object representing a tool being used by a device with the LIBINPUT_DEVICE_CAP_TABLET_TOOL capabil...
Definition: libinput.h:76
A handle for accessing libinput.