[PATCH libinput 01/14] Add a "switch" interface for parts of the SW_* range
Peter Hutterer
peter.hutterer at who-t.net
Wed Jan 25 23:44:11 UTC 2017
From: James Ye <jye836 at gmail.com>
This will allow switch devices known to libinput to be exposed. Currently,
this is SW_LID.
libinput also handles switch events internally, e.g. a laptop touchpad will
be disabled autmoatically when the lid is closed. This is transparent to
the caller, although the caller will also receive the event. See
https://bugs.freedesktop.org/show_bug.cgi?id=86223
This features is intended to be the main driver for the interface.
Co-Authored-By: Peter Hutterer <peter.hutterer at who-t.net>
Signed-off-by: James Ye <jye836 at gmail.com>
Signed-off-by: Peter Hutterer <peter.hutterer at who-t.net>
---
doc/Makefile.am | 1 +
doc/switches.dox | 16 +++++++
src/libinput-private.h | 5 +++
src/libinput.c | 103 +++++++++++++++++++++++++++++++++++++++++++++
src/libinput.h | 112 +++++++++++++++++++++++++++++++++++++++++++++++++
src/libinput.sym | 9 ++++
test/litest.c | 3 ++
tools/event-debug.c | 31 ++++++++++++++
tools/event-gui.c | 2 +
9 files changed, 282 insertions(+)
create mode 100644 doc/switches.dox
diff --git a/doc/Makefile.am b/doc/Makefile.am
index 698a316..a92d791 100644
--- a/doc/Makefile.am
+++ b/doc/Makefile.am
@@ -22,6 +22,7 @@ header_files = \
$(srcdir)/reporting-bugs.dox \
$(srcdir)/scrolling.dox \
$(srcdir)/seats.dox \
+ $(srcdir)/switches.dox \
$(srcdir)/t440-support.dox \
$(srcdir)/tablet-support.dox \
$(srcdir)/tapping.dox \
diff --git a/doc/switches.dox b/doc/switches.dox
new file mode 100644
index 0000000..4bb2675
--- /dev/null
+++ b/doc/switches.dox
@@ -0,0 +1,16 @@
+/**
+ at page switches Switches
+
+libinput supports a couple of switches. Unlike button events that come in
+press and release pairs, switches are usually toggled once and left at the
+setting for an extended period of time.
+
+Only some switches are handled by libinput, see @ref libinput_switch for a
+list of supported switches. Switch events are exposed to the caller, but
+libinput may handle some switch events internally and enable or disable
+specific features based on a switch state.
+
+The order of switch events is guaranteed to be correct, i.e., a switch will
+never send consecutive switch on, or switch off, events.
+
+*/
diff --git a/src/libinput-private.h b/src/libinput-private.h
index 39c169c..07bed36 100644
--- a/src/libinput-private.h
+++ b/src/libinput-private.h
@@ -623,6 +623,11 @@ tablet_pad_notify_strip(struct libinput_device *device,
double value,
enum libinput_tablet_pad_strip_axis_source source,
struct libinput_tablet_pad_mode_group *group);
+void
+switch_notify_toggle(struct libinput_device *device,
+ uint64_t time,
+ enum libinput_switch sw,
+ enum libinput_switch_state state);
static inline uint64_t
libinput_now(struct libinput *libinput)
diff --git a/src/libinput.c b/src/libinput.c
index 4daa11d..4997153 100644
--- a/src/libinput.c
+++ b/src/libinput.c
@@ -159,6 +159,13 @@ struct libinput_event_tablet_pad {
} strip;
};
+struct libinput_event_switch {
+ struct libinput_event base;
+ uint64_t time;
+ enum libinput_switch sw;
+ enum libinput_switch_state state;
+};
+
LIBINPUT_ATTRIBUTE_PRINTF(3, 0)
static void
libinput_default_log_func(struct libinput *libinput,
@@ -365,6 +372,17 @@ libinput_event_get_device_notify_event(struct libinput_event *event)
return (struct libinput_event_device_notify *) event;
}
+LIBINPUT_EXPORT struct libinput_event_switch *
+libinput_event_get_switch_event(struct libinput_event *event)
+{
+ require_event_type(libinput_event_get_context(event),
+ event->type,
+ NULL,
+ LIBINPUT_EVENT_SWITCH_TOGGLE);
+
+ return (struct libinput_event_switch *) event;
+}
+
LIBINPUT_EXPORT uint32_t
libinput_event_keyboard_get_time(struct libinput_event_keyboard *event)
{
@@ -1508,6 +1526,61 @@ libinput_tablet_tool_unref(struct libinput_tablet_tool *tool)
return NULL;
}
+LIBINPUT_EXPORT struct libinput_event *
+libinput_event_switch_get_base_event(struct libinput_event_switch *event)
+{
+ require_event_type(libinput_event_get_context(&event->base),
+ event->base.type,
+ NULL,
+ LIBINPUT_EVENT_SWITCH_TOGGLE);
+
+ return &event->base;
+}
+
+LIBINPUT_EXPORT enum libinput_switch
+libinput_event_switch_get_switch(struct libinput_event_switch *event)
+{
+ require_event_type(libinput_event_get_context(&event->base),
+ event->base.type,
+ 0,
+ LIBINPUT_EVENT_SWITCH_TOGGLE);
+
+ return event->sw;
+}
+
+LIBINPUT_EXPORT enum libinput_switch_state
+libinput_event_switch_get_switch_state(struct libinput_event_switch *event)
+{
+ require_event_type(libinput_event_get_context(&event->base),
+ event->base.type,
+ 0,
+ LIBINPUT_EVENT_SWITCH_TOGGLE);
+
+ return event->state;
+}
+
+LIBINPUT_EXPORT uint32_t
+libinput_event_switch_get_time(struct libinput_event_switch *event)
+{
+ require_event_type(libinput_event_get_context(&event->base),
+ event->base.type,
+ 0,
+ LIBINPUT_EVENT_SWITCH_TOGGLE);
+
+ return us2ms(event->time);
+}
+
+LIBINPUT_EXPORT uint64_t
+libinput_event_switch_get_time_usec(struct libinput_event_switch *event)
+{
+ require_event_type(libinput_event_get_context(&event->base),
+ event->base.type,
+ 0,
+ LIBINPUT_EVENT_SWITCH_TOGGLE);
+
+ return event->time;
+}
+
struct libinput_source *
libinput_add_fd(struct libinput *libinput,
int fd,
@@ -2024,6 +2097,9 @@ device_has_cap(struct libinput_device *device,
case LIBINPUT_DEVICE_CAP_TABLET_PAD:
capability = "CAP_TABLET_PAD";
break;
+ case LIBINPUT_DEVICE_CAP_SWITCH:
+ capability = "CAP_SWITCH";
+ break;
}
log_bug_libinput(device->seat->libinput,
@@ -2619,6 +2695,7 @@ event_type_to_str(enum libinput_event_type type)
CASE_RETURN_STRING(LIBINPUT_EVENT_GESTURE_PINCH_BEGIN);
CASE_RETURN_STRING(LIBINPUT_EVENT_GESTURE_PINCH_UPDATE);
CASE_RETURN_STRING(LIBINPUT_EVENT_GESTURE_PINCH_END);
+ CASE_RETURN_STRING(LIBINPUT_EVENT_SWITCH_TOGGLE);
case LIBINPUT_EVENT_NONE:
abort();
}
@@ -2626,6 +2703,32 @@ event_type_to_str(enum libinput_event_type type)
return NULL;
}
+void
+switch_notify_toggle(struct libinput_device *device,
+ uint64_t time,
+ enum libinput_switch sw,
+ enum libinput_switch_state state)
+{
+ struct libinput_event_switch *switch_event;
+
+ if (!device_has_cap(device, LIBINPUT_DEVICE_CAP_SWITCH))
+ return;
+
+ switch_event = zalloc(sizeof *switch_event);
+ if (!switch_event)
+ return;
+
+ *switch_event = (struct libinput_event_switch) {
+ .time = time,
+ .sw = sw,
+ .state = state,
+ };
+
+ post_device_event(device, time,
+ LIBINPUT_EVENT_SWITCH_TOGGLE,
+ &switch_event->base);
+}
+
static void
libinput_post_event(struct libinput *libinput,
struct libinput_event *event)
diff --git a/src/libinput.h b/src/libinput.h
index fdbba3c..f8b123a 100644
--- a/src/libinput.h
+++ b/src/libinput.h
@@ -187,6 +187,7 @@ enum libinput_device_capability {
LIBINPUT_DEVICE_CAP_TABLET_TOOL = 3,
LIBINPUT_DEVICE_CAP_TABLET_PAD = 4,
LIBINPUT_DEVICE_CAP_GESTURE = 5,
+ LIBINPUT_DEVICE_CAP_SWITCH = 6,
};
/**
@@ -598,6 +599,38 @@ libinput_tablet_pad_mode_group_get_user_data(
struct libinput_tablet_pad_mode_group *group);
/**
+ * @ingroup device
+ *
+ * The state of a switch.
+ */
+enum libinput_switch_state {
+ LIBINPUT_SWITCH_STATE_OFF = 0,
+ LIBINPUT_SWITCH_STATE_ON = 1,
+};
+
+/**
+ * @ingroup device
+ *
+ * The type of a switch.
+ */
+enum libinput_switch {
+ /**
+ * The laptop lid was closed when the switch state is @ref
+ * LIBINPUT_SWITCH_STATE_ON, or was opened when it is @ref
+ * LIBINPUT_SWITCH_STATE_OFF.
+ */
+ LIBINPUT_SWITCH_LID = 1,
+};
+
+/**
+ * @ingroup event_switch
+ * @struct libinput_event_switch
+ *
+ * A switch event representing a changed state in a switch.
+ */
+struct libinput_event_switch;
+
+/**
* @ingroup base
*
* Event type for events returned by libinput_get_event().
@@ -752,6 +785,8 @@ enum libinput_event_type {
LIBINPUT_EVENT_GESTURE_PINCH_BEGIN,
LIBINPUT_EVENT_GESTURE_PINCH_UPDATE,
LIBINPUT_EVENT_GESTURE_PINCH_END,
+
+ LIBINPUT_EVENT_SWITCH_TOGGLE = 900,
};
/**
@@ -891,6 +926,19 @@ libinput_event_get_tablet_pad_event(struct libinput_event *event);
/**
* @ingroup event
*
+ * Return the switch event that is this input event. If the event type does
+ * not match the switch event types, this function returns NULL.
+ *
+ * The inverse of this function is libinput_event_switch_get_base_event().
+ *
+ * @return A switch event, or NULL for other events
+ */
+struct libinput_event_switch *
+libinput_event_get_switch_event(struct libinput_event *event);
+
+/**
+ * @ingroup event
+ *
* Return the device event that is this input event. If the event type does
* not match the device event types, this function returns NULL.
*
@@ -2699,6 +2747,70 @@ uint64_t
libinput_event_tablet_pad_get_time_usec(struct libinput_event_tablet_pad *event);
/**
+ * @defgroup event_switch Switch events
+ *
+ * Events that come from switch devices.
+ */
+
+/**
+ * @ingroup event_switch
+ *
+ * Return the switch that triggered this event.
+ * For pointer events that are not of type @ref
+ * LIBINPUT_EVENT_SWITCH_TOGGLE, this function returns 0.
+ *
+ * @note It is an application bug to call this function for events other than
+ * @ref LIBINPUT_EVENT_SWITCH_TOGGLE.
+ *
+ * @param event The libinput switch event
+ * @return The switch triggering this event
+ */
+enum libinput_switch
+libinput_event_switch_get_switch(struct libinput_event_switch *event);
+
+/**
+ * @ingroup event_switch
+ *
+ * Return the switch state that triggered this event.
+ * For switch events that are not of type @ref
+ * LIBINPUT_EVENT_SWITCH_TOGGLE, this function returns 0.
+ *
+ * @note It is an application bug to call this function for events other than
+ * @ref LIBINPUT_EVENT_SWITCH_TOGGLE.
+ *
+ * @param event The libinput switch event
+ * @return The switch state triggering this event
+ */
+enum libinput_switch_state
+libinput_event_switch_get_switch_state(struct libinput_event_switch *event);
+
+/**
+ * @ingroup event_switch
+ *
+ * @return The generic libinput_event of this event
+ */
+struct libinput_event *
+libinput_event_switch_get_base_event(struct libinput_event_switch *event);
+
+/**
+ * @ingroup event_switch
+ *
+ * @param event The libinput switch event
+ * @return The event time for this event
+ */
+uint32_t
+libinput_event_switch_get_time(struct libinput_event_switch *event);
+
+/**
+ * @ingroup event_switch
+ *
+ * @param event The libinput switch event
+ * @return The event time for this event in microseconds
+ */
+uint64_t
+libinput_event_switch_get_time_usec(struct libinput_event_switch *event);
+
+/**
* @defgroup base Initialization and manipulation of libinput contexts
*/
diff --git a/src/libinput.sym b/src/libinput.sym
index 97bb57f..f440521 100644
--- a/src/libinput.sym
+++ b/src/libinput.sym
@@ -280,3 +280,12 @@ LIBINPUT_1.5 {
libinput_device_config_tap_get_default_button_map;
libinput_device_config_tap_set_button_map;
} LIBINPUT_1.4;
+
+LIBINPUT_SWITCH {
+ libinput_event_get_switch_event;
+ libinput_event_switch_get_base_event;
+ libinput_event_switch_get_switch_state;
+ libinput_event_switch_get_switch;
+ libinput_event_switch_get_time;
+ libinput_event_switch_get_time_usec;
+} LIBINPUT_1.5;
diff --git a/test/litest.c b/test/litest.c
index b3e7ba3..5b1e7b5 100644
--- a/test/litest.c
+++ b/test/litest.c
@@ -2203,6 +2203,9 @@ litest_event_type_str(enum libinput_event_type type)
case LIBINPUT_EVENT_TABLET_PAD_STRIP:
str = "TABLET PAD STRIP";
break;
+ case LIBINPUT_EVENT_SWITCH_TOGGLE:
+ str = "SWITCH TOGGLE";
+ break;
}
return str;
}
diff --git a/tools/event-debug.c b/tools/event-debug.c
index a3e460a..779b54a 100644
--- a/tools/event-debug.c
+++ b/tools/event-debug.c
@@ -133,6 +133,9 @@ print_event_header(struct libinput_event *ev)
case LIBINPUT_EVENT_TABLET_PAD_STRIP:
type = "TABLET_PAD_STRIP";
break;
+ case LIBINPUT_EVENT_SWITCH_TOGGLE:
+ type = "SWITCH_TOGGLE";
+ break;
}
prefix = (last_device != dev) ? '-' : ' ';
@@ -194,6 +197,9 @@ print_device_notify(struct libinput_event *ev)
if (libinput_device_has_capability(dev,
LIBINPUT_DEVICE_CAP_TABLET_PAD))
printf("P");
+ if (libinput_device_has_capability(dev,
+ LIBINPUT_DEVICE_CAP_SWITCH))
+ printf("S");
if (libinput_device_get_size(dev, &w, &h) == 0)
printf(" size %.0fx%.0fmm", w, h);
@@ -706,6 +712,28 @@ print_tablet_pad_strip_event(struct libinput_event *ev)
mode);
}
+static void
+print_switch_event(struct libinput_event *ev)
+{
+ struct libinput_event_switch *sw = libinput_event_get_switch_event(ev);
+ enum libinput_switch_state state;
+ const char *which;
+
+ print_event_time(libinput_event_switch_get_time(sw));
+
+ switch (libinput_event_switch_get_switch(sw)) {
+ case LIBINPUT_SWITCH_LID:
+ which = "lid";
+ break;
+ default:
+ abort();
+ }
+
+ state = libinput_event_switch_get_switch_state(sw);
+
+ printf("switch %s state %d\n", which, state);
+}
+
static int
handle_and_print_events(struct libinput *li)
{
@@ -794,6 +822,9 @@ handle_and_print_events(struct libinput *li)
case LIBINPUT_EVENT_TABLET_PAD_STRIP:
print_tablet_pad_strip_event(ev);
break;
+ case LIBINPUT_EVENT_SWITCH_TOGGLE:
+ print_switch_event(ev);
+ break;
}
libinput_event_destroy(ev);
diff --git a/tools/event-gui.c b/tools/event-gui.c
index e819901..155cc95 100644
--- a/tools/event-gui.c
+++ b/tools/event-gui.c
@@ -845,6 +845,8 @@ handle_event_libinput(GIOChannel *source, GIOCondition condition, gpointer data)
case LIBINPUT_EVENT_TABLET_PAD_RING:
case LIBINPUT_EVENT_TABLET_PAD_STRIP:
break;
+ case LIBINPUT_EVENT_SWITCH_TOGGLE:
+ break;
}
libinput_event_destroy(ev);
--
2.9.3
More information about the wayland-devel
mailing list