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 
49 };
50 
63 };
64 
74 };
75 
85 };
86 
96 };
97 
113 };
114 
135 };
136 
152 struct libinput_tablet_tool;
153 
183 };
184 
202 };
203 
216 };
217 
230 
240 
246 
248 
253 
263 
341 
348 };
349 
357 struct libinput;
358 
367 
377 
386 
398 
406 
414 
423 
435 
445 
462 void
464 
474 
483 struct libinput *
485 
499 struct libinput_device *
501 
512 struct libinput_event_pointer *
514 
527 
538 struct libinput_event_touch *
540 
549 struct libinput_event_gesture *
551 
564 
578 
584 struct libinput_event *
586 
599 uint32_t
601 
607 uint64_t
609 
615 uint32_t
617 
625 
631 struct libinput_event *
633 
646 uint32_t
648  struct libinput_event_keyboard *event);
649 
662 uint32_t
664 
670 uint64_t
672 
691 double
693 
712 double
714 
733 double
735  struct libinput_event_pointer *event);
736 
755 double
757  struct libinput_event_pointer *event);
758 
774 double
776 
792 double
794 
812 double
814  struct libinput_event_pointer *event,
815  uint32_t width);
816 
834 double
836  struct libinput_event_pointer *event,
837  uint32_t height);
838 
851 uint32_t
853 
868 
882 uint32_t
884  struct libinput_event_pointer *event);
885 
903 int
905  enum libinput_pointer_axis axis);
906 
931 double
933  enum libinput_pointer_axis axis);
934 
972 
989 double
991  enum libinput_pointer_axis axis);
992 
998 struct libinput_event *
1000 
1012 uint32_t
1014 
1020 uint64_t
1022 
1042 int32_t
1044 
1064 int32_t
1066 
1084 double
1086 
1104 double
1106 
1124 double
1126  uint32_t width);
1127 
1145 double
1147  uint32_t height);
1148 
1154 struct libinput_event *
1156 
1176 uint32_t
1177 libinput_event_gesture_get_time(struct libinput_event_gesture *event);
1178 
1184 uint64_t
1185 libinput_event_gesture_get_time_usec(struct libinput_event_gesture *event);
1186 
1192 struct libinput_event *
1193 libinput_event_gesture_get_base_event(struct libinput_event_gesture *event);
1194 
1206 int
1207 libinput_event_gesture_get_finger_count(struct libinput_event_gesture *event);
1208 
1223 int
1224 libinput_event_gesture_get_cancelled(struct libinput_event_gesture *event);
1225 
1241 double
1242 libinput_event_gesture_get_dx(struct libinput_event_gesture *event);
1243 
1259 double
1260 libinput_event_gesture_get_dy(struct libinput_event_gesture *event);
1261 
1277 double
1279  struct libinput_event_gesture *event);
1280 
1296 double
1298  struct libinput_event_gesture *event);
1299 
1326 double
1327 libinput_event_gesture_get_scale(struct libinput_event_gesture *event);
1328 
1350 double
1351 libinput_event_gesture_get_angle_delta(struct libinput_event_gesture *event);
1352 
1364 struct libinput_event *
1366 
1384 int
1386  struct libinput_event_tablet_tool *event);
1387 
1405 int
1407  struct libinput_event_tablet_tool *event);
1408 
1426 int
1428  struct libinput_event_tablet_tool *event);
1429 
1449 int
1451  struct libinput_event_tablet_tool *event);
1452 
1470 int
1472  struct libinput_event_tablet_tool *event);
1473 
1491 int
1493  struct libinput_event_tablet_tool *event);
1511 int
1513  struct libinput_event_tablet_tool *event);
1531 int
1533  struct libinput_event_tablet_tool *event);
1551 int
1553  struct libinput_event_tablet_tool *event);
1554 
1566 double
1568 
1580 double
1582 
1597 double
1599 
1614 double
1616 
1628 double
1630 
1642 double
1644 
1656 double
1658 
1670 double
1672 
1690 double
1692 
1706 double
1708 
1719 double
1721  struct libinput_event_tablet_tool *event);
1722 
1733 int
1735  struct libinput_event_tablet_tool *event);
1736 
1751 double
1753  uint32_t width);
1754 
1769 double
1771  uint32_t height);
1772 
1790 struct libinput_tablet_tool *
1792 
1807 
1821 
1835 uint32_t
1837 
1851 
1864 uint32_t
1866 
1873 uint32_t
1875 
1882 uint64_t
1884 
1898 
1915 uint64_t
1917 
1929 struct libinput_tablet_tool *
1931 
1943 struct libinput_tablet_tool *
1945 
1954 int
1956 
1965 int
1967 
1976 int
1978 
1987 int
1989 
1998 int
2000 
2009 int
2011 
2023 int
2025  uint32_t code);
2026 
2041 int
2043 
2056 uint64_t
2058 
2069 void *
2071 
2080 void
2082  void *user_data);
2083 
2111  int (*open_restricted)(const char *path, int flags, void *user_data);
2119  void (*close_restricted)(int fd, void *user_data);
2120 };
2121 
2135 struct libinput *
2136 libinput_udev_create_context(const struct libinput_interface *interface,
2137  void *user_data,
2138  struct udev *udev);
2139 
2161 int
2163  const char *seat_id);
2164 
2184 struct libinput *
2185 libinput_path_create_context(const struct libinput_interface *interface,
2186  void *user_data);
2187 
2208 struct libinput_device *
2210  const char *path);
2211 
2230 void
2232 
2241 int
2243 
2261 int
2263 
2275 struct libinput_event *
2277 
2291 
2303 void
2305  void *user_data);
2306 
2316 void *
2318 
2330 int
2332 
2342 void
2344 
2354 struct libinput *
2355 libinput_ref(struct libinput *libinput);
2356 
2387 struct libinput *
2389 
2405 void
2407  enum libinput_log_priority priority);
2408 
2425 
2440 typedef void (*libinput_log_handler)(struct libinput *libinput,
2441  enum libinput_log_priority priority,
2442  const char *format, va_list args)
2444 
2460 void
2461 libinput_log_set_handler(struct libinput *libinput,
2462  libinput_log_handler log_handler);
2463 
2484 struct libinput_seat *
2485 libinput_seat_ref(struct libinput_seat *seat);
2486 
2498 struct libinput_seat *
2499 libinput_seat_unref(struct libinput_seat *seat);
2500 
2512 void
2513 libinput_seat_set_user_data(struct libinput_seat *seat, void *user_data);
2514 
2524 void *
2526 
2535 struct libinput *
2537 
2554 const char *
2556 
2566 const char *
2568 
2584 struct libinput_device *
2585 libinput_device_ref(struct libinput_device *device);
2586 
2598 struct libinput_device *
2599 libinput_device_unref(struct libinput_device *device);
2600 
2612 void
2613 libinput_device_set_user_data(struct libinput_device *device, void *user_data);
2614 
2624 void *
2626 
2635 struct libinput *
2637 
2698 struct libinput_device_group *
2700 
2712 const char *
2714 
2728 const char *
2730 
2739 unsigned int
2741 
2750 unsigned int
2752 
2764 const char *
2766 
2781 struct libinput_seat *
2783 
2809 int
2811  const char *name);
2812 
2832 struct udev_device *
2834 
2845 void
2847  enum libinput_led leds);
2848 
2856 int
2858  enum libinput_device_capability capability);
2859 
2874 int
2876  double *width,
2877  double *height);
2878 
2891 int
2892 libinput_device_pointer_has_button(struct libinput_device *device, uint32_t code);
2893 
2906 int
2908  uint32_t code);
2909 
2922 struct libinput_device_group *
2924 
2938 struct libinput_device_group *
2940 
2952 void
2954  void *user_data);
2955 
2966 void *
2968 
2993 };
2994 
3004 const char *
3006 
3015 };
3016 
3032 int
3034 
3057  enum libinput_config_tap_state enable);
3058 
3077 
3094 
3113 };
3114 
3132  enum libinput_config_drag_state enable);
3133 
3149 
3167 
3176 };
3177 
3202  enum libinput_config_drag_lock_state enable);
3203 
3223 
3246 
3259 int
3261 
3313  const float matrix[6]);
3314 
3331 int
3333  float matrix[6]);
3334 
3354 int
3356  float matrix[6]);
3357 
3391 };
3392 
3407 uint32_t
3409 
3440  uint32_t mode);
3441 
3461 uint32_t
3463 
3477 uint32_t
3479 
3489 int
3491 
3510  double speed);
3511 
3523 double
3525 
3536 double
3538 
3553 
3559 };
3560 
3571 uint32_t
3573 
3587  enum libinput_config_accel_profile mode);
3588 
3600 
3612 
3642 int
3644 
3661  int enable);
3675 int
3677 
3691 int
3693 
3707 int
3709 
3735  int left_handed);
3736 
3750 int
3752 
3766 int
3768 
3791 };
3792 
3808 uint32_t
3810 
3833  enum libinput_config_click_method method);
3851 
3869 
3884 };
3885 
3906 int
3908  struct libinput_device *device);
3909 
3942  struct libinput_device *device,
3944 
3967  struct libinput_device *device);
3968 
3992  struct libinput_device *device);
3993 
4021 };
4022 
4040 uint32_t
4042 
4069  enum libinput_config_scroll_method method);
4070 
4089 
4108 
4146  uint32_t button);
4147 
4172 uint32_t
4174 
4195 uint32_t
4197 
4207 };
4208 
4224 int
4226 
4250  enum libinput_config_dwt_state enable);
4251 
4269 
4287 
4288 #ifdef __cplusplus
4289 }
4290 #endif
4291 #endif /* LIBINPUT_H */
Definition: libinput.h:345
libinput_config_dwt_state
Possible states for the disable-while-typing feature.
Definition: libinput.h:4204
const char * libinput_seat_get_physical_name(struct libinput_seat *seat)
Return the physical name of the seat.
Middle mouse button emulation is to be disabled, or is currently disabled.
Definition: libinput.h:3878
A base handle for accessing libinput devices.
Definition: libinput.h:357
Never send scroll events instead of pointer motion events.
Definition: libinput.h:4005
Placeholder for devices that don't have a configurable pointer acceleration profile.
Definition: libinput.h:3544
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:306
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:180
unsigned int libinput_device_get_id_product(struct libinput_device *device)
Get the product ID for this device.
Definition: libinput.h:60
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.
Definition: libinput.h:256
int libinput_dispatch(struct libinput *libinput)
Main event dispatchment function.
struct libinput * libinput_ref(struct libinput *libinput)
Add a reference to the context.
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:2099
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:46
The number of fingers decides which button press to generate.
Definition: libinput.h:3790
libinput_config_accel_profile
Definition: libinput.h:3539
Definition: libinput.h:252
Drag is to be enabled, or is currently enabled.
Definition: libinput.h:3112
Definition: libinput.h:95
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].
libinput_led
Mask reflecting LEDs on a device.
Definition: libinput.h:81
libinput_pointer_axis_source
The source for a libinput_pointer_axis event.
Definition: libinput.h:121
Touch event representing a touch down, move or up, as well as a touch cancel and touch frame events...
Definition: libinput.h:422
struct libinput_event * libinput_event_gesture_get_base_event(struct libinput_event_gesture *event)
Definition: libinput.h:254
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:112
libinput_tablet_tool_type
Available tool types for a device with the LIBINPUT_DEVICE_CAP_TABLET_TOOL capability.
Definition: libinput.h:174
Signals the end of a set of touchpoints at one device sample time.
Definition: libinput.h:262
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:2989
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:84
Use software-button areas (see Clickfinger behavior) to generate button events.
Definition: libinput.h:3786
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...
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:130
libinput_config_drag_state
A config status to distinguish or set dragging on a device.
Definition: libinput.h:3102
Tapping is to be enabled, or is currently enabled.
Definition: libinput.h:3013
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:3781
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:247
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:2440
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:346
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 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 event, transformed to screen coordinates...
Signals that a device has been added to the context.
Definition: libinput.h:239
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:2990
void(* close_restricted)(int fd, void *user_data)
Close the file descriptor.
Definition: libinput.h:2119
libinput_tablet_tool_proximity_state
The state of proximity for a tool on a device.
Definition: libinput.h:199
struct libinput_event_gesture * libinput_event_get_gesture_event(struct libinput_event *event)
Return the gesture event that is this input event.
Definition: libinput.h:249
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.
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:245
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:347
Definition: libinput.h:47
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:3364
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:93
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 type of 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:4010
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:413
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:329
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:213
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, normalized to the range [-1, 1].
Definition: libinput.h:251
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:110
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:3010
A mouse tool with a lens.
Definition: libinput.h:182
Definition: libinput.h:58
void libinput_set_user_data(struct libinput *libinput, void *user_data)
Set caller-specific data associated with this context.
Eraser.
Definition: libinput.h:176
An object representing a tool being used by a device with the LIBINPUT_DEVICE_CAP_TABLET_TOOL capabil...
A generic pen.
Definition: libinput.h:175
Middle mouse button emulation is to be enabled, or is currently enabled.
Definition: libinput.h:3883
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.
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:72
libinput_device_capability
Capabilities on a device.
Definition: libinput.h:57
The event is caused by the rotation of a wheel.
Definition: libinput.h:125
Definition: libinput.h:255
libinput_config_status
Status codes returned when applying configuration settings.
Definition: libinput.h:2988
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.
Definition: libinput.h:73
Definition: libinput.h:343
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.
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.
Definition: libinput.h:48
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 event representing an axis update, button press, or tool update.
Definition: libinput.h:434
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.
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:3175
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:61
Definition: libinput.h:257
The base event type.
Definition: libinput.h:385
#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:3776
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:366
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:177
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:3370
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:4205
struct libinput * libinput_device_get_context(struct libinput_device *device)
Get the libinput context from the device.
Invalid parameter range.
Definition: libinput.h:2992
unsigned int libinput_device_get_id_vendor(struct libinput_device *device)
Get the vendor ID for this device.
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.
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.
Drag lock is to be disabled, or is currently disabled.
Definition: libinput.h:3173
Definition: libinput.h:59
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, normalized to the range [-1, 1].
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:281
void libinput_event_destroy(struct libinput_event *event)
Destroy the event, freeing all associated resources.
Definition: libinput.h:250
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.
Physical drawing tool, e.g.
Definition: libinput.h:178
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:3107
int libinput_device_config_scroll_has_natural_scroll(struct libinput_device *device)
Return non-zero if the device supports "natural scrolling".
Definition: libinput.h:82
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 event that is this input event.
uint64_t libinput_event_pointer_get_time_usec(struct libinput_event_pointer *event)
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:4020
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:4000
Send scroll events when a finger moves along the bottom or right edge of a device.
Definition: libinput.h:4015
Tapping is to be disabled, or is currently disabled.
Definition: libinput.h:3011
Definition: libinput.h:94
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.
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:344
The base handle for accessing libinput seats.
Definition: libinput.h:376
Definition: libinput.h:62
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:223
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.
The event is caused by the motion of some device.
Definition: libinput.h:134
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:3384
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:201
Definition: libinput.h:83
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:3873
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.
Definition: libinput.h:111
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:342
An adaptive acceleration profile.
Definition: libinput.h:3558
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:2461
enum libinput_log_priority libinput_log_get_priority(const struct libinput *libinput)
Get the context's log priority.
Signals that a tool has changed a logical button state on a device with the LIBINPUT_DEVICE_CAP_TABLE...
Definition: libinput.h:340
const char * libinput_device_get_sysname(struct libinput_device *device)
Get the system name of the device.
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:3171
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.
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:3390
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:45
A mouse bound to the tablet.
Definition: libinput.h:181
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:2111
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:397
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.
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:214
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:71
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:229
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:215
uint64_t libinput_event_touch_get_time_usec(struct libinput_event_touch *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 flat acceleration profile.
Definition: libinput.h:3552
A keyboard event representing a key press/release.
Definition: libinput.h:405
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)
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:4206
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.