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 
174 
184 };
185 
200 };
201 
211 };
212 
223  LIBINPUT_LED_KANA = (1 << 4)
224 };
225 
235 };
236 
252 };
253 
290 };
291 
307 };
308 
324 };
325 
360 };
361 
381 };
382 
397 };
398 
427 
444 int
446 
471  unsigned int index);
472 
485 unsigned int
487 
505 unsigned int
507 
527 unsigned int
529 
542 int
544  unsigned int button);
545 
558 int
560  unsigned int dial);
561 
574 int
576  unsigned int ring);
577 
590 int
592  unsigned int strip);
593 
612 int
614  unsigned int button);
615 
629  struct libinput_tablet_pad_mode_group *group);
630 
644  struct libinput_tablet_pad_mode_group *group);
645 
659 void
661  struct libinput_tablet_pad_mode_group *group,
662  void *user_data);
663 
675 void *
677  struct libinput_tablet_pad_mode_group *group);
678 
693 };
694 
709 
725 };
726 
735 struct libinput_event_switch;
736 
749 
759 
765 
767 
801 
815 
829 
844 
854 
945 
969 
977 
990 
998 
1010 
1015 };
1016 
1033 void
1034 libinput_event_destroy(struct libinput_event *event);
1035 
1045 
1054 struct libinput *
1056 
1070 struct libinput_device *
1072 
1083 struct libinput_event_pointer *
1085 
1096 struct libinput_event_keyboard *
1098 
1109 struct libinput_event_touch *
1111 
1129 struct libinput_event_gesture *
1131 
1146 
1159 
1172 struct libinput_event_switch *
1174 
1188 
1194 struct libinput_event *
1196 
1212 uint32_t
1214 
1223 uint64_t
1225 
1231 uint32_t
1233 
1239 enum libinput_key_state
1241 
1247 struct libinput_event *
1249 
1262 uint32_t
1264  struct libinput_event_keyboard *event);
1265 
1281 uint32_t
1283 
1292 uint64_t
1294 
1313 double
1315 
1334 double
1336 
1358 double
1360  struct libinput_event_pointer *event);
1361 
1383 double
1385  struct libinput_event_pointer *event);
1386 
1402 double
1404 
1420 double
1422 
1440 double
1442  struct libinput_event_pointer *event,
1443  uint32_t width);
1444 
1462 double
1464  struct libinput_event_pointer *event,
1465  uint32_t height);
1466 
1479 uint32_t
1481 
1496 
1510 uint32_t
1512  struct libinput_event_pointer *event);
1513 
1536 int
1538  enum libinput_pointer_axis axis);
1539 
1564 double
1566  enum libinput_pointer_axis axis);
1567 
1616 
1642 double
1644  enum libinput_pointer_axis axis);
1645 
1694 double
1696  enum libinput_pointer_axis axis);
1697 
1734 double
1736  enum libinput_pointer_axis axis);
1737 
1743 struct libinput_event *
1745 
1760 uint32_t
1762 
1771 uint64_t
1773 
1793 int32_t
1795 
1815 int32_t
1817 
1835 double
1837 
1855 double
1857 
1875 double
1877  uint32_t width);
1878 
1896 double
1898  uint32_t height);
1899 
1905 struct libinput_event *
1907 
1930 uint32_t
1931 libinput_event_gesture_get_time(struct libinput_event_gesture *event);
1932 
1941 uint64_t
1942 libinput_event_gesture_get_time_usec(struct libinput_event_gesture *event);
1943 
1949 struct libinput_event *
1950 libinput_event_gesture_get_base_event(struct libinput_event_gesture *event);
1951 
1967 int
1968 libinput_event_gesture_get_finger_count(struct libinput_event_gesture *event);
1969 
1984 int
1985 libinput_event_gesture_get_cancelled(struct libinput_event_gesture *event);
1986 
2002 double
2003 libinput_event_gesture_get_dx(struct libinput_event_gesture *event);
2004 
2020 double
2021 libinput_event_gesture_get_dy(struct libinput_event_gesture *event);
2022 
2041 double
2043  struct libinput_event_gesture *event);
2044 
2063 double
2065  struct libinput_event_gesture *event);
2066 
2093 double
2094 libinput_event_gesture_get_scale(struct libinput_event_gesture *event);
2095 
2117 double
2118 libinput_event_gesture_get_angle_delta(struct libinput_event_gesture *event);
2119 
2144 struct libinput_event *
2146 
2166 int
2168  struct libinput_event_tablet_tool *event);
2169 
2189 int
2191  struct libinput_event_tablet_tool *event);
2192 
2212 int
2214  struct libinput_event_tablet_tool *event);
2215 
2237 int
2239  struct libinput_event_tablet_tool *event);
2240 
2260 int
2262  struct libinput_event_tablet_tool *event);
2263 
2283 int
2285  struct libinput_event_tablet_tool *event);
2305 int
2307  struct libinput_event_tablet_tool *event);
2327 int
2329  struct libinput_event_tablet_tool *event);
2330 
2348 int
2350  struct libinput_event_tablet_tool *event);
2351 
2369 int
2371  struct libinput_event_tablet_tool *event);
2372 
2392 int
2394  struct libinput_event_tablet_tool *event);
2395 
2416 double
2418 
2439 double
2441 
2458 double
2460 
2477 double
2479 
2493 double
2495 
2509 double
2511 
2529 double
2531 
2549 double
2551 
2571 double
2573 
2589 double
2591 
2607 double
2609 
2625 double
2627 
2638 double
2640  struct libinput_event_tablet_tool *event);
2641 
2654 int
2656  struct libinput_event_tablet_tool *event);
2657 
2677 double
2679  uint32_t width);
2680 
2700 double
2702  uint32_t height);
2703 
2726 struct libinput_tablet_tool *
2728 
2757 
2773 
2788 uint32_t
2790 
2806 
2822 uint32_t
2824 
2836 uint32_t
2838 
2850 uint64_t
2852 
2878 
2898 uint64_t
2900 
2914 struct libinput_tablet_tool *
2916 
2931 struct libinput_tablet_tool *
2933 
2944 int
2946 
2957 int
2959 
2970 int
2972 
2983 int
2985 
2996 int
2998 
3010 int
3012 
3023 int
3025 
3039 int
3041  uint32_t code);
3042 
3059 int
3061 
3098 uint64_t
3100 
3113 void *
3115 
3126 void
3128  void *user_data);
3129 
3146 struct libinput_event *
3148 
3171 double
3173 
3190 unsigned int
3192 
3211 
3234 double
3236 
3253 unsigned int
3255 
3274 
3295 uint32_t
3297 
3314 
3333 uint32_t
3335 
3350 enum libinput_key_state
3352 
3369 double
3371 
3388 unsigned int
3390 
3423 unsigned int
3425 
3451 
3463 uint32_t
3465 
3477 uint64_t
3479 
3501 enum libinput_switch
3503 
3521 
3529 struct libinput_event *
3531 
3543 uint32_t
3545 
3557 uint64_t
3559 
3587  int (*open_restricted)(const char *path, int flags, void *user_data);
3595  void (*close_restricted)(int fd, void *user_data);
3596 };
3597 
3611 struct libinput *
3612 libinput_udev_create_context(const struct libinput_interface *interface,
3613  void *user_data,
3614  struct udev *udev);
3615 
3637 int
3639  const char *seat_id);
3640 
3660 struct libinput *
3661 libinput_path_create_context(const struct libinput_interface *interface,
3662  void *user_data);
3663 
3684 struct libinput_device *
3686  const char *path);
3687 
3706 void
3708 
3717 int
3719 
3737 int
3739 
3751 struct libinput_event *
3753 
3767 
3779 void
3781  void *user_data);
3782 
3793 void *
3795 
3807 int
3809 
3819 void
3821 
3831 struct libinput *
3832 libinput_ref(struct libinput *libinput);
3833 
3865 struct libinput *
3867 
3883 void
3885  enum libinput_log_priority priority);
3886 
3903 
3918 typedef void (*libinput_log_handler)(struct libinput *libinput,
3919  enum libinput_log_priority priority,
3920  const char *format, va_list args)
3922 
3938 void
3939 libinput_log_set_handler(struct libinput *libinput,
3940  libinput_log_handler log_handler);
3941 
3963 struct libinput_seat *
3964 libinput_seat_ref(struct libinput_seat *seat);
3965 
3977 struct libinput_seat *
3978 libinput_seat_unref(struct libinput_seat *seat);
3979 
3991 void
3992 libinput_seat_set_user_data(struct libinput_seat *seat, void *user_data);
3993 
4003 void *
4005 
4014 struct libinput *
4016 
4033 const char *
4035 
4045 const char *
4047 
4063 struct libinput_device *
4064 libinput_device_ref(struct libinput_device *device);
4065 
4077 struct libinput_device *
4078 libinput_device_unref(struct libinput_device *device);
4079 
4091 void
4092 libinput_device_set_user_data(struct libinput_device *device, void *user_data);
4093 
4103 void *
4105 
4114 struct libinput *
4116 
4177 struct libinput_device_group *
4179 
4191 const char *
4193 
4207 const char *
4209 
4220 unsigned int
4222 
4231 unsigned int
4233 
4242 unsigned int
4244 
4264 const char *
4266 
4287 struct libinput_seat *
4289 
4315 int
4317  const char *name);
4318 
4338 struct udev_device *
4340 
4351 void
4353  enum libinput_led leds);
4354 
4362 int
4364  enum libinput_device_capability capability);
4365 
4380 int
4382  double *width,
4383  double *height);
4384 
4397 int
4398 libinput_device_pointer_has_button(struct libinput_device *device, uint32_t code);
4399 
4412 int
4414  uint32_t code);
4415 
4429 int
4431 
4446 int
4448  enum libinput_switch sw);
4449 
4464 int
4466 
4481 int
4483 
4498 int
4500 
4515 int
4517 
4532 int
4534  uint32_t code);
4535 
4548 struct libinput_device_group *
4550 
4564 struct libinput_device_group *
4566 
4578 void
4580  void *user_data);
4581 
4592 void *
4594 
4651 };
4652 
4662 const char *
4664 
4673 };
4674 
4690 int
4692 
4715  enum libinput_config_tap_state enable);
4716 
4735 
4752 
4763 };
4764 
4773 };
4774 
4808 
4830 
4852 
4873 };
4874 
4894  enum libinput_config_drag_state enable);
4895 
4913 
4933 
4948 };
4949 
4977  enum libinput_config_drag_lock_state enable);
4978 
5001 
5026 
5050 };
5051 
5065 int
5067 
5088  enum libinput_config_3fg_drag_state enable);
5089 
5108 
5127 
5140 int
5142 
5194  const float matrix[6]);
5195 
5212 int
5214  float matrix[6]);
5215 
5236 int
5238  float matrix[6]);
5239 
5257  double x1;
5258  double y1;
5259  double x2;
5260  double y2;
5261 };
5262 
5275 int
5277 
5333  const struct libinput_config_area_rectangle *rect);
5334 
5355 
5376 
5410 };
5411 
5426 uint32_t
5428 
5459  uint32_t mode);
5460 
5480 uint32_t
5482 
5496 uint32_t
5498 
5512 int
5514 
5537  double speed);
5538 
5560 double
5562 
5577 double
5579 
5599 
5605 
5614 };
5615 
5641 struct libinput_config_accel;
5642 
5664 struct libinput_config_accel *
5666 
5681 void
5682 libinput_config_accel_destroy(struct libinput_config_accel *accel_config);
5683 
5704  struct libinput_config_accel *accel_config);
5705 
5743 };
5744 
5776 libinput_config_accel_set_points(struct libinput_config_accel *accel_config,
5777  enum libinput_config_accel_type accel_type,
5778  double step, size_t npoints, double *points);
5779 
5792 uint32_t
5794 
5810  enum libinput_config_accel_profile profile);
5811 
5825 
5839 
5869 int
5871 
5888  int enable);
5902 int
5904 
5918 int
5920 
5934 int
5936 
5962  int left_handed);
5963 
5977 int
5979 
5993 int
5995 
6017 };
6018 
6034 uint32_t
6036 
6059  enum libinput_config_click_method method);
6077 
6095 
6123 
6140 
6157 
6172 };
6173 
6194 int
6196  struct libinput_device *device);
6197 
6222  struct libinput_device *device,
6224 
6250  struct libinput_device *device);
6251 
6278  struct libinput_device *device);
6279 
6307 };
6308 
6326 uint32_t
6328 
6355  enum libinput_config_scroll_method method);
6356 
6375 
6394 
6432  uint32_t button);
6433 
6458 uint32_t
6460 
6481 uint32_t
6483 
6487 };
6488 
6513 
6538 
6558 
6567 };
6568 
6584 int
6586 
6610  enum libinput_config_dwt_state enable);
6611 
6629 
6647 
6658 };
6659 
6678 int
6680 
6706  enum libinput_config_dwtp_state enable);
6707 
6727 
6747 
6762 int
6764 
6794  unsigned int degrees_cw);
6795 
6812 unsigned int
6814 
6831 unsigned int
6833 
6850 int
6852 
6883  double minimum,
6884  double maximum);
6885 
6905 double
6907 
6927 double
6929 
6949 double
6951 
6971 double
6973 
6974 #ifdef __cplusplus
6975 }
6976 #endif
6977 #endif /* LIBINPUT_H */
Definition: libinput.h:1002
libinput_config_dwt_state
Possible states for the disable-while-typing feature.
Definition: libinput.h:6564
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)
enum libinput_config_status libinput_device_config_accel_set_profile(struct libinput_device *device, enum libinput_config_accel_profile profile)
Set the pointer acceleration profile of this pointer device to the given mode.
A custom acceleration profile.
Definition: libinput.h:5613
Middle mouse button emulation is to be disabled, or is currently disabled.
Definition: libinput.h:6166
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:6291
libinput_config_accel_type
Acceleration types are categories of movement by a device that may have specific acceleration functio...
Definition: libinput.h:5727
Definition: libinput.h:6657
Definition: libinput.h:691
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.
libinput_config_clickfinger_button_map
Definition: libinput.h:4768
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:901
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:354
unsigned int libinput_device_get_id_product(struct libinput_device *device)
Get the product ID for this device.
Definition: libinput.h:195
libinput_config_accel_profile
Definition: libinput.h:5585
Drag is to be disabled, or is currently disabled.
Definition: libinput.h:5039
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:847
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.
enum libinput_config_status libinput_device_config_3fg_drag_set_enabled(struct libinput_device *device, enum libinput_config_3fg_drag_state enable)
Enable or disable 3-finger drag on this device.
int libinput_dispatch(struct libinput *libinput)
Main event dispatchment function.
struct libinput * libinput_ref(struct libinput *libinput)
Add a reference to the context.
struct libinput_tablet_pad_mode_group * libinput_tablet_pad_mode_group_unref(struct libinput_tablet_pad_mode_group *group)
Decrease the refcount of the mode group.
double libinput_event_gesture_get_angle_delta(struct libinput_event_gesture *event)
Return the angle delta in degrees between the last and the current LIBINPUT_EVENT_GESTURE_PINCH_UPDAT...
double x1
Definition: libinput.h:5257
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_tablet_tool_config_pressure_range_get_default_maximum(struct libinput_tablet_tool *tool)
Get the maximum pressure value for this tablet tool, normalized to the range [0.0, 1.0] of the available hardware pressure.
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:3575
Definition: libinput.h:197
enum libinput_config_3fg_drag_state libinput_device_config_3fg_drag_get_default_enabled(struct libinput_device *device)
Return whether 3-finger drag is enabled or disabled by default on this device.
Definition: libinput.h:181
The number of fingers decides which button press to generate.
Definition: libinput.h:6016
A scroll event from various sources.
Definition: libinput.h:800
Drag is to be enabled, or is currently enabled.
Definition: libinput.h:4872
Definition: libinput.h:234
libinput_switch_state
The state of a switch.
Definition: libinput.h:690
A rotary device with positional and rotation data.
Definition: libinput.h:357
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.
int libinput_device_config_area_has_rectangle(struct libinput_device *device)
Check if the device can change its logical input area via a rectangle.
libinput_led
Mask reflecting LEDs on a device.
Definition: libinput.h:218
libinput_pointer_axis_source
The source for a libinput_pointer_axis event.
Definition: libinput.h:266
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:1008
Definition: libinput.h:845
double libinput_event_tablet_pad_get_ring_position(struct libinput_event_tablet_pad *event)
Returns the current position of the ring, in degrees clockwise from the northern-most point of the ri...
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:251
libinput_tablet_tool_type
Available tool types for a device with the LIBINPUT_DEVICE_CAP_TABLET_TOOL capability.
Definition: libinput.h:348
Signals the end of a set of touchpoints at one device sample time.
Definition: libinput.h:853
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:4647
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.
Definition: libinput.h:6656
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:221
Use software-button areas to generate button events.
Definition: libinput.h:6012
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:289
The event is caused by the movement of one or more fingers on a device.
Definition: libinput.h:275
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:4862
Tapping is to be enabled, or is currently enabled.
Definition: libinput.h:4671
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.
Drag lock is to be enabled in sticky mode, or is currently enabled in sticky mode.
Definition: libinput.h:4947
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:6008
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:766
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:3918
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:1003
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...
struct libinput_config_area_rectangle libinput_device_config_area_get_rectangle(struct libinput_device *device)
Return the current area rectangle for this device.
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:758
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:4648
double libinput_tablet_tool_config_pressure_range_get_minimum(struct libinput_tablet_tool *tool)
Get the minimum pressure value for this tablet tool, normalized to the range [0.0, 1.0] of the available hardware pressure.
Drag is to be enabled for 4 fingers, or is currently enabled.
Definition: libinput.h:5049
void(* close_restricted)(int fd, void *user_data)
Close the file descriptor.
Definition: libinput.h:3595
libinput_tablet_tool_proximity_state
The state of proximity for a tool on a device.
Definition: libinput.h:378
Definition: libinput.h:768
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:5598
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)
enum libinput_config_status libinput_device_config_accel_apply(struct libinput_device *device, struct libinput_config_accel *accel_config)
Apply this pointer acceleration configuration to the 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:764
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.
int libinput_device_config_3fg_drag_get_finger_count(struct libinput_device *device)
Returns the maximum number of fingers available for 3-finger dragging.
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:1004
Definition: libinput.h:182
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:5383
1/2/3 finger click maps to left/right/middle
Definition: libinput.h:4770
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:232
const char * libinput_config_status_to_str(enum libinput_config_status status)
Return a string describing the error.
enum libinput_config_status libinput_device_config_click_set_clickfinger_button_map(struct libinput_device *device, enum libinput_config_clickfinger_button_map map)
Set the finger number to button number mapping for clickfinger.
Definition: libinput.h:199
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.
double libinput_event_tablet_pad_get_dial_delta_v120(struct libinput_event_tablet_pad *event)
Returns the delta change of the dial, in multiples or fractions of 120, with each multiple of 120 ind...
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:6296
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:926
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.
int libinput_tablet_tool_config_pressure_range_is_available(struct libinput_tablet_tool *tool)
Check if a tablet tool can have a custom pressure range.
libinput_tablet_tool_tip_state
The tip contact state for a tool on a device.
Definition: libinput.h:394
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:770
int libinput_device_config_dwtp_is_available(struct libinput_device *device)
Check if this device supports configurable disable-while-trackpointing feature.
enum libinput_config_middle_emulation_state libinput_device_config_middle_emulation_get_default_enabled(struct libinput_device *device)
Check if configurable middle button emulation is enabled by default on this device.
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.
Acceleration type for regular pointer movement.
Definition: libinput.h:5737
A scroll event from a continuous scroll source, e.g.
Definition: libinput.h:843
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:249
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.
enum libinput_config_clickfinger_button_map libinput_device_config_click_get_clickfinger_button_map(struct libinput_device *device)
Get the finger number to button number mapping for clickfinger.
libinput_config_tap_state
Definition: libinput.h:4668
A mouse tool with a lens.
Definition: libinput.h:356
Definition: libinput.h:193
void libinput_set_user_data(struct libinput *libinput, void *user_data)
Set caller-specific data associated with this context.
Eraser.
Definition: libinput.h:350
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:349
double libinput_tablet_tool_config_pressure_range_get_maximum(struct libinput_tablet_tool *tool)
Get the maximum pressure value for this tablet tool, normalized to the range [0.0, 1.0] of the available hardware pressure.
Middle mouse button emulation is to be enabled, or is currently enabled.
Definition: libinput.h:6171
unsigned int libinput_device_get_id_bustype(struct libinput_device *device)
Get the bus type ID for this device.
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:209
libinput_device_capability
Capabilities on a device.
Definition: libinput.h:192
The event is caused by the rotation of a wheel.
Definition: libinput.h:270
Definition: libinput.h:846
libinput_config_status
Status codes returned when applying configuration settings.
Definition: libinput.h:4646
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:210
libinput_tablet_pad_ring_axis_source
The source for a LIBINPUT_EVENT_TABLET_PAD_RING event.
Definition: libinput.h:300
Definition: libinput.h:1000
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. ...
1/2/3 finger click maps to left/middle/right
Definition: libinput.h:4772
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:4758
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 ...
libinput_config_3fg_drag_state
A config status to distinguish or set 3-finger dragging on a device.
Definition: libinput.h:5034
Definition: libinput.h:183
enum libinput_config_status libinput_config_accel_set_points(struct libinput_config_accel *accel_config, enum libinput_config_accel_type accel_type, double step, size_t npoints, double *points)
Defines the acceleration function for a given movement type in an acceleration configuration with the...
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.
enum libinput_config_3fg_drag_state libinput_device_config_3fg_drag_get_enabled(struct libinput_device *device)
Return whether 3-finger drag is enabled or disabled on 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:1014
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:989
double libinput_event_gesture_get_dy(struct libinput_event_gesture *event)
Return the delta between the last event and the current event.
double libinput_event_pointer_get_scroll_value(struct libinput_event_pointer *event, enum libinput_pointer_axis axis)
Return the axis value of the given axis.
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.
legacy spelling for LIBINPUT_CONFIG_DRAG_LOCK_ENABLED_TIMEOUT
Definition: libinput.h:4944
1/2/3 finger tap maps to left/middle/right
Definition: libinput.h:4762
The laptop lid was closed when the switch state is LIBINPUT_SWITCH_STATE_ON, or was opened when it is...
Definition: libinput.h:708
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:196
Definition: libinput.h:848
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:6003
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
void libinput_config_accel_destroy(struct libinput_config_accel *accel_config)
Destroy an acceleration configuration.
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:351
double y1
Definition: libinput.h:5258
A button pressed on a device with the LIBINPUT_DEVICE_CAP_TABLET_PAD capability.
Definition: libinput.h:961
The event is caused by the movement of one or more fingers on the ring.
Definition: libinput.h:306
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:5389
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:6565
struct libinput * libinput_device_get_context(struct libinput_device *device)
Get the libinput context from the device.
Invalid parameter range.
Definition: libinput.h:4650
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.
The default acceleration type used as a fallback when other acceleration types are not provided...
Definition: libinput.h:5732
Acceleration type for scroll movement.
Definition: libinput.h:5742
Placeholder for devices that don't have a configurable pointer acceleration profile.
Definition: libinput.h:5590
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:968
double libinput_event_gesture_get_dx(struct libinput_event_gesture *event)
Return the delta between the last event and the current event.
double libinput_event_pointer_get_scroll_value_v120(struct libinput_event_pointer *event, enum libinput_pointer_axis axis)
For events of type LIBINPUT_EVENT_POINTER_SCROLL_WHEEL the v120-normalized value represents the movem...
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:702
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.
A scroll event caused by the movement of one or more fingers on a device.
Definition: libinput.h:828
Drag lock is to be disabled, or is currently disabled.
Definition: libinput.h:4939
Definition: libinput.h:194
Drag lock is to be enabled in timeout mode, or is currently enabled in timeout mode.
Definition: libinput.h:4942
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:874
void libinput_event_destroy(struct libinput_event *event)
Destroy the event, freeing all associated resources.
Definition: libinput.h:769
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.
double libinput_tablet_tool_config_pressure_range_get_default_minimum(struct libinput_tablet_tool *tool)
Get the minimum pressure value for this tablet tool, normalized to the range [0.0, 1.0] of the available hardware pressure.
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:352
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:4867
enum libinput_config_clickfinger_button_map libinput_device_config_click_get_default_clickfinger_button_map(struct libinput_device *device)
Get the default finger number to button number mapping for clickfinger.
int libinput_device_config_scroll_has_natural_scroll(struct libinput_device *device)
Return non-zero if the device supports "natural scrolling".
Definition: libinput.h:219
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:6306
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:6286
Send scroll events when a finger moves along the bottom or right edge of a device.
Definition: libinput.h:6301
Tapping is to be disabled, or is currently disabled.
Definition: libinput.h:4669
A scroll event from a wheel.
Definition: libinput.h:814
Definition: libinput.h:233
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:1001
Definition: libinput.h:223
The base handle for accessing libinput seats.
Definition: libinput.h:67
Definition: libinput.h:198
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.
Drag is to be enabled for 3 fingers, or is currently enabled.
Definition: libinput.h:5044
libinput_event_type
Event type for events returned by libinput_get_event().
Definition: libinput.h:742
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:279
Definition: libinput.h:692
This switch indicates whether the device is in normal laptop mode or behaves like a tablet-like devic...
Definition: libinput.h:724
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:5403
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.
struct libinput_config_area_rectangle libinput_device_config_area_get_default_rectangle(struct libinput_device *device)
Return the default area rectangle for this device.
Definition: libinput.h:380
Definition: libinput.h:220
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:6161
struct libinput_seat * libinput_device_get_seat(struct libinput_device *device)
Get the seat associated with this input device.
unsigned int libinput_event_tablet_pad_get_dial_number(struct libinput_event_tablet_pad *event)
Returns the number of the dial that has changed state, with 0 being the first dial.
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.
libinput_config_dwtp_state
Possible states for the disable-while-trackpointing feature.
Definition: libinput.h:6655
The event is caused by the movement of one or more fingers on the strip.
Definition: libinput.h:323
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:250
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.
struct libinput_config_accel * libinput_config_accel_create(enum libinput_config_accel_profile profile)
Create an acceleration configuration of a given profile.
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.
int libinput_tablet_pad_mode_group_has_dial(struct libinput_tablet_pad_mode_group *group, unsigned int dial)
Devices without mode switching capabilities return true for every dial.
Definition: libinput.h:999
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:3939
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:317
Signals that a tool has changed a logical button state on a device with the LIBINPUT_DEVICE_CAP_TABLE...
Definition: libinput.h:944
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.
Definition: libinput.h:222
libinput_config_drag_lock_state
Definition: libinput.h:4937
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:976
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:5409
enum libinput_switch_state libinput_event_switch_get_switch_state(struct libinput_event_switch *event)
Return the switch state that triggered this event.
int libinput_device_tablet_pad_get_num_dials(struct libinput_device *device)
Return the number of dials a device with the LIBINPUT_DEVICE_CAP_TABLET_PAD capability provides...
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:4760
libinput_config_scroll_button_lock_state
Definition: libinput.h:6484
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:180
A mouse bound to the tablet.
Definition: libinput.h:355
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:3587
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.
enum libinput_config_dwtp_state libinput_device_config_dwtp_get_enabled(struct libinput_device *device)
Check if the disable-while trackpointing feature is currently enabled on this device.
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:395
Definition: libinput.h:1009
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.
enum libinput_config_dwtp_state libinput_device_config_dwtp_get_default_enabled(struct libinput_device *device)
Check if the disable-while trackpointing feature is enabled on this device by default.
enum libinput_config_status libinput_device_config_dwtp_set_enabled(struct libinput_device *device, enum libinput_config_dwtp_state enable)
Enable or disable the disable-while-trackpointing feature.
libinput_key_state
Logical state of a key.
Definition: libinput.h:208
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:748
void libinput_device_set_user_data(struct libinput_device *device, void *user_data)
Set caller-specific data associated with this input device.
double y2
Definition: libinput.h:5260
int libinput_tablet_tool_has_tilt(struct libinput_tablet_tool *tool)
Return whether the tablet tool supports tilt.
A status change on a tablet dial with the LIBINPUT_DEVICE_CAP_TABLET_PAD capability.
Definition: libinput.h:997
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:396
double x2
Definition: libinput.h:5259
uint64_t libinput_event_touch_get_time_usec(struct libinput_event_touch *event)
Definition: libinput.h:301
Describes a rectangle to configure a device's area, see libinput_device_config_area_set_rectangle().
Definition: libinput.h:5256
enum libinput_config_status libinput_device_config_area_set_rectangle(struct libinput_device *device, const struct libinput_config_area_rectangle *rect)
Set the given rectangle as the logical input area of this 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-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:5604
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.
enum libinput_config_status libinput_tablet_tool_config_pressure_range_set(struct libinput_tablet_tool *tool, double minimum, double maximum)
Set the pressure range for this tablet tool.
Definition: libinput.h:6566
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.