From 1e860c98d38fe0d96db41c4909a8a3925261e4ea Mon Sep 17 00:00:00 2001 From: Peter Hutterer Date: Wed, 3 Apr 2019 09:21:52 +1000 Subject: [PATCH] doc/api: add since tags to all functions after 1.0 Signed-off-by: Peter Hutterer (cherry picked from commit 4bb2899d005d97c9bc0798b344b49d676ec3dd71) --- src/libinput.h | 244 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 244 insertions(+) diff --git a/src/libinput.h b/src/libinput.h index 01cdf737..859d3d4c 100644 --- a/src/libinput.h +++ b/src/libinput.h @@ -90,6 +90,8 @@ struct libinput_seat; * * This struct is refcounted, use libinput_tablet_tool_ref() and * libinput_tablet_tool_unref(). + * + * @since 1.2 */ struct libinput_tablet_tool; @@ -151,6 +153,8 @@ struct libinput_event_touch; * LIBINPUT_EVENT_TABLET_TOOL_AXIS, @ref * LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY and @ref * LIBINPUT_EVENT_TABLET_TOOL_BUTTON. + * + * @since 1.2 */ struct libinput_event_tablet_tool; @@ -162,6 +166,8 @@ struct libinput_event_tablet_tool; * the tablet pad itself. Valid event types for this event are @ref * LIBINPUT_EVENT_TABLET_PAD_BUTTON, @ref LIBINPUT_EVENT_TABLET_PAD_RING and * @ref LIBINPUT_EVENT_TABLET_PAD_STRIP. + * + * @since 1.3 */ struct libinput_event_tablet_pad; @@ -275,6 +281,8 @@ enum libinput_pointer_axis_source { * * The source for a @ref LIBINPUT_EVENT_TABLET_PAD_RING event. See * libinput_event_tablet_pad_get_ring_source() for details. + * + * @since 1.3 */ enum libinput_tablet_pad_ring_axis_source { LIBINPUT_TABLET_PAD_RING_SOURCE_UNKNOWN = 1, @@ -290,6 +298,8 @@ enum libinput_tablet_pad_ring_axis_source { * * The source for a @ref LIBINPUT_EVENT_TABLET_PAD_STRIP event. See * libinput_event_tablet_pad_get_strip_source() for details. + * + * @since 1.3 */ enum libinput_tablet_pad_strip_axis_source { LIBINPUT_TABLET_PAD_STRIP_SOURCE_UNKNOWN = 1, @@ -319,6 +329,8 @@ enum libinput_tablet_pad_strip_axis_source { * type of the device. For devices with adjustable physical properties * the tool type remains the same, i.e. putting a Wacom stroke nib into a * classic pen leaves the tool type as @ref LIBINPUT_TABLET_TOOL_TYPE_PEN. + * + * @since 1.2 */ enum libinput_tablet_tool_type { LIBINPUT_TABLET_TOOL_TYPE_PEN = 1, /**< A generic pen */ @@ -344,6 +356,8 @@ enum libinput_tablet_tool_type { * On some hardware a tool goes out of proximity when it ceases to touch the * surface. On other hardware, the tool is still detectable within a short * distance (a few cm) off the surface. + * + * @since 1.2 */ enum libinput_tablet_tool_proximity_state { LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_OUT = 0, @@ -358,6 +372,8 @@ enum libinput_tablet_tool_proximity_state { * * The tip contact state of a tool is a binary state signalling whether the tool is * touching the surface of the tablet device. + * + * @since 1.2 */ enum libinput_tablet_tool_tip_state { LIBINPUT_TABLET_TOOL_TIP_UP = 0, @@ -388,6 +404,8 @@ enum libinput_tablet_tool_tip_state { * * This struct is refcounted, use libinput_tablet_pad_mode_group_ref() and * libinput_tablet_pad_mode_group_unref(). + * + * @since 1.4 */ struct libinput_tablet_pad_mode_group; @@ -403,6 +421,8 @@ struct libinput_tablet_pad_mode_group; * ring and strip with the correct mode group. * * @return the number of mode groups available on this device + * + * @since 1.4 */ int libinput_device_tablet_pad_get_num_mode_groups(struct libinput_device *device); @@ -426,6 +446,8 @@ libinput_device_tablet_pad_get_num_mode_groups(struct libinput_device *device); * @param index A mode group index * @return the mode group with the given index or NULL if an invalid index * is given. + * + * @since 1.4 */ struct libinput_tablet_pad_mode_group* libinput_device_tablet_pad_get_mode_group(struct libinput_device *device, @@ -440,6 +462,8 @@ libinput_device_tablet_pad_get_mode_group(struct libinput_device *device, * * @param group A previously obtained mode group * @return the numeric index this mode group represents, starting at 0 + * + * @since 1.4 */ unsigned int libinput_tablet_pad_mode_group_get_index(struct libinput_tablet_pad_mode_group *group); @@ -458,6 +482,8 @@ libinput_tablet_pad_mode_group_get_index(struct libinput_tablet_pad_mode_group * * * @param group A previously obtained mode group * @return the number of modes available in this mode group + * + * @since 1.4 */ unsigned int libinput_tablet_pad_mode_group_get_num_modes(struct libinput_tablet_pad_mode_group *group); @@ -478,6 +504,8 @@ libinput_tablet_pad_mode_group_get_num_modes(struct libinput_tablet_pad_mode_gro * @return the numeric index of the current mode in this group, starting at 0 * * @see libinput_event_tablet_pad_get_mode + * + * @since 1.4 */ unsigned int libinput_tablet_pad_mode_group_get_mode(struct libinput_tablet_pad_mode_group *group); @@ -491,6 +519,8 @@ libinput_tablet_pad_mode_group_get_mode(struct libinput_tablet_pad_mode_group *g * @param button A button index, starting at 0 * @return true if the given button index is part of this mode group or * false otherwise + * + * @since 1.4 */ int libinput_tablet_pad_mode_group_has_button(struct libinput_tablet_pad_mode_group *group, @@ -505,6 +535,8 @@ libinput_tablet_pad_mode_group_has_button(struct libinput_tablet_pad_mode_group * @param ring A ring index, starting at 0 * @return true if the given ring index is part of this mode group or * false otherwise + * + * @since 1.4 */ int libinput_tablet_pad_mode_group_has_ring(struct libinput_tablet_pad_mode_group *group, @@ -519,6 +551,8 @@ libinput_tablet_pad_mode_group_has_ring(struct libinput_tablet_pad_mode_group *g * @param strip A strip index, starting at 0 * @return true if the given strip index is part of this mode group or * false otherwise + * + * @since 1.4 */ int libinput_tablet_pad_mode_group_has_strip(struct libinput_tablet_pad_mode_group *group, @@ -539,6 +573,8 @@ libinput_tablet_pad_mode_group_has_strip(struct libinput_tablet_pad_mode_group * * @param button A button index, starting at 0 * @retval non-zero if the button is a mode toggle button for this group, or * zero otherwise + * + * @since 1.4 */ int libinput_tablet_pad_mode_group_button_is_toggle(struct libinput_tablet_pad_mode_group *group, @@ -552,6 +588,8 @@ libinput_tablet_pad_mode_group_button_is_toggle(struct libinput_tablet_pad_mode_ * * @param group A previously obtained mode group * @return The passed mode group + * + * @since 1.4 */ struct libinput_tablet_pad_mode_group * libinput_tablet_pad_mode_group_ref( @@ -565,6 +603,8 @@ libinput_tablet_pad_mode_group_ref( * * @param group A previously obtained mode group * @return NULL if the group was destroyed, otherwise the passed mode group + * + * @since 1.4 */ struct libinput_tablet_pad_mode_group * libinput_tablet_pad_mode_group_unref( @@ -581,6 +621,7 @@ libinput_tablet_pad_mode_group_unref( * @param user_data Caller-specific data pointer * @see libinput_tablet_pad_mode_group_get_user_data * + * @since 1.4 */ void libinput_tablet_pad_mode_group_set_user_data( @@ -595,6 +636,8 @@ libinput_tablet_pad_mode_group_set_user_data( * @param group A previously obtained mode group * @return Caller-specific data pointer or NULL if none was set * @see libinput_tablet_pad_mode_group_set_user_data + * + * @since 1.4 */ void * libinput_tablet_pad_mode_group_get_user_data( @@ -608,6 +651,8 @@ libinput_tablet_pad_mode_group_get_user_data( * off position. If a switch is logically on during initialization, libinput * sends an event of type @ref LIBINPUT_EVENT_SWITCH_TOGGLE with a state * @ref LIBINPUT_SWITCH_STATE_ON. + * + * @since 1.7 */ enum libinput_switch_state { LIBINPUT_SWITCH_STATE_OFF = 0, @@ -618,6 +663,8 @@ enum libinput_switch_state { * @ingroup device * * The type of a switch. + * + * @since 1.7 */ enum libinput_switch { /** @@ -649,6 +696,8 @@ enum libinput_switch { * @struct libinput_event_switch * * A switch event representing a changed state in a switch. + * + * @since 1.7 */ struct libinput_event_switch; @@ -714,6 +763,8 @@ enum libinput_event_type { * An event of type @ref LIBINPUT_EVENT_TABLET_TOOL_AXIS is sent * when the tip state does not change. See the documentation for * @ref LIBINPUT_EVENT_TABLET_TOOL_TIP for more details. + * + * @since 1.2 */ LIBINPUT_EVENT_TABLET_TOOL_AXIS = 600, /** @@ -739,6 +790,8 @@ enum libinput_event_type { * down on the stylus are marked as released. Button release events for * each button that was held down on the stylus are sent before the * proximity out event. + * + * @since 1.2 */ LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY, /** @@ -762,6 +815,8 @@ enum libinput_event_type { * * If a button state change occurs at the same time as a tip state * change, the order of events is device-dependent. + * + * @since 1.2 */ LIBINPUT_EVENT_TABLET_TOOL_TIP, /** @@ -778,6 +833,8 @@ enum libinput_event_type { * by the tablet pad. See @ref LIBINPUT_EVENT_TABLET_PAD_BUTTON. * * @see LIBINPUT_EVENT_TABLET_BUTTON + * + * @since 1.2 */ LIBINPUT_EVENT_TABLET_TOOL_BUTTON, @@ -787,17 +844,23 @@ enum libinput_event_type { * * This event is not to be confused with the button events emitted * by tools on a tablet (@ref LIBINPUT_EVENT_TABLET_TOOL_BUTTON). + * + * @since 1.3 */ LIBINPUT_EVENT_TABLET_PAD_BUTTON = 700, /** * A status change on a tablet ring with the @ref * LIBINPUT_DEVICE_CAP_TABLET_PAD capability. + * + * @since 1.3 */ LIBINPUT_EVENT_TABLET_PAD_RING, /** * A status change on a strip on a device with the @ref * LIBINPUT_DEVICE_CAP_TABLET_PAD capability. + * + * @since 1.3 */ LIBINPUT_EVENT_TABLET_PAD_STRIP, @@ -808,6 +871,9 @@ enum libinput_event_type { LIBINPUT_EVENT_GESTURE_PINCH_UPDATE, LIBINPUT_EVENT_GESTURE_PINCH_END, + /** + * @since 1.7 + */ LIBINPUT_EVENT_SWITCH_TOGGLE = 900, }; @@ -935,6 +1001,8 @@ libinput_event_get_gesture_event(struct libinput_event *event); * The inverse of this function is libinput_event_tablet_tool_get_base_event(). * * @return A tablet tool event, or NULL for other events + * + * @since 1.2 */ struct libinput_event_tablet_tool * libinput_event_get_tablet_tool_event(struct libinput_event *event); @@ -961,6 +1029,8 @@ libinput_event_get_tablet_pad_event(struct libinput_event *event); * The inverse of this function is libinput_event_switch_get_base_event(). * * @return A switch event, or NULL for other events + * + * @since 1.7 */ struct libinput_event_switch * libinput_event_get_switch_event(struct libinput_event *event); @@ -1823,6 +1893,8 @@ libinput_event_gesture_get_angle_delta(struct libinput_event_gesture *event); * @ingroup event_tablet * * @return The generic libinput_event of this event + * + * @since 1.2 */ struct libinput_event * libinput_event_tablet_tool_get_base_event(struct libinput_event_tablet_tool *event); @@ -1843,6 +1915,8 @@ libinput_event_tablet_tool_get_base_event(struct libinput_event_tablet_tool *eve * * @param event The libinput tablet tool event * @return 1 if the axis was updated or 0 otherwise + * + * @since 1.2 */ int libinput_event_tablet_tool_x_has_changed( @@ -1864,6 +1938,8 @@ libinput_event_tablet_tool_x_has_changed( * * @param event The libinput tablet tool event * @return 1 if the axis was updated or 0 otherwise + * + * @since 1.2 */ int libinput_event_tablet_tool_y_has_changed( @@ -1885,6 +1961,8 @@ libinput_event_tablet_tool_y_has_changed( * * @param event The libinput tablet tool event * @return 1 if the axis was updated or 0 otherwise + * + * @since 1.2 */ int libinput_event_tablet_tool_pressure_has_changed( @@ -1908,6 +1986,8 @@ libinput_event_tablet_tool_pressure_has_changed( * * @param event The libinput tablet tool event * @return 1 if the axis was updated or 0 otherwise + * + * @since 1.2 */ int libinput_event_tablet_tool_distance_has_changed( @@ -1929,6 +2009,8 @@ libinput_event_tablet_tool_distance_has_changed( * * @param event The libinput tablet tool event * @return 1 if the axis was updated or 0 otherwise + * + * @since 1.2 */ int libinput_event_tablet_tool_tilt_x_has_changed( @@ -1950,6 +2032,8 @@ libinput_event_tablet_tool_tilt_x_has_changed( * * @param event The libinput tablet tool event * @return 1 if the axis was updated or 0 otherwise + * + * @since 1.2 */ int libinput_event_tablet_tool_tilt_y_has_changed( @@ -1970,6 +2054,8 @@ libinput_event_tablet_tool_tilt_y_has_changed( * * @param event The libinput tablet tool event * @return 1 if the axis was updated or 0 otherwise + * + * @since 1.2 */ int libinput_event_tablet_tool_rotation_has_changed( @@ -1990,6 +2076,8 @@ libinput_event_tablet_tool_rotation_has_changed( * * @param event The libinput tablet tool event * @return 1 if the axis was updated or 0 otherwise + * + * @since 1.2 */ int libinput_event_tablet_tool_slider_has_changed( @@ -2010,6 +2098,8 @@ libinput_event_tablet_tool_slider_has_changed( * * @param event The libinput tablet tool event * @return 1 if the axis was updated or 0 otherwise + * + * @since 1.2 */ int libinput_event_tablet_tool_wheel_has_changed( @@ -2028,6 +2118,8 @@ libinput_event_tablet_tool_wheel_has_changed( * * @param event The libinput tablet tool event * @return The current value of the the axis + * + * @since 1.2 */ double libinput_event_tablet_tool_get_x(struct libinput_event_tablet_tool *event); @@ -2045,6 +2137,8 @@ libinput_event_tablet_tool_get_x(struct libinput_event_tablet_tool *event); * * @param event The libinput tablet tool event * @return The current value of the the axis + * + * @since 1.2 */ double libinput_event_tablet_tool_get_y(struct libinput_event_tablet_tool *event); @@ -2062,6 +2156,8 @@ libinput_event_tablet_tool_get_y(struct libinput_event_tablet_tool *event); * * @param event The libinput tablet event * @return The relative x movement since the last event + * + * @since 1.2 */ double libinput_event_tablet_tool_get_dx(struct libinput_event_tablet_tool *event); @@ -2079,6 +2175,8 @@ libinput_event_tablet_tool_get_dx(struct libinput_event_tablet_tool *event); * * @param event The libinput tablet event * @return The relative y movement since the last event + * + * @since 1.2 */ double libinput_event_tablet_tool_get_dy(struct libinput_event_tablet_tool *event); @@ -2093,6 +2191,8 @@ libinput_event_tablet_tool_get_dy(struct libinput_event_tablet_tool *event); * * @param event The libinput tablet tool event * @return The current value of the the axis + * + * @since 1.2 */ double libinput_event_tablet_tool_get_pressure(struct libinput_event_tablet_tool *event); @@ -2107,6 +2207,8 @@ libinput_event_tablet_tool_get_pressure(struct libinput_event_tablet_tool *event * * @param event The libinput tablet tool event * @return The current value of the the axis + * + * @since 1.2 */ double libinput_event_tablet_tool_get_distance(struct libinput_event_tablet_tool *event); @@ -2125,6 +2227,8 @@ libinput_event_tablet_tool_get_distance(struct libinput_event_tablet_tool *event * * @param event The libinput tablet tool event * @return The current value of the axis in degrees + * + * @since 1.2 */ double libinput_event_tablet_tool_get_tilt_x(struct libinput_event_tablet_tool *event); @@ -2143,6 +2247,8 @@ libinput_event_tablet_tool_get_tilt_x(struct libinput_event_tablet_tool *event); * * @param event The libinput tablet tool event * @return The current value of the the axis in degrees + * + * @since 1.2 */ double libinput_event_tablet_tool_get_tilt_y(struct libinput_event_tablet_tool *event); @@ -2163,6 +2269,8 @@ libinput_event_tablet_tool_get_tilt_y(struct libinput_event_tablet_tool *event); * * @param event The libinput tablet tool event * @return The current value of the the axis + * + * @since 1.2 */ double libinput_event_tablet_tool_get_rotation(struct libinput_event_tablet_tool *event); @@ -2179,6 +2287,8 @@ libinput_event_tablet_tool_get_rotation(struct libinput_event_tablet_tool *event * * @param event The libinput tablet tool event * @return The current value of the the axis + * + * @since 1.2 */ double libinput_event_tablet_tool_get_slider_position(struct libinput_event_tablet_tool *event); @@ -2206,6 +2316,8 @@ libinput_event_tablet_tool_get_wheel_delta( * @return The delta of the wheel, in discrete steps, compared to the last event * * @see libinput_event_tablet_tool_get_wheel_delta_discrete + * + * @since 1.2 */ int libinput_event_tablet_tool_get_wheel_delta_discrete( @@ -2227,6 +2339,8 @@ libinput_event_tablet_tool_get_wheel_delta_discrete( * @param event The libinput tablet tool event * @param width The current output screen width * @return the current absolute x coordinate transformed to a screen coordinate + * + * @since 1.2 */ double libinput_event_tablet_tool_get_x_transformed(struct libinput_event_tablet_tool *event, @@ -2248,6 +2362,8 @@ libinput_event_tablet_tool_get_x_transformed(struct libinput_event_tablet_tool * * @param event The libinput tablet tool event * @param height The current output screen height * @return the current absolute y coordinate transformed to a screen coordinate + * + * @since 1.2 */ double libinput_event_tablet_tool_get_y_transformed(struct libinput_event_tablet_tool *event, @@ -2272,6 +2388,8 @@ libinput_event_tablet_tool_get_y_transformed(struct libinput_event_tablet_tool * * * @param event The libinput tablet tool event * @return The new tool triggering this event + * + * @since 1.2 */ struct libinput_tablet_tool * libinput_event_tablet_tool_get_tool(struct libinput_event_tablet_tool *event); @@ -2299,6 +2417,8 @@ libinput_event_tablet_tool_get_tool(struct libinput_event_tablet_tool *event); * * @param event The libinput tablet tool event * @return The new proximity state of the tool from the event. + * + * @since 1.2 */ enum libinput_tablet_tool_proximity_state libinput_event_tablet_tool_get_proximity_state(struct libinput_event_tablet_tool *event); @@ -2313,6 +2433,8 @@ libinput_event_tablet_tool_get_proximity_state(struct libinput_event_tablet_tool * * @param event The libinput tablet tool event * @return The new tip state of the tool from the event. + * + * @since 1.2 */ enum libinput_tablet_tool_tip_state libinput_event_tablet_tool_get_tip_state(struct libinput_event_tablet_tool *event); @@ -2328,6 +2450,8 @@ libinput_event_tablet_tool_get_tip_state(struct libinput_event_tablet_tool *even * * @param event The libinput tablet tool event * @return the button triggering this event + * + * @since 1.2 */ uint32_t libinput_event_tablet_tool_get_button(struct libinput_event_tablet_tool *event); @@ -2342,6 +2466,8 @@ libinput_event_tablet_tool_get_button(struct libinput_event_tablet_tool *event); * * @param event The libinput tablet tool event * @return the button state triggering this event + * + * @since 1.2 */ enum libinput_button_state libinput_event_tablet_tool_get_button_state(struct libinput_event_tablet_tool *event); @@ -2358,6 +2484,8 @@ libinput_event_tablet_tool_get_button_state(struct libinput_event_tablet_tool *e * * @param event The libinput tablet tool event * @return the seat wide pressed button count for the key of this event + * + * @since 1.2 */ uint32_t libinput_event_tablet_tool_get_seat_button_count(struct libinput_event_tablet_tool *event); @@ -2370,6 +2498,8 @@ libinput_event_tablet_tool_get_seat_button_count(struct libinput_event_tablet_to * * @param event The libinput tablet tool event * @return The event time for this event + * + * @since 1.2 */ uint32_t libinput_event_tablet_tool_get_time(struct libinput_event_tablet_tool *event); @@ -2382,6 +2512,8 @@ libinput_event_tablet_tool_get_time(struct libinput_event_tablet_tool *event); * * @param event The libinput tablet tool event * @return The event time for this event in microseconds + * + * @since 1.2 */ uint64_t libinput_event_tablet_tool_get_time_usec(struct libinput_event_tablet_tool *event); @@ -2406,6 +2538,8 @@ libinput_event_tablet_tool_get_time_usec(struct libinput_event_tablet_tool *even * @return The tool type for this tool object * * @see libinput_tablet_tool_get_tool_id + * + * @since 1.2 */ enum libinput_tablet_tool_type libinput_tablet_tool_get_type(struct libinput_tablet_tool *tool); @@ -2426,6 +2560,8 @@ libinput_tablet_tool_get_type(struct libinput_tablet_tool *tool); * @return The tool ID for this tool object or 0 if none is provided * * @see libinput_tablet_tool_get_type + * + * @since 1.2 */ uint64_t libinput_tablet_tool_get_tool_id(struct libinput_tablet_tool *tool); @@ -2440,6 +2576,8 @@ libinput_tablet_tool_get_tool_id(struct libinput_tablet_tool *tool); * @return The passed tool * * @see libinput_tablet_tool_unref + * + * @since 1.2 */ struct libinput_tablet_tool * libinput_tablet_tool_ref(struct libinput_tablet_tool *tool); @@ -2455,6 +2593,8 @@ libinput_tablet_tool_ref(struct libinput_tablet_tool *tool); * @return NULL if the tool was destroyed otherwise the passed tool * * @see libinput_tablet_tool_ref + * + * @since 1.2 */ struct libinput_tablet_tool * libinput_tablet_tool_unref(struct libinput_tablet_tool *tool); @@ -2466,6 +2606,8 @@ libinput_tablet_tool_unref(struct libinput_tablet_tool *tool); * * @param tool The tool to check the axis capabilities of * @return Nonzero if the axis is available, zero otherwise. + * + * @since 1.2 */ int libinput_tablet_tool_has_pressure(struct libinput_tablet_tool *tool); @@ -2477,6 +2619,8 @@ libinput_tablet_tool_has_pressure(struct libinput_tablet_tool *tool); * * @param tool The tool to check the axis capabilities of * @return Nonzero if the axis is available, zero otherwise. + * + * @since 1.2 */ int libinput_tablet_tool_has_distance(struct libinput_tablet_tool *tool); @@ -2488,6 +2632,8 @@ libinput_tablet_tool_has_distance(struct libinput_tablet_tool *tool); * * @param tool The tool to check the axis capabilities of * @return Nonzero if the axis is available, zero otherwise. + * + * @since 1.2 */ int libinput_tablet_tool_has_tilt(struct libinput_tablet_tool *tool); @@ -2499,6 +2645,8 @@ libinput_tablet_tool_has_tilt(struct libinput_tablet_tool *tool); * * @param tool The tool to check the axis capabilities of * @return Nonzero if the axis is available, zero otherwise. + * + * @since 1.2 */ int libinput_tablet_tool_has_rotation(struct libinput_tablet_tool *tool); @@ -2510,6 +2658,8 @@ libinput_tablet_tool_has_rotation(struct libinput_tablet_tool *tool); * * @param tool The tool to check the axis capabilities of * @return Nonzero if the axis is available, zero otherwise. + * + * @since 1.2 */ int libinput_tablet_tool_has_slider(struct libinput_tablet_tool *tool); @@ -2521,6 +2671,8 @@ libinput_tablet_tool_has_slider(struct libinput_tablet_tool *tool); * * @param tool The tool to check the axis capabilities of * @return Nonzero if the axis is available, zero otherwise. + * + * @since 1.2 */ int libinput_tablet_tool_has_wheel(struct libinput_tablet_tool *tool); @@ -2535,6 +2687,8 @@ libinput_tablet_tool_has_wheel(struct libinput_tablet_tool *tool); * @param code button code to check for * * @return 1 if the tool supports this button code, 0 if it does not + * + * @since 1.2 */ int libinput_tablet_tool_has_button(struct libinput_tablet_tool *tool, @@ -2553,6 +2707,8 @@ libinput_tablet_tool_has_button(struct libinput_tablet_tool *tool, * @return 1 if the tool can be uniquely identified, 0 otherwise. * * @see libinput_tablet_tool_get_serial + * + * @since 1.2 */ int libinput_tablet_tool_is_unique(struct libinput_tablet_tool *tool); @@ -2590,6 +2746,8 @@ libinput_tablet_tool_is_unique(struct libinput_tablet_tool *tool); * @return The tool serial number * * @see libinput_tablet_tool_is_unique + * + * @since 1.2 */ uint64_t libinput_tablet_tool_get_serial(struct libinput_tablet_tool *tool); @@ -2603,6 +2761,8 @@ libinput_tablet_tool_get_serial(struct libinput_tablet_tool *tool); * * @param tool The libinput tool * @return The user data associated with the tool object + * + * @since 1.2 */ void * libinput_tablet_tool_get_user_data(struct libinput_tablet_tool *tool); @@ -2614,6 +2774,8 @@ libinput_tablet_tool_get_user_data(struct libinput_tablet_tool *tool); * * @param tool The libinput tool * @param user_data The user data to associate with the tool object + * + * @since 1.2 */ void libinput_tablet_tool_set_user_data(struct libinput_tablet_tool *tool, @@ -2624,12 +2786,16 @@ libinput_tablet_tool_set_user_data(struct libinput_tablet_tool *tool, * * Events that come from the pad of tablet devices. For events from the * tablet tools, see @ref event_tablet. + * + * @since 1.3 */ /** * @ingroup event_tablet_pad * * @return The generic libinput_event of this event + * + * @since 1.3 */ struct libinput_event * libinput_event_tablet_pad_get_base_event(struct libinput_event_tablet_pad *event); @@ -2653,6 +2819,8 @@ libinput_event_tablet_pad_get_base_event(struct libinput_event_tablet_pad *event * @param event The libinput tablet pad event * @return The current value of the the axis * @retval -1 The finger was lifted + * + * @since 1.3 */ double libinput_event_tablet_pad_get_ring_position(struct libinput_event_tablet_pad *event); @@ -2670,6 +2838,8 @@ libinput_event_tablet_pad_get_ring_position(struct libinput_event_tablet_pad *ev * * @param event The libinput tablet pad event * @return The index of the ring that changed state + * + * @since 1.3 */ unsigned int libinput_event_tablet_pad_get_ring_number(struct libinput_event_tablet_pad *event); @@ -2687,6 +2857,8 @@ libinput_event_tablet_pad_get_ring_number(struct libinput_event_tablet_pad *even * * @param event The libinput tablet pad event * @return The source of the ring interaction + * + * @since 1.3 */ enum libinput_tablet_pad_ring_axis_source libinput_event_tablet_pad_get_ring_source(struct libinput_event_tablet_pad *event); @@ -2710,6 +2882,8 @@ libinput_event_tablet_pad_get_ring_source(struct libinput_event_tablet_pad *even * @param event The libinput tablet pad event * @return The current value of the the axis * @retval -1 The finger was lifted + * + * @since 1.3 */ double libinput_event_tablet_pad_get_strip_position(struct libinput_event_tablet_pad *event); @@ -2727,6 +2901,8 @@ libinput_event_tablet_pad_get_strip_position(struct libinput_event_tablet_pad *e * * @param event The libinput tablet pad event * @return The index of the strip that changed state + * + * @since 1.3 */ unsigned int libinput_event_tablet_pad_get_strip_number(struct libinput_event_tablet_pad *event); @@ -2744,6 +2920,8 @@ libinput_event_tablet_pad_get_strip_number(struct libinput_event_tablet_pad *eve * * @param event The libinput tablet pad event * @return The source of the strip interaction + * + * @since 1.3 */ enum libinput_tablet_pad_strip_axis_source libinput_event_tablet_pad_get_strip_source(struct libinput_event_tablet_pad *event); @@ -2765,6 +2943,8 @@ libinput_event_tablet_pad_get_strip_source(struct libinput_event_tablet_pad *eve * * @param event The libinput tablet pad event * @return the button triggering this event + * + * @since 1.3 */ uint32_t libinput_event_tablet_pad_get_button_number(struct libinput_event_tablet_pad *event); @@ -2780,6 +2960,8 @@ libinput_event_tablet_pad_get_button_number(struct libinput_event_tablet_pad *ev * * @param event The libinput tablet pad event * @return the button state triggering this event + * + * @since 1.3 */ enum libinput_button_state libinput_event_tablet_pad_get_button_state(struct libinput_event_tablet_pad *event); @@ -2810,6 +2992,8 @@ libinput_event_tablet_pad_get_button_state(struct libinput_event_tablet_pad *eve * the event * * @see libinput_tablet_pad_mode_group_get_mode + * + * @since 1.4 */ unsigned int libinput_event_tablet_pad_get_mode(struct libinput_event_tablet_pad *event); @@ -2831,6 +3015,8 @@ libinput_event_tablet_pad_get_mode(struct libinput_event_tablet_pad *event); * @return the mode group of the button, ring or strip that caused this event * * @see libinput_device_tablet_pad_get_mode_group + * + * @since 1.4 */ struct libinput_tablet_pad_mode_group * libinput_event_tablet_pad_get_mode_group(struct libinput_event_tablet_pad *event); @@ -2843,6 +3029,8 @@ libinput_event_tablet_pad_get_mode_group(struct libinput_event_tablet_pad *event * * @param event The libinput tablet pad event * @return The event time for this event + * + * @since 1.3 */ uint32_t libinput_event_tablet_pad_get_time(struct libinput_event_tablet_pad *event); @@ -2855,6 +3043,8 @@ libinput_event_tablet_pad_get_time(struct libinput_event_tablet_pad *event); * * @param event The libinput tablet pad event * @return The event time for this event in microseconds + * + * @since 1.3 */ uint64_t libinput_event_tablet_pad_get_time_usec(struct libinput_event_tablet_pad *event); @@ -2877,6 +3067,8 @@ libinput_event_tablet_pad_get_time_usec(struct libinput_event_tablet_pad *event) * * @param event The libinput switch event * @return The switch triggering this event + * + * @since 1.7 */ enum libinput_switch libinput_event_switch_get_switch(struct libinput_event_switch *event); @@ -2893,6 +3085,8 @@ libinput_event_switch_get_switch(struct libinput_event_switch *event); * * @param event The libinput switch event * @return The switch state triggering this event + * + * @since 1.7 */ enum libinput_switch_state libinput_event_switch_get_switch_state(struct libinput_event_switch *event); @@ -2901,6 +3095,8 @@ libinput_event_switch_get_switch_state(struct libinput_event_switch *event); * @ingroup event_switch * * @return The generic libinput_event of this event + * + * @since 1.7 */ struct libinput_event * libinput_event_switch_get_base_event(struct libinput_event_switch *event); @@ -2913,6 +3109,8 @@ libinput_event_switch_get_base_event(struct libinput_event_switch *event); * * @param event The libinput switch event * @return The event time for this event + * + * @since 1.7 */ uint32_t libinput_event_switch_get_time(struct libinput_event_switch *event); @@ -2925,6 +3123,8 @@ libinput_event_switch_get_time(struct libinput_event_switch *event); * * @param event The libinput switch event * @return The event time for this event in microseconds + * + * @since 1.7 */ uint64_t libinput_event_switch_get_time_usec(struct libinput_event_switch *event); @@ -3782,6 +3982,8 @@ libinput_device_keyboard_has_key(struct libinput_device *device, * * @return The number of simultaneous touches or 0 if unknown, -1 * on error. + * + * @since 1.11 */ int libinput_device_touch_get_touch_count(struct libinput_device *device); @@ -3797,6 +3999,8 @@ libinput_device_touch_get_touch_count(struct libinput_device *device); * * @return 1 if the device supports this switch, 0 if it does not, -1 * on error. + * + * @since 1.9 */ int libinput_device_switch_has_switch(struct libinput_device *device, @@ -3813,6 +4017,8 @@ libinput_device_switch_has_switch(struct libinput_device *device, * @param device A current input device * * @return The number of buttons supported by the device. + * + * @since 1.3 */ int libinput_device_tablet_pad_get_num_buttons(struct libinput_device *device); @@ -3828,6 +4034,8 @@ libinput_device_tablet_pad_get_num_buttons(struct libinput_device *device); * @return The number of rings or 0 if the device has no rings. * * @see libinput_event_tablet_pad_get_ring_number + * + * @since 1.3 */ int libinput_device_tablet_pad_get_num_rings(struct libinput_device *device); @@ -3843,6 +4051,8 @@ libinput_device_tablet_pad_get_num_rings(struct libinput_device *device); * @return The number of strips or 0 if the device has no strips. * * @see libinput_event_tablet_pad_get_strip_number + * + * @since 1.3 */ int libinput_device_tablet_pad_get_num_strips(struct libinput_device *device); @@ -4061,6 +4271,8 @@ libinput_device_config_tap_get_default_enabled(struct libinput_device *device); /** * @ingroup config + * + * @since 1.5 */ enum libinput_config_tap_button_map { /** 1/2/3 finger tap maps to left/right/middle */ @@ -4096,6 +4308,8 @@ enum libinput_config_tap_button_map { * * @see libinput_device_config_tap_get_button_map * @see libinput_device_config_tap_get_default_button_map + * + * @since 1.5 */ enum libinput_config_status libinput_device_config_tap_set_button_map(struct libinput_device *device, @@ -4117,6 +4331,8 @@ libinput_device_config_tap_set_button_map(struct libinput_device *device, * * @see libinput_device_config_tap_set_button_map * @see libinput_device_config_tap_get_default_button_map + * + * @since 1.5 */ enum libinput_config_tap_button_map libinput_device_config_tap_get_button_map(struct libinput_device *device); @@ -4137,6 +4353,8 @@ libinput_device_config_tap_get_button_map(struct libinput_device *device); * * @see libinput_device_config_tap_set_button_map * @see libinput_device_config_tap_get_default_button_map + * + * @since 1.5 */ enum libinput_config_tap_button_map libinput_device_config_tap_get_default_button_map(struct libinput_device *device); @@ -4147,6 +4365,8 @@ libinput_device_config_tap_get_default_button_map(struct libinput_device *device * A config status to distinguish or set dragging on a device. Currently * implemented for tap-and-drag only, see * libinput_device_config_tap_set_drag_enabled() + * + * @since 1.2 */ enum libinput_config_drag_state { /** @@ -4176,6 +4396,8 @@ enum libinput_config_drag_state { * * @see libinput_device_config_tap_drag_get_enabled * @see libinput_device_config_tap_drag_get_default_enabled + * + * @since 1.2 */ enum libinput_config_status libinput_device_config_tap_set_drag_enabled(struct libinput_device *device, @@ -4193,6 +4415,8 @@ libinput_device_config_tap_set_drag_enabled(struct libinput_device *device, * * @see libinput_device_config_tap_drag_set_enabled * @see libinput_device_config_tap_drag_get_default_enabled + * + * @since 1.2 */ enum libinput_config_drag_state libinput_device_config_tap_get_drag_enabled(struct libinput_device *device); @@ -4211,6 +4435,8 @@ libinput_device_config_tap_get_drag_enabled(struct libinput_device *device); * * @see libinput_device_config_tap_drag_set_enabled * @see libinput_device_config_tap_drag_get_enabled + * + * @since 1.2 */ enum libinput_config_drag_state libinput_device_config_tap_get_default_drag_enabled(struct libinput_device *device); @@ -4605,6 +4831,8 @@ libinput_device_config_accel_get_default_speed(struct libinput_device *device); /** * @ingroup config + * + * @since 1.1 */ enum libinput_config_accel_profile { /** @@ -4637,6 +4865,8 @@ enum libinput_config_accel_profile { * @param device The device to configure * * @return A bitmask of all configurable modes available on this device. + * + * @since 1.1 */ uint32_t libinput_device_config_accel_get_profiles(struct libinput_device *device); @@ -4651,6 +4881,8 @@ libinput_device_config_accel_get_profiles(struct libinput_device *device); * @param mode The mode to set the device to. * * @return A config status code + * + * @since 1.1 */ enum libinput_config_status libinput_device_config_accel_set_profile(struct libinput_device *device, @@ -4664,6 +4896,8 @@ libinput_device_config_accel_set_profile(struct libinput_device *device, * @param device The device to configure * * @return The currently configured pointer acceleration profile. + * + * @since 1.1 */ enum libinput_config_accel_profile libinput_device_config_accel_get_profile(struct libinput_device *device); @@ -4676,6 +4910,8 @@ libinput_device_config_accel_get_profile(struct libinput_device *device); * @param device The device to configure * * @return The default acceleration profile for this device. + * + * @since 1.1 */ enum libinput_config_accel_profile libinput_device_config_accel_get_default_profile(struct libinput_device *device); @@ -5362,6 +5598,8 @@ libinput_device_config_dwt_get_default_enabled(struct libinput_device *device); * @see libinput_device_config_rotation_set_angle * @see libinput_device_config_rotation_get_angle * @see libinput_device_config_rotation_get_default_angle + * + * @since 1.4 */ int libinput_device_config_rotation_is_available(struct libinput_device *device); @@ -5395,6 +5633,8 @@ libinput_device_config_rotation_is_available(struct libinput_device *device); * @see libinput_device_config_rotation_is_available * @see libinput_device_config_rotation_get_angle * @see libinput_device_config_rotation_get_default_angle + * + * @since 1.4 */ enum libinput_config_status libinput_device_config_rotation_set_angle(struct libinput_device *device, @@ -5413,6 +5653,8 @@ libinput_device_config_rotation_set_angle(struct libinput_device *device, * @see libinput_device_config_rotation_is_available * @see libinput_device_config_rotation_set_angle * @see libinput_device_config_rotation_get_default_angle + * + * @since 1.4 */ unsigned int libinput_device_config_rotation_get_angle(struct libinput_device *device); @@ -5430,6 +5672,8 @@ libinput_device_config_rotation_get_angle(struct libinput_device *device); * @see libinput_device_config_rotation_is_available * @see libinput_device_config_rotation_set_angle * @see libinput_device_config_rotation_get_angle + * + * @since 1.4 */ unsigned int libinput_device_config_rotation_get_default_angle(struct libinput_device *device);