Lines Matching refs:device
51 * @ingroup device
60 * @ingroup device
63 * A base handle for accessing libinput device groups. This struct is
79 * @ingroup device
82 * An object representing a tool being used by a device with the @ref
85 * Tablet events generated by such a device are bound to a specific tool
86 * rather than coming from the device directly. Depending on the hardware it
114 * An event notifying the caller of a device being added or removed.
186 * @ingroup device
188 * Capabilities on a device. A device may have one or more capabilities
189 * at a time, capabilities remain static for the lifetime of the device.
202 * @ingroup device
213 * @ingroup device
215 * Mask reflecting LEDs on a device.
224 * @ingroup device
235 * @ingroup device
237 * Axes on a device with the capability @ref LIBINPUT_DEVICE_CAP_POINTER
242 * depending on the device. libinput provides some scroll direction locking
252 * @ingroup device
270 * device.
274 * The event is caused by the motion of some device.
283 * It was never used by any device before libinput 1.16. All wheel
324 * @ingroup device
326 * Available tool types for a device with the @ref
334 * Note that on some device, the eraser tool is on the tail end of a pen
335 * device. On other devices, e.g. MS Surface 3, the eraser is the pen tip
339 * type of the device. For devices with adjustable physical properties
354 LIBINPUT_TABLET_TOOL_TYPE_TOTEM, /**< A rotary device with
360 * @ingroup device
362 * The state of proximity for a tool on a device. The device must have the @ref
366 * within a detectable distance of the tablet device. A tool that is out of
381 * @ingroup device
383 * The tip contact state for a tool on a device. The device must have
387 * touching the surface of the tablet device.
436 * @return the number of mode groups available on this device
441 libinput_device_tablet_pad_get_num_mode_groups(struct libinput_device *device);
457 * @param device A device with the @ref LIBINPUT_DEVICE_CAP_TABLET_PAD
466 libinput_device_tablet_pad_get_mode_group(struct libinput_device *device,
489 * device. Different mode groups may have a different number of modes. Use
493 * libinput guarantees that at least one mode is available. A device without
660 * @ingroup device
676 * @ingroup device
691 * This switch indicates whether the device is in normal laptop mode
692 * or behaves like a tablet-like device where the primary
697 * device is in laptop mode. If the switch is in state @ref
698 * LIBINPUT_SWITCH_STATE_ON, the device is in tablet mode and the
731 * Signals that a device has been added to the context. The device will
735 * This allows setting up initial device configuration before any events
741 * Signals that a device has been removed. No more events from the
742 * associated device will be in the queue or be queued after this event.
798 * device. This event is sent is sent **in addition** to the @ref
830 * Signals the end of a set of touchpoints at one device sample
836 * One or more axes have changed state on a device with the @ref
856 * Signals that a tool has come in or out of proximity of a device with
884 * device with the @ref LIBINPUT_DEVICE_CAP_TABLET_TOOL capability.
891 * The decision when a tip touches the surface is device-dependent
902 * change, the order of events is device-dependent.
909 * device with the @ref LIBINPUT_DEVICE_CAP_TABLET_TOOL capability.
915 * LIBINPUT_EVENT_TABLET_TOOL_AXIS event is device-specific.
927 * A button pressed on a device with the @ref
951 * A status change on a strip on a device with the @ref
959 * A key pressed on a device with the @ref
1032 * Return the device associated with this event. For device added/removed
1033 * events this is the device added or removed. For all other device events,
1034 * this is the device that generated the event.
1036 * This device is not refcounted and its lifetime is that of the event. Use
1037 * libinput_device_ref() before using the device outside of this scope.
1039 * @return The device associated with this event
1150 * Return the device event that is this input event. If the event type does
1151 * not match the device event types, this function returns NULL.
1156 * @return A device event, or NULL for other events
1274 * If a device employs pointer acceleration, the delta returned by this
1295 * If a device employs pointer acceleration, the delta returned by this
1316 * Relative unaccelerated motion deltas are raw device coordinates.
1317 * Note that these coordinates are subject to the device's native
1318 * resolution. Touchpad coordinates represent raw device coordinates in the
1322 * Any rotation applied to the device also applies to unaccelerated motion
1341 * Relative unaccelerated motion deltas are raw device coordinates.
1342 * Note that these coordinates are subject to the device's native
1343 * resolution. Touchpad coordinates represent raw device coordinates in the
1347 * Any rotation applied to the device also applies to unaccelerated motion
1363 * the top left corner of the device. To get the corresponding output screen
1381 * the top left corner of the device. To get the corresponding output screen
1570 * deprecated as of libinput 1.16. No device has ever sent this source.
1685 * The normalized v120 value does not take device-specific physical angles
1753 * single touch device, this function returns -1.
1775 * touch point per device.
1794 * the top left corner of the device. To get the corresponding output screen
1814 * the top left corner of the device. To get the corresponding output screen
1966 * If a device employs pointer acceleration, the delta returned by this
1969 * Relative motion deltas are normalized to represent those of a device with
1984 * If a device employs pointer acceleration, the delta returned by this
1987 * Relative motion deltas are normalized to represent those of a device with
2004 * device with 1000dpi resolution. See the libinput documentation for more
2006 * as read from the device.
2008 * Any rotation applied to the device also applies to gesture motion
2026 * device with 1000dpi resolution. See the libinput documentation for more
2028 * as read from the device.
2030 * Any rotation applied to the device also applies to gesture motion
2099 * Tool events originate (usually) from a stylus-like device, pad events
2377 * width of the device. See the libinput documentation for more details.
2396 * width of the device. See the libinput documentation for more details.
2630 * libinput always includes all device axes in the event.
2633 * width of the device. See the libinput documentation for more details.
2653 * libinput always includes all device axes in the event.
2656 * width of the device. See the libinput documentation for more details.
3033 * identify the physical device. For example, tools compatible with the
3324 * visual feedback like LEDs on the pad. Mode indices start at 0, a device
3503 * Open the device at the given path with the flags provided and
3506 * @param path The device path to open
3552 * device are ignored. Such devices and those that failed to open
3575 * least one device has been added.
3593 * Add a device to a libinput context initialized with
3594 * libinput_path_create_context(). If successful, the device will be
3595 * added to the internal list and re-opened on libinput_resume(). The device
3598 * If the device was successfully initialized, it is returned in the device
3599 * argument. The lifetime of the returned device pointer is limited until
3604 * @param path Path to an input device
3605 * @return The newly initiated device on success, or NULL on failure.
3617 * Remove a device from a libinput context initialized with
3621 * Events already processed from this input device are kept in the queue,
3623 * this device.
3625 * If no matching device exists, this function does nothing.
3627 * @param device A libinput device
3633 libinput_path_remove_device(struct libinput_device *device);
3725 * Resume a suspended libinput context. This re-enables device
3776 * device = libinput_path_add_device(li, "/dev/input/event0");
3777 * // get extra reference to device
3778 * libinput_device_ref(device);
3781 * // including device
3784 * // INCORRECT: device has been cleaned up and must not be used
3785 * // li = libinput_device_get_context(device);
3872 * device is always assigned to exactly one seat. It may change to a
3975 * @defgroup device Initialization and manipulation of input devices
3979 * @ingroup device
3981 * Increase the refcount of the input device. An input device will be freed
3983 * libinput_dispatch() if the device was removed from the system. A caller
3984 * must ensure to reference the device correctly to avoid dangling pointers.
3986 * @param device A previously obtained device
3987 * @return The passed device
3990 libinput_device_ref(struct libinput_device *device);
3993 * @ingroup device
3995 * Decrease the refcount of the input device. An input device will be freed
3997 * if the device was removed from the system. A caller must ensure to
3998 * reference the device correctly to avoid dangling pointers.
4000 * @param device A previously obtained device
4001 * @return NULL if the device was destroyed, otherwise the passed device
4004 libinput_device_unref(struct libinput_device *device);
4007 * @ingroup device
4009 * Set caller-specific data associated with this input device. libinput does
4013 * @param device A previously obtained device
4018 libinput_device_set_user_data(struct libinput_device *device, void *user_data);
4021 * @ingroup device
4023 * Get the caller-specific data associated with this input device, if any.
4025 * @param device A previously obtained device
4030 libinput_device_get_user_data(struct libinput_device *device);
4033 * @ingroup device
4035 * Get the libinput context from the device.
4037 * @param device A previously obtained device
4038 * @return The libinput context for this device.
4041 libinput_device_get_context(struct libinput_device *device);
4044 * @ingroup device
4046 * Get the device group this device is assigned to. Some physical
4053 * means turning it upside down. A touch device on the same tablet would
4056 * All devices are part of a device group though for most devices the group
4057 * will be a singleton. A device is assigned to a device group on @ref
4060 * devices are in each device group.
4089 * Device groups do not get re-used once the last device in the group was
4090 * removed, i.e. unplugging and re-plugging a physical device with grouped
4091 * devices will return a different device group after every unplug.
4093 * The returned device group is not refcounted and may become invalid after
4101 * @return The device group this device belongs to
4104 libinput_device_get_device_group(struct libinput_device *device);
4107 * @ingroup device
4109 * Get the system name of the device.
4111 * To get the descriptive device name, use libinput_device_get_name().
4113 * @param device A previously obtained device
4114 * @return System name of the device
4118 libinput_device_get_sysname(struct libinput_device *device);
4121 * @ingroup device
4123 * The descriptive device name as advertised by the kernel and/or the
4124 * hardware itself. To get the sysname for this device, use
4130 * @param device A previously obtained device
4131 * @return The device name
4134 libinput_device_get_name(struct libinput_device *device);
4137 * @ingroup device
4139 * Get the product ID for this device.
4141 * @param device A previously obtained device
4142 * @return The product ID of this device
4145 libinput_device_get_id_product(struct libinput_device *device);
4148 * @ingroup device
4150 * Get the vendor ID for this device.
4152 * @param device A previously obtained device
4153 * @return The vendor ID of this device
4156 libinput_device_get_id_vendor(struct libinput_device *device);
4159 * @ingroup device
4161 * A device may be mapped to a single output, or all available outputs. If a
4162 * device is mapped to a single output only, a relative device may not move
4163 * beyond the boundaries of this output. An absolute device has its input
4168 * insufficient to map the device. Instead, the system configuration could
4170 * caller could then obtain device with libinput_device_get_udev_device()
4172 * must implement monitor-to-device association heuristics.
4174 * @return The name of the output this device is mapped to, or NULL if no
4178 libinput_device_get_output_name(struct libinput_device *device);
4181 * @ingroup device
4183 * Get the seat associated with this input device.
4188 * may be destroyed if no device belonging to it is left.
4197 * @param device A previously obtained device
4198 * @return The seat this input device belongs to
4201 libinput_device_get_seat(struct libinput_device *device);
4204 * @ingroup device
4206 * Change the logical seat associated with this device by removing the
4207 * device and adding it to the new seat.
4209 * This command is identical to physically unplugging the device, then
4216 * references to the new device accordingly.
4218 * If the logical seat name already exists in the device's physical seat,
4219 * the device is added to this seat. Otherwise, a new seat is created.
4221 * @note This change applies to this device until removal or @ref
4224 * @param device A previously obtained device
4229 libinput_device_set_seat_logical_name(struct libinput_device *device,
4233 * @ingroup device
4235 * Return a udev handle to the device that is this libinput device, if any.
4241 * Some devices may not have a udev device, or the udev device may be
4242 * unobtainable. This function returns NULL if no udev device was available.
4244 * Calling this function multiple times for the same device may not
4247 * @param device A previously obtained device
4248 * @return A udev handle to the device with a refcount of >= 1 or NULL.
4249 * @retval NULL This device is not represented by a udev device
4252 libinput_device_get_udev_device(struct libinput_device *device);
4255 * @ingroup device
4257 * Update the LEDs on the device, if any. If the device does not have
4261 * @param device A previously obtained device
4265 libinput_device_led_update(struct libinput_device *device,
4269 * @ingroup device
4271 * Check if the given device has the specified capability
4273 * @return Non-zero if the given device has the capability or zero otherwise
4276 libinput_device_has_capability(struct libinput_device *device,
4280 * @ingroup device
4282 * Get the physical size of a device in mm, where meaningful. This function
4288 * @param device The device
4289 * @param width Set to the width of the device
4290 * @param height Set to the height of the device
4294 libinput_device_get_size(struct libinput_device *device,
4299 * @ingroup device
4301 * Check if a @ref LIBINPUT_DEVICE_CAP_POINTER device has a button with the
4304 * @param device A current input device
4307 * @return 1 if the device supports this button code, 0 if it does not, -1
4311 libinput_device_pointer_has_button(struct libinput_device *device, uint32_t code);
4314 * @ingroup device
4316 * Check if a @ref LIBINPUT_DEVICE_CAP_KEYBOARD device has a key with the
4319 * @param device A current input device
4322 * @return 1 if the device supports this key code, 0 if it does not, -1
4326 libinput_device_keyboard_has_key(struct libinput_device *device,
4330 * @ingroup device
4332 * Check how many touches a @ref LIBINPUT_DEVICE_CAP_TOUCH device supports
4335 * @param device A current input device
4343 libinput_device_touch_get_touch_count(struct libinput_device *device);
4346 * @ingroup device
4348 * Check if a @ref LIBINPUT_DEVICE_CAP_SWITCH device has a switch of the
4351 * @param device A current input device
4354 * @return 1 if the device supports this switch, 0 if it does not, -1
4360 libinput_device_switch_has_switch(struct libinput_device *device,
4364 * @ingroup device
4366 * Return the number of buttons on a device with the
4368 * Buttons on a pad device are numbered sequentially, see the
4371 * @param device A current input device
4373 * @return The number of buttons supported by the device. -1 on error.
4378 libinput_device_tablet_pad_get_num_buttons(struct libinput_device *device);
4381 * @ingroup device
4383 * Return the number of rings a device with the @ref
4386 * @param device A current input device
4388 * @return The number of rings or 0 if the device has no rings. -1 on error.
4395 libinput_device_tablet_pad_get_num_rings(struct libinput_device *device);
4398 * @ingroup device
4400 * Return the number of strips a device with the @ref
4403 * @param device A current input device
4405 * @return The number of strips or 0 if the device has no strips. -1 on error.
4412 libinput_device_tablet_pad_get_num_strips(struct libinput_device *device);
4415 * @ingroup device
4417 * Check if a @ref LIBINPUT_DEVICE_CAP_TABLET_PAD device has a key with the
4420 * @param device A current input device
4423 * @return 1 if the device supports this key code, 0 if it does not, -1
4429 libinput_device_tablet_pad_has_key(struct libinput_device *device,
4433 * @ingroup device
4435 * Increase the refcount of the device group. A device group will be freed
4438 * system. A caller must ensure to reference the device group correctly to
4441 * @param group A previously obtained device group
4442 * @return The passed device group
4448 * @ingroup device
4450 * Decrease the refcount of the device group. A device group will be freed
4453 * system. A caller must ensure to reference the device group correctly to
4456 * @param group A previously obtained device group
4457 * @return NULL if the device group was destroyed, otherwise the passed
4458 * device group
4464 * @ingroup device
4466 * Set caller-specific data associated with this device group. libinput does
4470 * @param group A previously obtained device group
4479 * @ingroup device
4481 * Get the caller-specific data associated with this input device group, if
4494 * Enable, disable, change and/or check for device-specific features. For
4499 * Configuration options are device dependent and not all options are
4502 * device (e.g. libinput_device_config_calibration_has_matrix())
4509 * Below is a general grouping of configuration options according to device
4511 * device.
4540 this device */
4569 * Check if the device supports tap-to-click and how many fingers can be
4573 * @param device The device to configure
4575 * device does not support tapping.
4582 libinput_device_config_tap_get_finger_count(struct libinput_device *device);
4587 * Enable or disable tap-to-click on this device, with a default mapping of
4590 * supported by the device, see
4593 * @param device The device to configure
4597 * @return A config status code. Disabling tapping on a device that does not
4605 libinput_device_config_tap_set_enabled(struct libinput_device *device,
4611 * Check if tap-to-click is enabled on this device. If the device does not
4615 * @param device The device to configure
4625 libinput_device_config_tap_get_enabled(struct libinput_device *device);
4631 * device.
4633 * @param device The device to configure
4642 libinput_device_config_tap_get_default_enabled(struct libinput_device *device);
4662 * A device may permit changing the button mapping but disallow specific
4667 * the device may wait until it is in a neutral state before applying any
4676 * @param device The device to configure
4678 * @return A config status code. Changing the order on a device that does not
4687 libinput_device_config_tap_set_button_map(struct libinput_device *device,
4695 * The return value for a device that does not support tapping is always
4701 * @param device The device to configure
4710 libinput_device_config_tap_get_button_map(struct libinput_device *device);
4717 * The return value for a device that does not support tapping is always
4723 * @param device The device to configure
4732 libinput_device_config_tap_get_default_button_map(struct libinput_device *device);
4737 * A config status to distinguish or set dragging on a device. Currently
4759 * Enable or disable tap-and-drag on this device. When enabled, a
4764 * @param device The device to configure
4774 libinput_device_config_tap_set_drag_enabled(struct libinput_device *device,
4780 * Return whether tap-and-drag is enabled or disabled on this device.
4782 * @param device The device to check
4793 libinput_device_config_tap_get_drag_enabled(struct libinput_device *device);
4799 * device.
4801 * @param device The device to check
4813 libinput_device_config_tap_get_default_drag_enabled(struct libinput_device *device);
4828 * Enable or disable drag-lock during tapping on this device. When enabled,
4834 * Enabling drag lock on a device that has tapping disabled is permitted,
4837 * @param device The device to configure
4841 * @return A config status code. Disabling drag lock on a device that does not
4848 libinput_device_config_tap_set_drag_lock_enabled(struct libinput_device *device,
4854 * Check if drag-lock during tapping is enabled on this device. If the
4855 * device does not support tapping, this function always returns
4860 * @param device The device to configure
4869 libinput_device_config_tap_get_drag_lock_enabled(struct libinput_device *device);
4874 * Check if drag-lock during tapping is enabled by default on this device.
4875 * If the device does not support tapping, this function always returns
4881 * @param device The device to configure
4892 libinput_device_config_tap_get_default_drag_lock_enabled(struct libinput_device *device);
4897 * Check if the device can be calibrated via a calibration matrix.
4899 * @param device The device to check
4900 * @return Non-zero if the device can be calibrated, zero otherwise.
4907 libinput_device_config_calibration_has_matrix(struct libinput_device *device);
4912 * Apply the 3x3 transformation matrix to absolute device coordinates. This
4923 * device coordinate range. For example, the matrix
4929 * moves all coordinates by 1 device-width to the right and 1 device-height
4939 * translate the rotated coordinates back into the original device space.
4948 * @param device The device to configure
4959 libinput_device_config_calibration_set_matrix(struct libinput_device *device,
4965 * Return the current calibration matrix for this device.
4967 * @param device The device to configure
4979 libinput_device_config_calibration_get_matrix(struct libinput_device *device,
4985 * Return the default calibration matrix for this device. On most devices,
4987 * <b>LIBINPUT_CALIBRATION_MATRIX</b> is set on the respective udev device,
4991 * @param device The device to configure
5003 libinput_device_config_calibration_get_default_matrix(struct libinput_device *device,
5009 * The send-event mode of a device defines when a device may generate events
5014 * Send events from this device normally. This is a placeholder
5015 * mode only, any device detected by libinput can be enabled. Do not
5020 * Do not send events through this device. Depending on the device,
5021 * this may close all file descriptors on the device or it may leave
5023 * device.
5029 * the device remains disabled when all external pointer devices are
5034 * If an external pointer device is plugged in, do not send events
5035 * from this device. This option may be available on built-in
5044 * Return the possible send-event modes for this device. These modes define
5045 * when a device may process and send events.
5047 * @param device The device to configure
5056 libinput_device_config_send_events_get_modes(struct libinput_device *device);
5061 * Set the send-event mode for this device. The mode defines when the device
5065 * received and processed from this device are unaffected and will be passed
5069 * the device may wait for or generate events until it is in a neutral
5073 * If the device is already suspended, this function does nothing and
5074 * returns success. Changing the send-event mode on a device that has been
5077 * @param device The device to configure
5087 libinput_device_config_send_events_set_mode(struct libinput_device *device,
5093 * Get the send-event mode for this device. The mode defines when the device
5102 * @param device The device to configure
5103 * @return The current bitmask of the send-event mode for this device.
5110 libinput_device_config_send_events_get_mode(struct libinput_device *device);
5115 * Get the default send-event mode for this device. The mode defines when
5116 * the device processes and sends events to the caller.
5118 * @param device The device to configure
5119 * @return The bitmask of the send-event mode for this device.
5126 libinput_device_config_send_events_get_default_mode(struct libinput_device *device);
5131 * Check if a device uses libinput-internal pointer-acceleration.
5133 * @param device The device to configure
5135 * @return 0 if the device is not accelerated, nonzero if it is accelerated
5142 libinput_device_config_accel_is_available(struct libinput_device *device);
5147 * Set the pointer acceleration speed of this pointer device within a range
5148 * of [-1, 1], where 0 is the default acceleration for this device, -1 is
5150 * this device. The actual pointer acceleration mechanism is
5155 * @param device The device to configure
5165 libinput_device_config_accel_set_speed(struct libinput_device *device,
5171 * Get the current pointer acceleration setting for this pointer device. The
5177 * device will not change but future calls to
5181 * @param device The device to configure
5190 libinput_device_config_accel_get_speed(struct libinput_device *device);
5195 * Return the default speed setting for this device, normalized to a range
5199 * @param device The device to configure
5200 * @return The default speed setting for this device.
5207 libinput_device_config_accel_get_default_speed(struct libinput_device *device);
5222 * constant (device-specific) factor, depending on the current
5264 * Once set up, apply the configuration to a device using
5316 * Apply this pointer acceleration configuration to the device. This changes the
5317 * device's pointer acceleration method to the method given in
5323 * @param device The device to configure.
5332 libinput_device_config_accel_apply(struct libinput_device *device,
5338 * Acceleration types are categories of movement by a device that may have
5339 * specific acceleration functions applied. A device always supports the
5344 * function to be moved for any movement produced by the device that does not
5350 * Each device implements a subset of those types, see a list of supported
5381 * Movement types are specific to each device, @see libinput_config_accel_type.
5387 * The x-axis represents the device-speed in device units per millisecond.
5390 * It is up to the user to define those values in accordance with device DPI
5413 * this device.
5415 * @param device The device to configure
5417 * @return A bitmask of all configurable modes available on this device.
5422 libinput_device_config_accel_get_profiles(struct libinput_device *device);
5427 * Set the pointer acceleration profile of this pointer device to the given
5430 * @param device The device to configure
5431 * @param profile The profile to set the device to.
5438 libinput_device_config_accel_set_profile(struct libinput_device *device,
5444 * Get the current pointer acceleration profile for this pointer device.
5446 * @param device The device to configure
5453 libinput_device_config_accel_get_profile(struct libinput_device *device);
5458 * Return the default pointer acceleration profile for this pointer device.
5460 * @param device The device to configure
5462 * @return The default acceleration profile for this device.
5467 libinput_device_config_accel_get_default_profile(struct libinput_device *device);
5472 * Return non-zero if the device supports "natural scrolling".
5486 * A device supporting natural scrolling can be switched between traditional
5489 * @param device The device to configure
5492 * scrolling is supported by this device
5499 libinput_device_config_scroll_has_natural_scroll(struct libinput_device *device);
5504 * Enable or disable natural scrolling on the device.
5506 * @param device The device to configure
5516 libinput_device_config_scroll_set_natural_scroll_enabled(struct libinput_device *device,
5521 * Get the current mode for scrolling on this device
5523 * @param device The device to configure
5532 libinput_device_config_scroll_get_natural_scroll_enabled(struct libinput_device *device);
5537 * Get the default mode for scrolling on this device
5539 * @param device The device to configure
5548 libinput_device_config_scroll_get_default_natural_scroll_enabled(struct libinput_device *device);
5553 * Check if a device has a configuration that supports left-handed usage.
5555 * @param device The device to configure
5556 * @return Non-zero if the device can be set to left-handed, or zero
5564 libinput_device_config_left_handed_is_available(struct libinput_device *device);
5569 * Set the left-handed configuration of the device.
5571 * The exact behavior is device-dependent. On a mouse and most pointing
5578 * Changing the left-handed configuration of a device may not take effect
5581 * @param device The device to configure
5590 libinput_device_config_left_handed_set(struct libinput_device *device,
5596 * Get the current left-handed configuration of the device.
5598 * @param device The device to configure
5599 * @return Zero if the device is in right-handed mode, non-zero if the
5600 * device is in left-handed mode
5607 libinput_device_config_left_handed_get(struct libinput_device *device);
5612 * Get the default left-handed configuration of the device.
5614 * @param device The device to configure
5615 * @return Zero if the device is in right-handed mode by default, or non-zero
5616 * if the device is in left-handed mode by default
5623 libinput_device_config_left_handed_get_default(struct libinput_device *device);
5629 * buttons, usually on a device that does not have a specific physical
5651 * Check which button click methods a device supports. The button click
5653 * device that does not have a specific physical button available.
5655 * @param device The device to configure
5664 libinput_device_config_click_get_methods(struct libinput_device *device);
5669 * Set the button click method for this device. The button click
5671 * device that does not have a specific physical button available.
5674 * device may require changing to a neutral state first before activating
5677 * @param device The device to configure
5687 libinput_device_config_click_set_method(struct libinput_device *device,
5692 * Get the button click method for this device. The button click
5694 * device that does not have a specific physical button available.
5696 * @param device The device to configure
5698 * @return The current button click method for this device
5705 libinput_device_config_click_get_method(struct libinput_device *device);
5710 * Get the default button click method for this device. The button click
5712 * device that does not have a specific physical button available.
5714 * @param device The device to configure
5716 * @return The default button click method for this device
5723 libinput_device_config_click_get_default_method(struct libinput_device *device);
5745 * device. See libinput_device_config_middle_emulation_set_enabled() for
5752 * @param device The device to query
5763 struct libinput_device *device);
5768 * Enable or disable middle button emulation on this device. When enabled, a
5775 * @param device The device to configure
5781 * device that does not support middle button emulation always succeeds.
5789 struct libinput_device *device,
5795 * Check if configurable middle button emulation is enabled on this device.
5799 * If the device does not have configurable middle button emulation, this
5806 * @param device The device to configure
5817 struct libinput_device *device);
5823 * this device. See libinput_device_config_middle_emulation_set_enabled()
5826 * If the device does not have configurable middle button
5834 * @param device The device to configure
5845 struct libinput_device *device);
5850 * The scroll method of a device selects when to generate scroll axis events
5861 * device.
5866 * right edge of a device.
5870 * Send scroll events when a button is down and the device moves
5879 * Check which scroll methods a device supports. The method defines when to
5882 * @param device The device to configure
5894 libinput_device_config_scroll_get_methods(struct libinput_device *device);
5899 * Set the scroll method for this device. The method defines when to
5908 * @param device The device to configure
5909 * @param method The scroll method for this device.
5921 libinput_device_config_scroll_set_method(struct libinput_device *device,
5927 * Get the scroll method for this device. The method defines when to
5930 * @param device The device to configure
5931 * @return The current scroll method for this device.
5941 libinput_device_config_scroll_get_method(struct libinput_device *device);
5946 * Get the default scroll method for this device. The method defines when to
5949 * @param device The device to configure
5950 * @return The default scroll method for this device.
5960 libinput_device_config_scroll_get_default_method(struct libinput_device *device);
5966 * for this device.
5980 * @param device The device to configure
5988 * exist on this device
5998 libinput_device_config_scroll_set_button(struct libinput_device *device,
6005 * for this device.
6011 * scroll-method. For button scrolling to activate, a device must have the
6015 * @param device The device to configure
6026 libinput_device_config_scroll_get_button(struct libinput_device *device);
6032 * method for this device.
6037 * @param device The device to configure
6049 libinput_device_config_scroll_get_default_button(struct libinput_device *device);
6067 * @param device The device to configure
6071 * device that does not support button scrolling always succeeds.
6078 libinput_device_config_scroll_set_button_lock(struct libinput_device *device,
6091 * scroll-method. For the scroll button lock to activate, a device must have
6095 * @param device The device to configure
6104 libinput_device_config_scroll_get_button_lock(struct libinput_device *device);
6115 * @param device The device to configure
6124 libinput_device_config_scroll_get_default_button_lock(struct libinput_device *device);
6139 * Check if this device supports configurable disable-while-typing feature.
6143 * @param device The device to configure
6144 * @return 0 if this device does not support disable-while-typing, or 1
6152 libinput_device_config_dwt_is_available(struct libinput_device *device);
6158 * device will be disabled while typing and for a short period after. See
6164 * @param device The device to configure
6169 * device that does not support the feature always succeeds.
6176 libinput_device_config_dwt_set_enabled(struct libinput_device *device,
6183 * device. If the device does not support disable-while-typing, this
6186 * @param device The device to configure
6195 libinput_device_config_dwt_get_enabled(struct libinput_device *device);
6200 * Check if the disable-while typing feature is enabled on this device by
6201 * default. If the device does not support disable-while-typing, this
6204 * @param device The device to configure
6213 libinput_device_config_dwt_get_default_enabled(struct libinput_device *device);
6230 * Check if this device supports configurable disable-while-trackpointing
6235 * @param device The device to configure
6236 * @return 0 if this device does not support disable-while-trackpointing, or 1
6246 libinput_device_config_dwtp_is_available(struct libinput_device *device);
6252 * device will be disabled while using the trackpoint and for a short period
6258 * @param device The device to configure
6263 * device that does not support the feature always succeeds.
6272 libinput_device_config_dwtp_set_enabled(struct libinput_device *device,
6279 * this device. If the device does not support disable-while-trackpointing,
6282 * @param device The device to configure
6293 libinput_device_config_dwtp_get_enabled(struct libinput_device *device);
6298 * Check if the disable-while trackpointing feature is enabled on this device
6299 * by default. If the device does not support disable-while-trackpointing, this
6302 * @param device The device to configure
6313 libinput_device_config_dwtp_get_default_enabled(struct libinput_device *device);
6318 * Check whether a device can have a custom rotation applied.
6320 * @param device The device to configure
6321 * @return Non-zero if a device can be rotated, zero otherwise.
6330 libinput_device_config_rotation_is_available(struct libinput_device *device);
6335 * Set the rotation of a device in degrees clockwise off the logical neutral
6344 * The rotation angle is applied to all motion events emitted by the device.
6345 * Thus, rotating the device also changes the angle required or presented by
6348 * @param device The device to configure
6351 * device that does not support rotation always succeeds.
6360 libinput_device_config_rotation_set_angle(struct libinput_device *device,
6366 * Get the current rotation of a device in degrees clockwise off the logical
6367 * neutral position. If this device does not support rotation, the return
6370 * @param device The device to configure
6380 libinput_device_config_rotation_get_angle(struct libinput_device *device);
6385 * Get the default rotation of a device in degrees clockwise off the logical
6386 * neutral position. If this device does not support rotation, the return
6389 * @param device The device to configure
6399 libinput_device_config_rotation_get_default_angle(struct libinput_device *device);