libinput  0.16.0
A wrapper library for input devices
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 to use, copy, modify, distribute, and sell this software and
6  * its documentation for any purpose is hereby granted without fee, provided
7  * that the above copyright notice appear in all copies and that both that
8  * copyright notice and this permission notice appear in supporting
9  * documentation, and that the name of the copyright holders not be used in
10  * advertising or publicity pertaining to distribution of the software
11  * without specific, written prior permission. The copyright holders make
12  * no representations about the suitability of this software for any
13  * purpose. It is provided "as is" without express or implied warranty.
14  *
15  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
16  * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
17  * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
18  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
19  * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
20  * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
21  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
22  */
23 
24 #ifndef LIBINPUT_H
25 #define LIBINPUT_H
26 
27 #ifdef __cplusplus
28 extern "C" {
29 #endif
30 
31 #include <stdlib.h>
32 #include <stdint.h>
33 #include <libudev.h>
34 
35 #define LIBINPUT_ATTRIBUTE_PRINTF(_format, _args) \
36  __attribute__ ((format (printf, _format, _args)))
37 #define LIBINPUT_ATTRIBUTE_DEPRECATED __attribute__ ((deprecated))
38 
46 };
47 
58 };
59 
69 };
70 
80 };
81 
91 };
92 
108 };
109 
130 };
131 
144 
154 
160 
162 
167 
177 };
178 
186 struct libinput;
187 
196 
206 
215 
227 
235 
243 
252 
263 struct libinput_event_touch;
264 
281 void
283 
293 
302 struct libinput *
304 
318 struct libinput_device *
320 
331 struct libinput_event_pointer *
333 
346 
357 struct libinput_event_touch *
359 
373 
379 struct libinput_event *
381 
394 uint32_t
396 
402 uint32_t
404 
412 
418 struct libinput_event *
420 
433 uint32_t
435  struct libinput_event_keyboard *event);
436 
449 uint32_t
451 
470 double
472 
491 double
493 
511 double
513  struct libinput_event_pointer *event);
514 
532 double
534  struct libinput_event_pointer *event);
535 
551 double
553 
569 double
571 
589 double
591  struct libinput_event_pointer *event,
592  uint32_t width);
593 
611 double
613  struct libinput_event_pointer *event,
614  uint32_t height);
615 
628 uint32_t
630 
645 
659 uint32_t
661  struct libinput_event_pointer *event);
662 
680 int
682  enum libinput_pointer_axis axis);
683 
708 double
710  enum libinput_pointer_axis axis);
711 
749 
766 double
768  enum libinput_pointer_axis axis);
769 
775 struct libinput_event *
777 
789 uint32_t
791 
811 int32_t
813 
833 int32_t
835 
852 double
854 
871 double
873 
890 double
892  uint32_t width);
893 
910 double
912  uint32_t height);
913 
919 struct libinput_event *
921 
949  int (*open_restricted)(const char *path, int flags, void *user_data);
957  void (*close_restricted)(int fd, void *user_data);
958 };
959 
973 struct libinput *
974 libinput_udev_create_context(const struct libinput_interface *interface,
975  void *user_data,
976  struct udev *udev);
977 
999 int
1001  const char *seat_id);
1002 
1022 struct libinput *
1023 libinput_path_create_context(const struct libinput_interface *interface,
1024  void *user_data);
1025 
1046 struct libinput_device *
1048  const char *path);
1049 
1068 void
1070 
1079 int
1081 
1099 int
1101 
1113 struct libinput_event *
1115 
1129 
1141 void
1143  void *user_data);
1144 
1154 void *
1156 
1168 int
1170 
1180 void
1182 
1192 struct libinput *
1193 libinput_ref(struct libinput *libinput);
1194 
1205 struct libinput *
1207 
1223 void
1225  enum libinput_log_priority priority);
1226 
1243 
1258 typedef void (*libinput_log_handler)(struct libinput *libinput,
1259  enum libinput_log_priority priority,
1260  const char *format, va_list args)
1262 
1278 void
1279 libinput_log_set_handler(struct libinput *libinput,
1280  libinput_log_handler log_handler);
1281 
1302 struct libinput_seat *
1303 libinput_seat_ref(struct libinput_seat *seat);
1304 
1316 struct libinput_seat *
1317 libinput_seat_unref(struct libinput_seat *seat);
1318 
1330 void
1331 libinput_seat_set_user_data(struct libinput_seat *seat, void *user_data);
1332 
1342 void *
1344 
1353 struct libinput *
1355 
1372 const char *
1374 
1384 const char *
1386 
1402 struct libinput_device *
1403 libinput_device_ref(struct libinput_device *device);
1404 
1416 struct libinput_device *
1417 libinput_device_unref(struct libinput_device *device);
1418 
1430 void
1431 libinput_device_set_user_data(struct libinput_device *device, void *user_data);
1432 
1442 void *
1444 
1453 struct libinput *
1455 
1516 struct libinput_device_group *
1518 
1530 const char *
1532 
1546 const char *
1548 
1557 unsigned int
1559 
1568 unsigned int
1570 
1582 const char *
1584 
1599 struct libinput_seat *
1601 
1627 int
1629  const char *name);
1630 
1650 struct udev_device *
1652 
1663 void
1665  enum libinput_led leds);
1666 
1674 int
1676  enum libinput_device_capability capability);
1677 
1692 int
1694  double *width,
1695  double *height);
1696 
1709 int
1710 libinput_device_pointer_has_button(struct libinput_device *device, uint32_t code);
1711 
1724 int
1726  uint32_t code);
1727 
1740 struct libinput_device_group *
1742 
1756 struct libinput_device_group *
1758 
1770 void
1772  void *user_data);
1773 
1784 void *
1786 
1811 };
1812 
1822 const char *
1824 
1833 };
1834 
1850 int
1852 
1875  enum libinput_config_tap_state enable);
1876 
1894 
1911 
1924 int
1926 
1978  const float matrix[6]);
1979 
1996 int
1998  float matrix[6]);
1999 
2019 int
2021  float matrix[6]);
2022 
2054 };
2055 
2070 uint32_t
2072 
2103  uint32_t mode);
2104 
2124 uint32_t
2126 
2140 uint32_t
2142 
2152 int
2154 
2173  double speed);
2174 
2186 double
2188 
2199 double
2201 
2231 int
2233 
2250  int enable);
2264 int
2266 
2280 int
2282 
2296 int
2298 
2324  int left_handed);
2325 
2339 int
2341 
2355 int
2357 
2380 };
2381 
2397 uint32_t
2399 
2422  enum libinput_config_click_method method);
2440 
2458 
2473 };
2474 
2495 int
2497  struct libinput_device *device);
2498 
2531  struct libinput_device *device,
2533 
2556  struct libinput_device *device);
2557 
2581  struct libinput_device *device);
2582 
2610 };
2611 
2629 uint32_t
2631 
2658  enum libinput_config_scroll_method method);
2659 
2678 
2697 
2735  uint32_t button);
2736 
2761 uint32_t
2763 
2784 uint32_t
2786 
2787 #ifdef __cplusplus
2788 }
2789 #endif
2790 #endif /* LIBINPUT_H */
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:2467
A base handle for accessing libinput devices.
Definition: libinput.h:186
libinput_log_priority
Log priority for internal logging messages.
Definition: libinput.h:42
Never send scroll events instead of pointer motion events.
Definition: libinput.h:2594
unsigned int libinput_device_get_id_product(struct libinput_device *device)
Get the product ID for this device.
Definition: libinput.h:57
uint32_t libinput_event_pointer_get_button(struct libinput_event_pointer *event)
Return the button that triggered this event.
Definition: libinput.h:170
int libinput_dispatch(struct libinput *libinput)
Main event dispatchment function.
struct libinput * libinput_ref(struct libinput *libinput)
Add a reference to the context.
libinput does not open file descriptors to devices directly, instead open_restricted() and close_rest...
Definition: libinput.h:937
The number of fingers decides which button press to generate.
Definition: libinput.h:2379
Definition: libinput.h:166
Definition: libinput.h:90
libinput_led
Mask reflecting LEDs on a device.
Definition: libinput.h:76
libinput_pointer_axis_source
The source for a libinput_pointer_axis event.
Definition: libinput.h:116
Touch event representing a touch down, move or up, as well as a touch cancel and touch frame events...
Definition: libinput.h:251
Definition: libinput.h:168
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:107
Signals the end of a set of touchpoints at one device sample time.
Definition: libinput.h:176
Config applied successfully.
Definition: libinput.h:1807
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.
Definition: libinput.h:79
Use software-button areas (see Clickfinger behavior) to generate button events.
Definition: libinput.h:2375
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...
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:125
Tapping is to be enabled, or is currently enabled.
Definition: libinput.h:1831
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.
Do not send software-emulated button events.
Definition: libinput.h:2370
Definition: libinput.h:161
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:1258
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.
Signals that a device has been added to the context.
Definition: libinput.h:153
Send events from this device normally.
Definition: libinput.h:2033
Configuration not available on this device.
Definition: libinput.h:1808
void(* close_restricted)(int fd, void *user_data)
Close the file descriptor.
Definition: libinput.h:957
Definition: libinput.h:163
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.
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:159
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.
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:88
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.
struct libinput_device * libinput_device_ref(struct libinput_device *device)
Increase the refcount of the input device.
Send scroll events when two fingers are logically down on the device.
Definition: libinput.h:2599
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:242
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...
uint32_t libinput_event_pointer_get_seat_button_count(struct libinput_event_pointer *event)
For the button of a LIBINPUT_EVENT_POINTER_BUTTON event, return the total number of buttons pressed o...
int libinput_device_config_calibration_get_matrix(struct libinput_device *device, float matrix[6])
Return the current calibration matrix for this device.
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.
Definition: libinput.h:165
Definition: libinput.h:44
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:105
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.
libinput_config_tap_state
Definition: libinput.h:1828
Definition: libinput.h:55
void libinput_set_user_data(struct libinput *libinput, void *user_data)
Set caller-specific data associated with this context.
Middle mouse button emulation is to be enabled, or is currently enabled.
Definition: libinput.h:2472
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:67
libinput_device_capability
Capabilities on a device.
Definition: libinput.h:54
The event is caused by the rotation of a wheel.
Definition: libinput.h:120
Definition: libinput.h:169
libinput_config_status
Status codes returned when applying configuration settings.
Definition: libinput.h:1806
Definition: libinput.h:68
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...
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.
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_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.
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().
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...
Definition: libinput.h:43
struct libinput * libinput_event_get_context(struct libinput_event *event)
Get the libinput context from the event.
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:171
The base event type.
Definition: libinput.h:214
#define LIBINPUT_ATTRIBUTE_PRINTF(_format, _args)
Definition: libinput.h:35
libinput_config_click_method
The click method defines when to generate software-emulated buttons, usually on a device that does no...
Definition: libinput.h:2365
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.
A base handle for accessing libinput device groups.
Definition: libinput.h:195
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...
If an external pointer device is plugged in, do not send events from this device. ...
Definition: libinput.h:2053
struct libinput_seat * libinput_seat_unref(struct libinput_seat *seat)
Decrease the refcount of the seat.
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.
struct libinput * libinput_device_get_context(struct libinput_device *device)
Get the libinput context from the device.
Invalid parameter range.
Definition: libinput.h:1810
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.
A handle for accessing libinput.
struct libinput_device * libinput_event_get_device(struct libinput_event *event)
Return the device associated with this event.
void * libinput_get_user_data(struct libinput *libinput)
Get the caller-specific data associated with this context, if any.
Definition: libinput.h:56
void libinput_event_destroy(struct libinput_event *event)
Destroy the event, freeing all associated resources.
Definition: libinput.h:164
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.
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.
int libinput_device_config_scroll_has_natural_scroll(struct libinput_device *device)
Return non-zero if the device supports "natural scrolling".
Definition: libinput.h:77
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:2609
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:2589
Send scroll events when a finger moves along the bottom or right edge of a device.
Definition: libinput.h:2604
Tapping is to be disabled, or is currently disabled.
Definition: libinput.h:1829
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:2027
Definition: libinput.h:89
int libinput_get_fd(struct libinput *libinput)
libinput keeps a single file descriptor for all events.
int libinput_resume(struct libinput *libinput)
Resume a suspended libinput context.
The base handle for accessing libinput seats.
Definition: libinput.h:205
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:137
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:129
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...
uint32_t libinput_event_keyboard_get_time(struct libinput_event_keyboard *event)
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:78
int libinput_device_config_accel_is_available(struct libinput_device *device)
Check if a device uses libinput-internal pointer-acceleration.
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:2462
struct libinput_seat * libinput_device_get_seat(struct libinput_device *device)
Get the seat associated with this input device, see Seats for details.
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:106
Do not send events through this device.
Definition: libinput.h:2047
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.
void(*) voi libinput_log_set_handler)(struct libinput *libinput, libinput_log_handler log_handler)
Set the context's log handler.
Definition: libinput.h:1279
enum libinput_log_priority libinput_log_get_priority(const struct libinput *libinput)
Get the context's log priority.
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.
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.
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.
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...
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:949
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:226
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.
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:66
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:143
void libinput_device_set_user_data(struct libinput_device *device, void *user_data)
Set caller-specific data associated with this input device.
int libinput_device_pointer_has_button(struct libinput_device *device, uint32_t code)
Check if a LIBINPUT_DEVICE_CAP_POINTER device has a button with the given code (see linux/input...
int libinput_device_config_left_handed_get(struct libinput_device *device)
Get the current left-handed configuration of the device.
A keyboard event representing a key press/release.
Definition: libinput.h:234
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.
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:45
struct libinput_event_touch * libinput_event_get_touch_event(struct libinput_event *event)
Return the touch event that is this input event.