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 
58 
68 
77 
97 
109 
117 
125 
134 
146 
160 
173 
183 };
184 
199 };
200 
210 };
211 
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 
899 
904 };
905 
922 void
924 
934 
943 struct libinput *
945 
959 struct libinput_device *
961 
972 struct libinput_event_pointer *
974 
987 
998 struct libinput_event_touch *
1000 
1018 struct libinput_event_gesture *
1020 
1035 
1048 
1061 struct libinput_event_switch *
1063 
1077 
1083 struct libinput_event *
1085 
1101 uint32_t
1103 
1112 uint64_t
1114 
1120 uint32_t
1122 
1128 enum libinput_key_state
1130 
1136 struct libinput_event *
1138 
1151 uint32_t
1153  struct libinput_event_keyboard *event);
1154 
1170 uint32_t
1172 
1181 uint64_t
1183 
1202 double
1204 
1223 double
1225 
1247 double
1249  struct libinput_event_pointer *event);
1250 
1272 double
1274  struct libinput_event_pointer *event);
1275 
1291 double
1293 
1309 double
1311 
1329 double
1331  struct libinput_event_pointer *event,
1332  uint32_t width);
1333 
1351 double
1353  struct libinput_event_pointer *event,
1354  uint32_t height);
1355 
1368 uint32_t
1370 
1385 
1399 uint32_t
1401  struct libinput_event_pointer *event);
1402 
1420 int
1422  enum libinput_pointer_axis axis);
1423 
1448 double
1450  enum libinput_pointer_axis axis);
1451 
1492 
1509 double
1511  enum libinput_pointer_axis axis);
1512 
1518 struct libinput_event *
1520 
1535 uint32_t
1537 
1546 uint64_t
1548 
1568 int32_t
1570 
1590 int32_t
1592 
1610 double
1612 
1630 double
1632 
1650 double
1652  uint32_t width);
1653 
1671 double
1673  uint32_t height);
1674 
1680 struct libinput_event *
1682 
1705 uint32_t
1706 libinput_event_gesture_get_time(struct libinput_event_gesture *event);
1707 
1716 uint64_t
1717 libinput_event_gesture_get_time_usec(struct libinput_event_gesture *event);
1718 
1724 struct libinput_event *
1725 libinput_event_gesture_get_base_event(struct libinput_event_gesture *event);
1726 
1742 int
1743 libinput_event_gesture_get_finger_count(struct libinput_event_gesture *event);
1744 
1759 int
1760 libinput_event_gesture_get_cancelled(struct libinput_event_gesture *event);
1761 
1777 double
1778 libinput_event_gesture_get_dx(struct libinput_event_gesture *event);
1779 
1795 double
1796 libinput_event_gesture_get_dy(struct libinput_event_gesture *event);
1797 
1816 double
1818  struct libinput_event_gesture *event);
1819 
1838 double
1840  struct libinput_event_gesture *event);
1841 
1868 double
1869 libinput_event_gesture_get_scale(struct libinput_event_gesture *event);
1870 
1892 double
1893 libinput_event_gesture_get_angle_delta(struct libinput_event_gesture *event);
1894 
1919 struct libinput_event *
1921 
1941 int
1943  struct libinput_event_tablet_tool *event);
1944 
1964 int
1966  struct libinput_event_tablet_tool *event);
1967 
1987 int
1989  struct libinput_event_tablet_tool *event);
1990 
2012 int
2014  struct libinput_event_tablet_tool *event);
2015 
2035 int
2037  struct libinput_event_tablet_tool *event);
2038 
2058 int
2060  struct libinput_event_tablet_tool *event);
2080 int
2082  struct libinput_event_tablet_tool *event);
2102 int
2104  struct libinput_event_tablet_tool *event);
2105 
2123 int
2125  struct libinput_event_tablet_tool *event);
2126 
2144 int
2146  struct libinput_event_tablet_tool *event);
2147 
2167 int
2169  struct libinput_event_tablet_tool *event);
2170 
2187 double
2189 
2206 double
2208 
2225 double
2227 
2244 double
2246 
2260 double
2262 
2276 double
2278 
2296 double
2298 
2316 double
2318 
2338 double
2340 
2356 double
2358 
2374 double
2376 
2392 double
2394 
2405 double
2407  struct libinput_event_tablet_tool *event);
2408 
2421 int
2423  struct libinput_event_tablet_tool *event);
2424 
2444 double
2446  uint32_t width);
2447 
2467 double
2469  uint32_t height);
2470 
2493 struct libinput_tablet_tool *
2495 
2524 
2540 
2555 uint32_t
2557 
2573 
2589 uint32_t
2591 
2603 uint32_t
2605 
2617 uint64_t
2619 
2645 
2665 uint64_t
2667 
2681 struct libinput_tablet_tool *
2683 
2698 struct libinput_tablet_tool *
2700 
2711 int
2713 
2724 int
2726 
2737 int
2739 
2750 int
2752 
2763 int
2765 
2777 int
2779 
2790 int
2792 
2806 int
2808  uint32_t code);
2809 
2826 int
2828 
2865 uint64_t
2867 
2880 void *
2882 
2893 void
2895  void *user_data);
2896 
2913 struct libinput_event *
2915 
2938 double
2940 
2957 unsigned int
2959 
2978 
3001 double
3003 
3020 unsigned int
3022 
3041 
3062 uint32_t
3064 
3081 
3100 uint32_t
3102 
3117 enum libinput_key_state
3119 
3152 unsigned int
3154 
3180 
3192 uint32_t
3194 
3206 uint64_t
3208 
3230 enum libinput_switch
3232 
3250 
3258 struct libinput_event *
3260 
3272 uint32_t
3274 
3286 uint64_t
3288 
3316  int (*open_restricted)(const char *path, int flags, void *user_data);
3324  void (*close_restricted)(int fd, void *user_data);
3325 };
3326 
3340 struct libinput *
3341 libinput_udev_create_context(const struct libinput_interface *interface,
3342  void *user_data,
3343  struct udev *udev);
3344 
3366 int
3368  const char *seat_id);
3369 
3389 struct libinput *
3390 libinput_path_create_context(const struct libinput_interface *interface,
3391  void *user_data);
3392 
3413 struct libinput_device *
3415  const char *path);
3416 
3435 void
3437 
3446 int
3448 
3466 int
3468 
3480 struct libinput_event *
3482 
3496 
3508 void
3510  void *user_data);
3511 
3522 void *
3524 
3536 int
3538 
3548 void
3550 
3560 struct libinput *
3561 libinput_ref(struct libinput *libinput);
3562 
3594 struct libinput *
3596 
3612 void
3614  enum libinput_log_priority priority);
3615 
3632 
3647 typedef void (*libinput_log_handler)(struct libinput *libinput,
3648  enum libinput_log_priority priority,
3649  const char *format, va_list args)
3651 
3667 void
3668 libinput_log_set_handler(struct libinput *libinput,
3669  libinput_log_handler log_handler);
3670 
3692 struct libinput_seat *
3693 libinput_seat_ref(struct libinput_seat *seat);
3694 
3706 struct libinput_seat *
3707 libinput_seat_unref(struct libinput_seat *seat);
3708 
3720 void
3721 libinput_seat_set_user_data(struct libinput_seat *seat, void *user_data);
3722 
3732 void *
3734 
3743 struct libinput *
3745 
3762 const char *
3764 
3774 const char *
3776 
3792 struct libinput_device *
3793 libinput_device_ref(struct libinput_device *device);
3794 
3806 struct libinput_device *
3807 libinput_device_unref(struct libinput_device *device);
3808 
3820 void
3821 libinput_device_set_user_data(struct libinput_device *device, void *user_data);
3822 
3832 void *
3834 
3843 struct libinput *
3845 
3906 struct libinput_device_group *
3908 
3920 const char *
3922 
3936 const char *
3938 
3947 unsigned int
3949 
3958 unsigned int
3960 
3980 const char *
3982 
4003 struct libinput_seat *
4005 
4031 int
4033  const char *name);
4034 
4054 struct udev_device *
4056 
4067 void
4069  enum libinput_led leds);
4070 
4078 int
4080  enum libinput_device_capability capability);
4081 
4096 int
4098  double *width,
4099  double *height);
4100 
4113 int
4114 libinput_device_pointer_has_button(struct libinput_device *device, uint32_t code);
4115 
4128 int
4130  uint32_t code);
4131 
4145 int
4147 
4162 int
4164  enum libinput_switch sw);
4165 
4180 int
4182 
4197 int
4199 
4214 int
4216 
4231 int
4233  uint32_t code);
4234 
4247 struct libinput_device_group *
4249 
4263 struct libinput_device_group *
4265 
4277 void
4279  void *user_data);
4280 
4291 void *
4293 
4345 };
4346 
4356 const char *
4358 
4367 };
4368 
4384 int
4386 
4409  enum libinput_config_tap_state enable);
4410 
4429 
4446 
4457 };
4458 
4492 
4514 
4536 
4557 };
4558 
4579  enum libinput_config_drag_state enable);
4580 
4598 
4618 
4627 };
4628 
4653  enum libinput_config_drag_lock_state enable);
4654 
4674 
4697 
4710 int
4712 
4764  const float matrix[6]);
4765 
4782 int
4784  float matrix[6]);
4785 
4806 int
4808  float matrix[6]);
4809 
4843 };
4844 
4859 uint32_t
4861 
4892  uint32_t mode);
4893 
4913 uint32_t
4915 
4929 uint32_t
4931 
4945 int
4947 
4970  double speed);
4971 
4987 double
4989 
5004 double
5006 
5026 
5032 };
5033 
5046 uint32_t
5048 
5064  enum libinput_config_accel_profile mode);
5065 
5079 
5093 
5123 int
5125 
5142  int enable);
5156 int
5158 
5172 int
5174 
5188 int
5190 
5216  int left_handed);
5217 
5231 int
5233 
5247 int
5249 
5271 };
5272 
5288 uint32_t
5290 
5313  enum libinput_config_click_method method);
5331 
5349 
5364 };
5365 
5386 int
5388  struct libinput_device *device);
5389 
5414  struct libinput_device *device,
5416 
5442  struct libinput_device *device);
5443 
5470  struct libinput_device *device);
5471 
5499 };
5500 
5518 uint32_t
5520 
5547  enum libinput_config_scroll_method method);
5548 
5567 
5586 
5624  uint32_t button);
5625 
5650 uint32_t
5652 
5673 uint32_t
5675 
5679 };
5680 
5705 
5730 
5750 
5759 };
5760 
5776 int
5778 
5802  enum libinput_config_dwt_state enable);
5803 
5821 
5839 
5854 int
5856 
5891  unsigned int degrees_cw);
5892 
5909 unsigned int
5911 
5928 unsigned int
5930 
5931 #ifdef __cplusplus
5932 }
5933 #endif
5934 #endif /* LIBINPUT_H */
Definition: libinput.h:896
libinput_config_dwt_state
Possible states for the disable-while-typing feature.
Definition: libinput.h:5756
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:5358
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:48
Never send scroll events instead of pointer motion events.
Definition: libinput.h:5483
Definition: libinput.h:665
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:803
uint64_t libinput_event_switch_get_time_usec(struct libinput_event_switch *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.
uint32_t libinput_event_tablet_tool_get_time(struct libinput_event_tablet_tool *event)
An airbrush-like tool.
Definition: libinput.h:345
unsigned int libinput_device_get_id_product(struct libinput_device *device)
Get the product ID for this device.
Definition: libinput.h:194
libinput_config_accel_profile
Definition: libinput.h:5012
uint32_t libinput_event_switch_get_time(struct libinput_event_switch *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...
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:749
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...
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...
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:3304
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:196
Definition: libinput.h:180
The number of fingers decides which button press to generate.
Definition: libinput.h:5270
Definition: libinput.h:745
Drag is to be enabled, or is currently enabled.
Definition: libinput.h:4556
Definition: libinput.h:231
libinput_switch_state
The state of a switch.
Definition: libinput.h:664
A rotary device with positional and rotation data.
Definition: libinput.h:348
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, 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:217
libinput_pointer_axis_source
The source for a libinput_pointer_axis event.
Definition: libinput.h:257
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.
Touch event representing a touch down, move or up, as well as a touch cancel and touch frame events...
Definition: libinput.h:133
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:747
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.
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.
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:248
libinput_tablet_tool_type
Available tool types for a device with the LIBINPUT_DEVICE_CAP_TABLET_TOOL capability.
Definition: libinput.h:339
Signals the end of a set of touchpoints at one device sample time.
Definition: libinput.h:755
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:4341
int libinput_tablet_tool_has_pressure(struct libinput_tablet_tool *tool)
Return whether the tablet tool supports pressure.
A switch event representing a changed state in a switch.
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:220
Use software-button areas to generate button events.
Definition: libinput.h:5266
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 tilting of a mouse wheel rather than its rotation.
Definition: libinput.h:280
The event is caused by the movement of one or more fingers on a device.
Definition: libinput.h:266
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:4546
Tapping is to be enabled, or is currently enabled.
Definition: libinput.h:4365
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.
uint32_t libinput_event_tablet_pad_get_key(struct libinput_event_tablet_pad *event)
Return the key code that triggered this event, e.g.
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:5262
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:740
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:3647
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:897
int libinput_device_touch_get_touch_count(struct libinput_device *device)
Check how many touches a LIBINPUT_DEVICE_CAP_TOUCH device supports simultaneously.
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.
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:732
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:4342
void(* close_restricted)(int fd, void *user_data)
Close the file descriptor.
Definition: libinput.h:3324
libinput_tablet_tool_proximity_state
The state of proximity for a tool on a device.
Definition: libinput.h:369
Definition: libinput.h:742
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:5025
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:738
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:898
Definition: libinput.h:181
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:4816
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:229
const char * libinput_config_status_to_str(enum libinput_config_status status)
Return a string describing the error.
Definition: libinput.h:198
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 high-level tool type for a tool object.
Send scroll events when two fingers are logically down on the device.
Definition: libinput.h:5488
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:124
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:828
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:385
uint32_t libinput_event_tablet_pad_get_time(struct libinput_event_tablet_pad *event)
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's current logical orientation, in degrees off the tablet'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:744
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:246
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:4362
A mouse tool with a lens.
Definition: libinput.h:347
Definition: libinput.h:192
void libinput_set_user_data(struct libinput *libinput, void *user_data)
Set caller-specific data associated with this context.
Eraser.
Definition: libinput.h:341
An object representing a tool being used by a device with the LIBINPUT_DEVICE_CAP_TABLET_TOOL capabil...
Definition: libinput.h:76
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:340
Middle mouse button emulation is to be enabled, or is currently enabled.
Definition: libinput.h:5363
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:208
libinput_device_capability
Capabilities on a device.
Definition: libinput.h:191
The event is caused by the rotation of a wheel.
Definition: libinput.h:261
Definition: libinput.h:748
libinput_config_status
Status codes returned when applying configuration settings.
Definition: libinput.h:4340
int libinput_event_tablet_tool_distance_has_changed(struct libinput_event_tablet_tool *event)
Check if the distance axis was updated in this event.
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.
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.
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.
Definition: libinput.h:209
libinput_tablet_pad_ring_axis_source
The source for a LIBINPUT_EVENT_TABLET_PAD_RING event.
Definition: libinput.h:291
Definition: libinput.h:894
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.
libinput_config_tap_button_map
Definition: libinput.h:4452
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:182
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.
Definition: libinput.h:903
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:145
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...
A key pressed on a device with the LIBINPUT_DEVICE_CAP_TABLET_PAD capability.
Definition: libinput.h:891
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:4626
1/2/3 finger tap maps to left/middle/right
Definition: libinput.h:4456
The laptop lid was closed when the switch state is LIBINPUT_SWITCH_STATE_ON, or was opened when it is...
Definition: libinput.h:682
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:195
Definition: libinput.h:750
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:96
#define LIBINPUT_ATTRIBUTE_PRINTF(_format, _args)
Definition: libinput.h:37
libinput_config_click_method
The click method defines when to generate software-emulated buttons, usually on a device that does no...
Definition: libinput.h:5257
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:57
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:342
A button pressed on a device with the LIBINPUT_DEVICE_CAP_TABLET_PAD capability.
Definition: libinput.h:863
The event is caused by the movement of one or more fingers on the ring.
Definition: libinput.h:297
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:4822
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:5757
struct libinput * libinput_device_get_context(struct libinput_device *device)
Get the libinput context from the device.
Invalid parameter range.
Definition: libinput.h:4344
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...
struct libinput_event_switch * libinput_event_get_switch_event(struct libinput_event *event)
Return the switch event that is this input event.
Placeholder for devices that don't have a configurable pointer acceleration profile.
Definition: libinput.h:5017
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:870
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.
libinput_switch
The type of a switch.
Definition: libinput.h:676
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:4624
Definition: libinput.h:193
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, in degrees off the tablet'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:776
void libinput_event_destroy(struct libinput_event *event)
Destroy the event, freeing all associated resources.
Definition: libinput.h:743
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:159
Physical drawing tool, e.g.
Definition: libinput.h:343
void libinput_suspend(struct libinput *libinput)
Suspend monitoring for new devices and close existing devices.
struct libinput_event * libinput_event_switch_get_base_event(struct libinput_event_switch *event)
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:4551
int libinput_device_config_scroll_has_natural_scroll(struct libinput_device *device)
Return non-zero if the device supports "natural scrolling".
Definition: libinput.h:218
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)
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.
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)
enum libinput_key_state libinput_event_tablet_pad_get_key_state(struct libinput_event_tablet_pad *event)
Return the key state of the 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:5498
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:5478
Send scroll events when a finger moves along the bottom or right edge of a device.
Definition: libinput.h:5493
Tapping is to be disabled, or is currently disabled.
Definition: libinput.h:4363
Definition: libinput.h:230
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:895
The base handle for accessing libinput seats.
Definition: libinput.h:67
Definition: libinput.h:197
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:716
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'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.
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.
The event is caused by the motion of some device.
Definition: libinput.h:270
Definition: libinput.h:666
This switch indicates whether the device is in normal laptop mode or behaves like a tablet-like devic...
Definition: libinput.h:698
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:4836
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:371
Definition: libinput.h:219
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:5353
struct libinput_seat * libinput_device_get_seat(struct libinput_device *device)
Get the seat associated with this input device.
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:314
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:247
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:893
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's log handler.
Definition: libinput.h:3668
enum libinput_log_priority libinput_log_get_priority(const struct libinput *libinput)
Get the context's log priority.
libinput_tablet_pad_strip_axis_source
The source for a LIBINPUT_EVENT_TABLET_PAD_STRIP event.
Definition: libinput.h:308
Signals that a tool has changed a logical button state on a device with the LIBINPUT_DEVICE_CAP_TABLE...
Definition: libinput.h:846
int libinput_tablet_tool_has_size(struct libinput_tablet_tool *tool)
Return whether the tablet tool has a ellipsis major and minor.
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:4622
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:878
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:4842
enum libinput_switch_state libinput_event_switch_get_switch_state(struct libinput_event_switch *event)
Return the switch state that triggered this event.
void * libinput_tablet_tool_get_user_data(struct libinput_tablet_tool *tool)
Return the user data associated with a tool object.
1/2/3 finger tap maps to left/right/middle
Definition: libinput.h:4454
libinput_config_scroll_button_lock_state
Definition: libinput.h:5676
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.
libinput_log_priority
Log priority for internal logging messages.
Definition: libinput.h:179
A mouse bound to the tablet.
Definition: libinput.h:346
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...
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...
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.
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:3316
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:108
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:386
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.
enum libinput_switch libinput_event_switch_get_switch(struct libinput_event_switch *event)
Return the switch that triggered this event.
libinput_key_state
Logical state of a key.
Definition: libinput.h:207
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
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.
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.
Definition: libinput.h:387
uint64_t libinput_event_touch_get_time_usec(struct libinput_event_touch *event)
Definition: libinput.h:292
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_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:116
An adaptive acceleration profile.
Definition: libinput.h:5031
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.
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.
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:5758
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.