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 <libudev.h>
35 
36 #define LIBINPUT_ATTRIBUTE_PRINTF(_format, _args) \
37  __attribute__ ((format (printf, _format, _args)))
38 #define LIBINPUT_ATTRIBUTE_DEPRECATED __attribute__ ((deprecated))
39 
47 struct libinput;
48 
57 
67 
76 
93 
105 
113 
121 
130 
142 
154 
165 
175 };
176 
190 };
191 
201 };
202 
212 };
213 
223 };
224 
240 };
241 
262 };
263 
277 };
278 
292 };
293 
323 };
324 
342 };
343 
356 };
357 
384 
398 int
400 
423  unsigned int index);
424 
435 unsigned int
437 
453 unsigned int
455 
473 unsigned int
475 
486 int
488  unsigned int button);
489 
500 int
502  unsigned int ring);
503 
514 int
516  unsigned int strip);
517 
534 int
536  unsigned int button);
537 
549  struct libinput_tablet_pad_mode_group *group);
550 
562  struct libinput_tablet_pad_mode_group *group);
563 
576 void
578  struct libinput_tablet_pad_mode_group *group,
579  void *user_data);
580 
590 void *
592  struct libinput_tablet_pad_mode_group *group);
593 
606 
616 
622 
624 
629 
639 
722 
736 
742 
749 };
750 
767 void
769 
779 
788 struct libinput *
790 
804 struct libinput_device *
806 
817 struct libinput_event_pointer *
819 
832 
843 struct libinput_event_touch *
845 
856 struct libinput_event_gesture *
858 
871 
884 
898 
904 struct libinput_event *
906 
919 uint32_t
921 
927 uint64_t
929 
935 uint32_t
937 
945 
951 struct libinput_event *
953 
966 uint32_t
968  struct libinput_event_keyboard *event);
969 
982 uint32_t
984 
990 uint64_t
992 
1011 double
1013 
1032 double
1034 
1056 double
1058  struct libinput_event_pointer *event);
1059 
1081 double
1083  struct libinput_event_pointer *event);
1084 
1100 double
1102 
1118 double
1120 
1138 double
1140  struct libinput_event_pointer *event,
1141  uint32_t width);
1142 
1160 double
1162  struct libinput_event_pointer *event,
1163  uint32_t height);
1164 
1177 uint32_t
1179 
1194 
1208 uint32_t
1210  struct libinput_event_pointer *event);
1211 
1229 int
1231  enum libinput_pointer_axis axis);
1232 
1257 double
1259  enum libinput_pointer_axis axis);
1260 
1298 
1315 double
1317  enum libinput_pointer_axis axis);
1318 
1324 struct libinput_event *
1326 
1338 uint32_t
1340 
1346 uint64_t
1348 
1368 int32_t
1370 
1390 int32_t
1392 
1410 double
1412 
1430 double
1432 
1450 double
1452  uint32_t width);
1453 
1471 double
1473  uint32_t height);
1474 
1480 struct libinput_event *
1482 
1502 uint32_t
1503 libinput_event_gesture_get_time(struct libinput_event_gesture *event);
1504 
1510 uint64_t
1511 libinput_event_gesture_get_time_usec(struct libinput_event_gesture *event);
1512 
1518 struct libinput_event *
1519 libinput_event_gesture_get_base_event(struct libinput_event_gesture *event);
1520 
1532 int
1533 libinput_event_gesture_get_finger_count(struct libinput_event_gesture *event);
1534 
1549 int
1550 libinput_event_gesture_get_cancelled(struct libinput_event_gesture *event);
1551 
1567 double
1568 libinput_event_gesture_get_dx(struct libinput_event_gesture *event);
1569 
1585 double
1586 libinput_event_gesture_get_dy(struct libinput_event_gesture *event);
1587 
1606 double
1608  struct libinput_event_gesture *event);
1609 
1628 double
1630  struct libinput_event_gesture *event);
1631 
1658 double
1659 libinput_event_gesture_get_scale(struct libinput_event_gesture *event);
1660 
1682 double
1683 libinput_event_gesture_get_angle_delta(struct libinput_event_gesture *event);
1684 
1707 struct libinput_event *
1709 
1727 int
1729  struct libinput_event_tablet_tool *event);
1730 
1748 int
1750  struct libinput_event_tablet_tool *event);
1751 
1769 int
1771  struct libinput_event_tablet_tool *event);
1772 
1792 int
1794  struct libinput_event_tablet_tool *event);
1795 
1813 int
1815  struct libinput_event_tablet_tool *event);
1816 
1834 int
1836  struct libinput_event_tablet_tool *event);
1854 int
1856  struct libinput_event_tablet_tool *event);
1874 int
1876  struct libinput_event_tablet_tool *event);
1894 int
1896  struct libinput_event_tablet_tool *event);
1897 
1912 double
1914 
1929 double
1931 
1946 double
1948 
1963 double
1965 
1977 double
1979 
1991 double
1993 
2009 double
2011 
2027 double
2029 
2047 double
2049 
2063 double
2065 
2076 double
2078  struct libinput_event_tablet_tool *event);
2079 
2090 int
2092  struct libinput_event_tablet_tool *event);
2093 
2111 double
2113  uint32_t width);
2114 
2132 double
2134  uint32_t height);
2135 
2156 struct libinput_tablet_tool *
2158 
2173 
2187 
2200 uint32_t
2202 
2216 
2230 uint32_t
2232 
2239 uint32_t
2241 
2248 uint64_t
2250 
2264 
2281 uint64_t
2283 
2295 struct libinput_tablet_tool *
2297 
2310 struct libinput_tablet_tool *
2312 
2321 int
2323 
2332 int
2334 
2343 int
2345 
2354 int
2356 
2365 int
2367 
2376 int
2378 
2390 int
2392  uint32_t code);
2393 
2408 int
2410 
2423 uint64_t
2425 
2436 void *
2438 
2447 void
2449  void *user_data);
2450 
2463 struct libinput_event *
2465 
2486 double
2488 
2503 unsigned int
2505 
2522 
2543 double
2545 
2560 unsigned int
2562 
2579 
2598 uint32_t
2600 
2615 
2644 unsigned int
2646 
2667 
2674 uint32_t
2676 
2683 uint64_t
2685 
2713  int (*open_restricted)(const char *path, int flags, void *user_data);
2721  void (*close_restricted)(int fd, void *user_data);
2722 };
2723 
2737 struct libinput *
2738 libinput_udev_create_context(const struct libinput_interface *interface,
2739  void *user_data,
2740  struct udev *udev);
2741 
2763 int
2765  const char *seat_id);
2766 
2786 struct libinput *
2787 libinput_path_create_context(const struct libinput_interface *interface,
2788  void *user_data);
2789 
2810 struct libinput_device *
2812  const char *path);
2813 
2832 void
2834 
2843 int
2845 
2863 int
2865 
2877 struct libinput_event *
2879 
2893 
2905 void
2907  void *user_data);
2908 
2918 void *
2920 
2932 int
2934 
2944 void
2946 
2956 struct libinput *
2957 libinput_ref(struct libinput *libinput);
2958 
2989 struct libinput *
2991 
3007 void
3009  enum libinput_log_priority priority);
3010 
3027 
3042 typedef void (*libinput_log_handler)(struct libinput *libinput,
3043  enum libinput_log_priority priority,
3044  const char *format, va_list args)
3046 
3062 void
3063 libinput_log_set_handler(struct libinput *libinput,
3064  libinput_log_handler log_handler);
3065 
3086 struct libinput_seat *
3087 libinput_seat_ref(struct libinput_seat *seat);
3088 
3100 struct libinput_seat *
3101 libinput_seat_unref(struct libinput_seat *seat);
3102 
3114 void
3115 libinput_seat_set_user_data(struct libinput_seat *seat, void *user_data);
3116 
3126 void *
3128 
3137 struct libinput *
3139 
3156 const char *
3158 
3168 const char *
3170 
3186 struct libinput_device *
3187 libinput_device_ref(struct libinput_device *device);
3188 
3200 struct libinput_device *
3201 libinput_device_unref(struct libinput_device *device);
3202 
3214 void
3215 libinput_device_set_user_data(struct libinput_device *device, void *user_data);
3216 
3226 void *
3228 
3237 struct libinput *
3239 
3300 struct libinput_device_group *
3302 
3314 const char *
3316 
3330 const char *
3332 
3341 unsigned int
3343 
3352 unsigned int
3354 
3366 const char *
3368 
3388 struct libinput_seat *
3390 
3416 int
3418  const char *name);
3419 
3439 struct udev_device *
3441 
3452 void
3454  enum libinput_led leds);
3455 
3463 int
3465  enum libinput_device_capability capability);
3466 
3481 int
3483  double *width,
3484  double *height);
3485 
3498 int
3499 libinput_device_pointer_has_button(struct libinput_device *device, uint32_t code);
3500 
3513 int
3515  uint32_t code);
3516 
3529 int
3531 
3544 int
3546 
3559 int
3561 
3574 struct libinput_device_group *
3576 
3590 struct libinput_device_group *
3592 
3604 void
3606  void *user_data);
3607 
3618 void *
3620 
3672 };
3673 
3683 const char *
3685 
3694 };
3695 
3711 int
3713 
3736  enum libinput_config_tap_state enable);
3737 
3756 
3773 
3792 };
3793 
3811  enum libinput_config_drag_state enable);
3812 
3828 
3846 
3855 };
3856 
3881  enum libinput_config_drag_lock_state enable);
3882 
3902 
3925 
3938 int
3940 
3992  const float matrix[6]);
3993 
4010 int
4012  float matrix[6]);
4013 
4033 int
4035  float matrix[6]);
4036 
4070 };
4071 
4086 uint32_t
4088 
4119  uint32_t mode);
4120 
4140 uint32_t
4142 
4156 uint32_t
4158 
4168 int
4170 
4189  double speed);
4190 
4202 double
4204 
4215 double
4217 
4235 
4241 };
4242 
4253 uint32_t
4255 
4269  enum libinput_config_accel_profile mode);
4270 
4282 
4294 
4324 int
4326 
4343  int enable);
4357 int
4359 
4373 int
4375 
4389 int
4391 
4417  int left_handed);
4418 
4432 int
4434 
4448 int
4450 
4473 };
4474 
4490 uint32_t
4492 
4515  enum libinput_config_click_method method);
4533 
4551 
4566 };
4567 
4588 int
4590  struct libinput_device *device);
4591 
4628  struct libinput_device *device,
4630 
4653  struct libinput_device *device);
4654 
4678  struct libinput_device *device);
4679 
4707 };
4708 
4726 uint32_t
4728 
4755  enum libinput_config_scroll_method method);
4756 
4775 
4794 
4832  uint32_t button);
4833 
4858 uint32_t
4860 
4881 uint32_t
4883 
4893 };
4894 
4910 int
4912 
4936  enum libinput_config_dwt_state enable);
4937 
4955 
4973 
4986 int
4988 
5021  unsigned int degrees_cw);
5022 
5037 unsigned int
5039 
5054 unsigned int
5056 
5057 #ifdef __cplusplus
5058 }
5059 #endif
5060 #endif /* LIBINPUT_H */
Definition: libinput.h:746
libinput_config_dwt_state
Possible states for the disable-while-typing feature.
Definition: libinput.h:4890
const char * libinput_seat_get_physical_name(struct libinput_seat *seat)
Return the physical name of the seat.
struct libinput_event * libinput_event_tablet_pad_get_base_event(struct libinput_event_tablet_pad *event)
Middle mouse button emulation is to be disabled, or is currently disabled.
Definition: libinput.h:4560
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.
A base handle for accessing libinput devices.
Definition: libinput.h:47
Never send scroll events instead of pointer motion events.
Definition: libinput.h:4691
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.
uint32_t libinput_device_config_accel_get_profiles(struct libinput_device *device)
Returns a bitmask of the configurable acceleration modes available on this device.
Signals that a tool has come in or out of proximity of a device with the LIBINPUT_DEVICE_CAP_TABLET_T...
Definition: libinput.h:682
int libinput_event_tablet_tool_pressure_has_changed(struct libinput_event_tablet_tool *event)
Check if the pressure axis was updated in this event.
uint32_t libinput_event_tablet_tool_get_time(struct libinput_event_tablet_tool *event)
An airbrush-like tool.
Definition: libinput.h:320
unsigned int libinput_device_get_id_product(struct libinput_device *device)
Get the product ID for this device.
Definition: libinput.h:186
libinput_config_accel_profile
Definition: libinput.h:4221
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...
uint32_t libinput_event_pointer_get_button(struct libinput_event_pointer *event)
Return the button that triggered this event.
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-...
Definition: libinput.h:632
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_dispatch(struct libinput *libinput)
Main event dispatchment function.
struct libinput * libinput_ref(struct libinput *libinput)
Add a reference to the context.
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.
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...
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 does not open file descriptors to devices directly, instead open_restricted() and close_rest...
Definition: libinput.h:2701
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.
Definition: libinput.h:188
Definition: libinput.h:172
The number of fingers decides which button press to generate.
Definition: libinput.h:4472
Definition: libinput.h:628
Drag is to be enabled, or is currently enabled.
Definition: libinput.h:3791
Definition: libinput.h:222
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].
int libinput_device_config_rotation_is_available(struct libinput_device *device)
Check whether a device can have a custom rotation applied.
libinput_led
Mask reflecting LEDs on a device.
Definition: libinput.h:208
libinput_pointer_axis_source
The source for a libinput_pointer_axis event.
Definition: libinput.h:248
Touch event representing a touch down, move or up, as well as a touch cancel and touch frame events...
Definition: libinput.h:129
struct libinput_event * libinput_event_gesture_get_base_event(struct libinput_event_gesture *event)
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...
Definition: libinput.h:630
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...
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...
int32_t libinput_event_touch_get_slot(struct libinput_event_touch *event)
Get the slot of this touch event.
void * libinput_device_get_user_data(struct libinput_device *device)
Get the caller-specific data associated with this input device, if any.
struct libinput_seat * libinput_seat_ref(struct libinput_seat *seat)
Increase the refcount of the seat.
Definition: libinput.h:239
libinput_tablet_tool_type
Available tool types for a device with the LIBINPUT_DEVICE_CAP_TABLET_TOOL capability.
Definition: libinput.h:314
Signals the end of a set of touchpoints at one device sample time.
Definition: libinput.h:638
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_get_wheel_delta_discrete(struct libinput_event_tablet_tool *event)
Return the delta for the wheel in discrete steps (e.g.
uint64_t libinput_event_keyboard_get_time_usec(struct libinput_event_keyboard *event)
Config applied successfully.
Definition: libinput.h:3668
int libinput_tablet_tool_has_pressure(struct libinput_tablet_tool *tool)
Return whether the tablet tool supports pressure.
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.
const char * libinput_device_get_name(struct libinput_device *device)
The descriptive device name as advertised by the kernel and/or the hardware itself.
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_event_tablet_tool_rotation_has_changed(struct libinput_event_tablet_tool *event)
Check if the z-rotation axis was updated in this event.
Definition: libinput.h:211
Use software-button areas (see Clickfinger behavior) to generate button events.
Definition: libinput.h:4468
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_tablet_pad_get_button_number(struct libinput_event_tablet_pad *event)
Return the button number that triggered this event, starting at 0.
struct libinput_tablet_tool * libinput_tablet_tool_unref(struct libinput_tablet_tool *tool)
Decrement the reference count of the tool by one.
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...
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.
double libinput_event_tablet_tool_get_dy(struct libinput_event_tablet_tool *event)
Return the delta between the last event and the current event.
void * libinput_seat_get_user_data(struct libinput_seat *seat)
Get the caller-specific data associated with this seat, if any.
The event is caused by the movement of one or more fingers on a device.
Definition: libinput.h:257
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
A config status to distinguish or set dragging on a device.
Definition: libinput.h:3781
Tapping is to be enabled, or is currently enabled.
Definition: libinput.h:3692
uint64_t libinput_tablet_tool_get_serial(struct libinput_tablet_tool *tool)
Return the serial number of a tool.
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.
int libinput_event_gesture_get_finger_count(struct libinput_event_gesture *event)
Return the number of fingers used for a gesture.
struct libinput_event * libinput_event_device_notify_get_base_event(struct libinput_event_device_notify *event)
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_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.
Do not send software-emulated button events.
Definition: libinput.h:4463
int libinput_event_tablet_tool_x_has_changed(struct libinput_event_tablet_tool *event)
Check if the x axis was updated in this event.
Definition: libinput.h:623
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...
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:3042
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_slider_position(struct libinput_event_tablet_tool *event)
Returns the current position of the slider on the tool, normalized to the range [-1, 1].
Definition: libinput.h:747
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...
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_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...
Signals that a device has been added to the context.
Definition: libinput.h:615
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.
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.
Configuration not available on this device.
Definition: libinput.h:3669
void(* close_restricted)(int fd, void *user_data)
Close the file descriptor.
Definition: libinput.h:2721
libinput_tablet_tool_proximity_state
The state of proximity for a tool on a device.
Definition: libinput.h:339
Definition: libinput.h:625
double libinput_event_pointer_get_dy(struct libinput_event_pointer *event)
Return the delta between the last event and the current event.
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.
A flat acceleration profile.
Definition: libinput.h:4234
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.
uint32_t libinput_event_gesture_get_time(struct libinput_event_gesture *event)
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...
Signals that a device has been removed.
Definition: libinput.h:621
int libinput_device_config_calibration_get_default_matrix(struct libinput_device *device, float matrix[6])
Return the default calibration matrix for this device.
void libinput_log_set_priority(struct libinput *libinput, enum libinput_log_priority priority)
Set the log priority for the libinput context.
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_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_button_state libinput_event_tablet_tool_get_button_state(struct libinput_event_tablet_tool *event)
Return the button state of the event.
Definition: libinput.h:748
Definition: libinput.h:173
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:4043
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
Logical state of a physical button.
Definition: libinput.h:220
const char * libinput_config_status_to_str(enum libinput_config_status status)
Return a string describing the error.
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.
int libinput_event_tablet_tool_wheel_has_changed(struct libinput_event_tablet_tool *event)
Check if the wheel axis was updated in this event.
struct libinput_device * libinput_device_ref(struct libinput_device *device)
Increase the refcount of the input device.
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...
Send scroll events when two fingers are logically down on the device.
Definition: libinput.h:4696
uint32_t libinput_event_touch_get_time(struct libinput_event_touch *event)
A pointer event representing relative or absolute pointer movement, a button press/release or scroll ...
Definition: libinput.h:120
double libinput_device_config_accel_get_speed(struct libinput_device *device)
Get the current pointer acceleration setting for this pointer device.
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...
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.
Signals that a tool has come in contact with the surface of a device with the LIBINPUT_DEVICE_CAP_TAB...
Definition: libinput.h:705
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...
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.
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...
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
The tip contact state for a tool on a device.
Definition: libinput.h:353
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.
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.
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.
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.
Definition: libinput.h:627
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.
enum libinput_key_state libinput_event_keyboard_get_key_state(struct libinput_event_keyboard *event)
int libinput_device_config_left_handed_is_available(struct libinput_device *device)
Check if a device has a configuration that supports left-handed usage.
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_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 ...
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
Axes on a device with the capability LIBINPUT_DEVICE_CAP_POINTER that are not x or y coordinates...
Definition: libinput.h:237
void libinput_device_group_set_user_data(struct libinput_device_group *group, void *user_data)
Set caller-specific data associated with this device group.
int libinput_device_config_calibration_has_matrix(struct libinput_device *device)
Check if the device can be calibrated via a calibration matrix.
int libinput_device_config_dwt_is_available(struct libinput_device *device)
Check if this device supports configurable disable-while-typing feature.
libinput_config_tap_state
Definition: libinput.h:3689
A mouse tool with a lens.
Definition: libinput.h:322
Definition: libinput.h:184
void libinput_set_user_data(struct libinput *libinput, void *user_data)
Set caller-specific data associated with this context.
Eraser.
Definition: libinput.h:316
An object representing a tool being used by a device with the LIBINPUT_DEVICE_CAP_TABLET_TOOL capabil...
Definition: libinput.h:75
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...
A generic pen.
Definition: libinput.h:315
Middle mouse button emulation is to be enabled, or is currently enabled.
Definition: libinput.h:4565
enum libinput_button_state libinput_event_tablet_pad_get_button_state(struct libinput_event_tablet_pad *event)
Return the button state of the event.
A mode on a tablet pad is a virtual grouping of functionality, usually based on some visual feedback ...
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_pointer_axis_source libinput_event_pointer_get_axis_source(struct libinput_event_pointer *event)
Return the source for a given axis event.
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_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...
Definition: libinput.h:199
libinput_device_capability
Capabilities on a device.
Definition: libinput.h:183
The event is caused by the rotation of a wheel.
Definition: libinput.h:252
Definition: libinput.h:631
libinput_config_status
Status codes returned when applying configuration settings.
Definition: libinput.h:3667
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_event_tablet_tool_tilt_y_has_changed(struct libinput_event_tablet_tool *event)
Check if the tilt y axis was updated in this event.
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.
Definition: libinput.h:200
libinput_tablet_pad_ring_axis_source
The source for a LIBINPUT_EVENT_TABLET_PAD_RING event.
Definition: libinput.h:270
Definition: libinput.h:744
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...
struct libinput_event * libinput_event_tablet_tool_get_base_event(struct libinput_event_tablet_tool *event)
int libinput_device_config_middle_emulation_is_available(struct libinput_device *device)
Check if middle mouse button emulation configuration is available on this device. ...
enum libinput_config_scroll_method libinput_device_config_scroll_get_method(struct libinput_device *device)
Get the scroll method for this device.
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.
double libinput_event_tablet_tool_get_wheel_delta(struct libinput_event_tablet_tool *event)
Return the delta for the wheel in degrees.
int32_t libinput_event_touch_get_seat_slot(struct libinput_event_touch *event)
Get the seat slot of the touch 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.
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 ...
Definition: libinput.h:174
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 ...
uint32_t libinput_device_config_send_events_get_mode(struct libinput_device *device)
Get the send-event mode for this device.
int libinput_event_gesture_get_cancelled(struct libinput_event_gesture *event)
Return if the gesture ended normally, or if it was cancelled.
void libinput_device_led_update(struct libinput_device *device, enum libinput_led leds)
Update the LEDs on the device, if any.
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.
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().
Tablet tool event representing an axis update, button press, or tool update.
Definition: libinput.h:141
uint64_t libinput_event_tablet_tool_get_time_usec(struct libinput_event_tablet_tool *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...
double libinput_event_gesture_get_dy(struct libinput_event_gesture *event)
Return the delta between the last event and the current 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.
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.
struct libinput * libinput_event_get_context(struct libinput_event *event)
Get the libinput context from the event.
Drag lock is to be enabled, or is currently disabled.
Definition: libinput.h:3854
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.
enum libinput_config_click_method libinput_device_config_click_get_method(struct libinput_device *device)
Get the button click method for this device.
Definition: libinput.h:187
Definition: libinput.h:633
struct libinput_event_gesture * libinput_event_get_gesture_event(struct libinput_event *event)
Return the gesture event that is this input event.
The base event type.
Definition: libinput.h:92
#define LIBINPUT_ATTRIBUTE_PRINTF(_format, _args)
Definition: libinput.h:36
libinput_config_click_method
The click method defines when to generate software-emulated buttons, usually on a device that does no...
Definition: libinput.h:4458
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.
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.
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.
A base handle for accessing libinput device groups.
Definition: libinput.h:56
int libinput_device_config_left_handed_get_default(struct libinput_device *device)
Get the default left-handed configuration of the device.
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...
A paintbrush-like tool.
Definition: libinput.h:317
A button pressed on a device with the LIBINPUT_DEVICE_CAP_TABLET_PAD capability.
Definition: libinput.h:730
The event is caused by the movement of one or more fingers on the ring.
Definition: libinput.h:276
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...
struct libinput_seat * libinput_seat_unref(struct libinput_seat *seat)
Decrease the refcount of the seat.
Send events from this device normally.
Definition: libinput.h:4049
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.
Definition: libinput.h:4891
struct libinput * libinput_device_get_context(struct libinput_device *device)
Get the libinput context from the device.
Invalid parameter range.
Definition: libinput.h:3671
unsigned int libinput_device_get_id_vendor(struct libinput_device *device)
Get the vendor ID for this device.
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.
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...
Placeholder for devices that don&#39;t have a configurable pointer acceleration profile.
Definition: libinput.h:4226
enum libinput_event_type libinput_event_get_type(struct libinput_event *event)
Get the type of the event.
struct libinput_device_group * libinput_device_group_ref(struct libinput_device_group *group)
Increase the refcount of the device group.
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...
A handle for accessing libinput.
A status change on a tablet ring with the LIBINPUT_DEVICE_CAP_TABLET_PAD capability.
Definition: libinput.h:735
double libinput_event_gesture_get_dx(struct libinput_event_gesture *event)
Return the delta between the last event and the current event.
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.
struct libinput_device * libinput_event_get_device(struct libinput_event *event)
Return the device associated with this 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.
void * libinput_get_user_data(struct libinput *libinput)
Get the caller-specific data associated with this context, if any.
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.
Drag lock is to be disabled, or is currently disabled.
Definition: libinput.h:3852
Definition: libinput.h:185
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.
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).
int libinput_tablet_tool_has_wheel(struct libinput_tablet_tool *tool)
Return whether the tablet tool has a relative wheel.
One or more axes have changed state on a device with the LIBINPUT_DEVICE_CAP_TABLET_TOOL capability...
Definition: libinput.h:657
void libinput_event_destroy(struct libinput_event *event)
Destroy the event, freeing all associated resources.
Definition: libinput.h:626
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.
Tablet pad event representing a button press, or ring/strip update on the tablet pad itself...
Definition: libinput.h:153
Physical drawing tool, e.g.
Definition: libinput.h:318
void libinput_suspend(struct libinput *libinput)
Suspend monitoring for new devices and close existing devices.
enum libinput_config_scroll_method libinput_device_config_scroll_get_default_method(struct libinput_device *device)
Get the default scroll method for this device.
Drag is to be disabled, or is currently disabled.
Definition: libinput.h:3786
int libinput_device_config_scroll_has_natural_scroll(struct libinput_device *device)
Return non-zero if the device supports "natural scrolling".
Definition: libinput.h:209
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.
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.
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.
uint64_t libinput_event_pointer_get_time_usec(struct libinput_event_pointer *event)
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...
uint64_t libinput_event_gesture_get_time_usec(struct libinput_event_gesture *event)
uint32_t libinput_event_keyboard_get_key(struct libinput_event_keyboard *event)
Send scroll events when a button is down and the device moves along a scroll-capable axis...
Definition: libinput.h:4706
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:4686
Send scroll events when a finger moves along the bottom or right edge of a device.
Definition: libinput.h:4701
Tapping is to be disabled, or is currently disabled.
Definition: libinput.h:3690
Definition: libinput.h:221
int libinput_get_fd(struct libinput *libinput)
libinput keeps a single file descriptor for all events.
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.
struct libinput_tablet_tool * libinput_tablet_tool_ref(struct libinput_tablet_tool *tool)
Increment the reference count of the tool by one.
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...
int libinput_resume(struct libinput *libinput)
Resume a suspended libinput context.
int libinput_tablet_tool_has_slider(struct libinput_tablet_tool *tool)
Return whether the tablet tool has a slider axis.
Definition: libinput.h:745
The base handle for accessing libinput seats.
Definition: libinput.h:66
Definition: libinput.h:189
uint64_t libinput_event_tablet_pad_get_time_usec(struct libinput_event_tablet_pad *event)
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
Event type for events returned by libinput_get_event().
Definition: libinput.h:599
uint32_t libinput_device_config_click_get_methods(struct libinput_device *device)
Check which button click methods a device supports.
struct libinput_event * libinput_get_event(struct libinput *libinput)
Retrieve the next event from libinput&#39;s internal event queue.
enum libinput_event_type libinput_next_event_type(struct libinput *libinput)
Return the type of the next event in the internal queue.
int libinput_device_has_capability(struct libinput_device *device, enum libinput_device_capability capability)
Check if the given device has the specified capability.
The event is caused by the motion of some device.
Definition: libinput.h:261
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...
int libinput_event_tablet_tool_slider_has_changed(struct libinput_event_tablet_tool *event)
Check if the slider axis was updated in this event.
uint32_t libinput_event_keyboard_get_time(struct libinput_event_keyboard *event)
Do not send events through this device.
Definition: libinput.h:4063
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...
struct libinput_event_keyboard * libinput_event_get_keyboard_event(struct libinput_event *event)
Return the keyboard event that is this input event.
Definition: libinput.h:341
Definition: libinput.h:210
int libinput_device_config_accel_is_available(struct libinput_device *device)
Check if a device uses libinput-internal pointer-acceleration.
int libinput_tablet_tool_has_rotation(struct libinput_tablet_tool *tool)
Return whether the tablet tool supports z-rotation.
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
Definition: libinput.h:4555
struct libinput_seat * libinput_device_get_seat(struct libinput_device *device)
Get the seat associated with this input device, see Seats for details.
uint32_t libinput_event_tablet_tool_get_button(struct libinput_event_tablet_tool *event)
Return the button that triggered this event.
enum libinput_button_state libinput_event_pointer_get_button_state(struct libinput_event_pointer *event)
Return the button state that triggered this event.
The event is caused by the movement of one or more fingers on the strip.
Definition: libinput.h:291
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.
Definition: libinput.h:238
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.
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.
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.
struct libinput * libinput_unref(struct libinput *libinput)
Dereference the libinput context.
Definition: libinput.h:743
int libinput_tablet_tool_has_distance(struct libinput_tablet_tool *tool)
Return whether the tablet tool supports distance.
void(*) voi libinput_log_set_handler)(struct libinput *libinput, libinput_log_handler log_handler)
Set the context&#39;s log handler.
Definition: libinput.h:3063
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
The source for a LIBINPUT_EVENT_TABLET_PAD_STRIP event.
Definition: libinput.h:285
Signals that a tool has changed a logical button state on a device with the LIBINPUT_DEVICE_CAP_TABLE...
Definition: libinput.h:721
const char * libinput_device_get_sysname(struct libinput_device *device)
Get the system name of the device.
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...
struct libinput_device * libinput_device_unref(struct libinput_device *device)
Decrease the refcount of the input device.
libinput_config_drag_lock_state
Definition: libinput.h:3850
int libinput_device_config_scroll_get_default_natural_scroll_enabled(struct libinput_device *device)
Get the default mode for scrolling on this device.
int libinput_device_get_size(struct libinput_device *device, double *width, double *height)
Get the physical size of a device in mm, where meaningful.
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.
A status change on a strip on a device with the LIBINPUT_DEVICE_CAP_TABLET_PAD capability.
Definition: libinput.h:741
void libinput_seat_set_user_data(struct libinput_seat *seat, void *user_data)
Set caller-specific data associated with this seat.
const char * libinput_seat_get_logical_name(struct libinput_seat *seat)
Return the logical name of the seat.
If an external pointer device is plugged in, do not send events from this device. ...
Definition: libinput.h:4069
void * libinput_tablet_tool_get_user_data(struct libinput_tablet_tool *tool)
Return the user data associated with a tool object.
libinput_log_priority
Log priority for internal logging messages.
Definition: libinput.h:171
A mouse bound to the tablet.
Definition: libinput.h:321
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...
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.
int libinput_udev_assign_seat(struct libinput *libinput, const char *seat_id)
Assign a seat to this libinput context.
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...
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:2713
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.
An event notifying the caller of a device being added or removed.
Definition: libinput.h:104
struct libinput_device_group * libinput_device_group_unref(struct libinput_device_group *group)
Decrease the refcount of the device group.
uint32_t libinput_device_config_scroll_get_methods(struct libinput_device *device)
Check which scroll methods a device supports.
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.
struct libinput_event * libinput_event_keyboard_get_base_event(struct libinput_event_keyboard *event)
const char * libinput_device_get_output_name(struct libinput_device *device)
A device may be mapped to a single output, or all available outputs.
uint32_t libinput_event_pointer_get_time(struct libinput_event_pointer *event)
struct libinput_event * libinput_event_touch_get_base_event(struct libinput_event_touch *event)
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].
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.
Definition: libinput.h:354
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_key_state
Logical state of a key.
Definition: libinput.h:198
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:605
void libinput_device_set_user_data(struct libinput_device *device, void *user_data)
Set caller-specific data associated with this input device.
int libinput_tablet_tool_has_tilt(struct libinput_tablet_tool *tool)
Return whether the tablet tool supports tilt.
Definition: libinput.h:355
uint64_t libinput_event_touch_get_time_usec(struct libinput_event_touch *event)
Definition: libinput.h:271
uint32_t libinput_event_tablet_pad_get_time(struct libinput_event_tablet_pad *event)
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...
int libinput_device_config_left_handed_get(struct libinput_device *device)
Get the current left-handed configuration of the device.
A keyboard event representing a key press/release.
Definition: libinput.h:112
An adaptive acceleration profile.
Definition: libinput.h:4240
struct libinput * libinput_seat_get_context(struct libinput_seat *seat)
Get the libinput context from the seat.
struct libinput_event * libinput_event_pointer_get_base_event(struct libinput_event_pointer *event)
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().
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.
struct libinput_event_pointer * libinput_event_get_pointer_event(struct libinput_event *event)
Return the pointer event that is this input event.
int libinput_event_tablet_tool_y_has_changed(struct libinput_event_tablet_tool *event)
Check if the y axis was updated in this event.
struct libinput_device_group * libinput_device_get_device_group(struct libinput_device *device)
Get the device group this device is assigned to.
uint32_t libinput_device_config_send_events_get_modes(struct libinput_device *device)
Return the possible send-event modes for this device.
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.
Definition: libinput.h:4892
struct libinput_event_touch * libinput_event_get_touch_event(struct libinput_event *event)
Return the touch event that is this input event.
uint64_t libinput_tablet_tool_get_tool_id(struct libinput_tablet_tool *tool)
Return the tool ID for a tool object.