Merge lp:~3v1n0/unity/xi2-input-monitor into lp:unity

[Marco Trevisan (Treviño)]

InputMonitor: add an unity class that monitors XInput2 events and converts them to XEvent

Clients of this class can register event handlers, and when an interested event will hit
our event filter function (that is set only if we have handlers), then we notify them
with a standard XEvent struct, converted from the XIDeviceEvent cookie.

The nice thing of this monitor is that it always reports events, despite the X grabs.

[Andrea Azzarone (azzar1)]

Nice! I think the class Monitor has no need to have a virtual dtor. So please make it non-virtual.

review: Needs Fixing

[Marco Trevisan (Treviño) (3v1n0)]

Done thanks...

I think I added that thinking of future abstractions, but this won't be the case.

[Andrea Azzarone (azzar1)]

Thanks!

review: Approve

=== modified file 'launcher/EdgeBarrierController.cpp'
--- launcher/EdgeBarrierController.cpp	2015-12-23 09:29:24 +0000
+++ launcher/EdgeBarrierController.cpp	2016-08-22 10:28:22 +0000
@@ -295,7 +295,7 @@
   nux::GetGraphicsDisplay()->AddEventFilter(event_filter);
 }
 
-bool EdgeBarrierController::Impl::HandleEvent(XEvent xevent)
+bool EdgeBarrierController::Impl::HandleEvent(XEvent& xevent)
 {
   Display *dpy = nux::GetGraphicsDisplay()->GetX11Display();
   XGenericEventCookie *cookie = &xevent.xcookie;

=== modified file 'launcher/EdgeBarrierControllerPrivate.h'
--- launcher/EdgeBarrierControllerPrivate.h	2015-12-23 09:29:24 +0000
+++ launcher/EdgeBarrierControllerPrivate.h	2016-08-22 10:28:22 +0000
@@ -58,7 +58,7 @@
   PointerBarrierWrapper::Ptr FindBarrierEventOwner(XIBarrierEvent* barrier_event);
 
   static bool HandleEventCB(XEvent event, void* data);
-  bool HandleEvent(XEvent event);
+  bool HandleEvent(XEvent& event);
 
   std::vector<PointerBarrierWrapper::Ptr> vertical_barriers_;
   std::vector<PointerBarrierWrapper::Ptr> horizontal_barriers_;

=== modified file 'plugins/unityshell/src/unityshell.h'
--- plugins/unityshell/src/unityshell.h	2016-08-12 11:21:48 +0000
+++ plugins/unityshell/src/unityshell.h	2016-08-22 10:28:22 +0000
@@ -56,6 +56,7 @@
 #include "DashStyle.h"
 #include "EdgeBarrierController.h"
 #include "FavoriteStoreGSettings.h"
+#include "InputMonitor.h"
 #include "ShortcutController.h"
 #include "LauncherController.h"
 #include "LockScreenController.h"
@@ -317,6 +318,7 @@
   internal::FavoriteStoreGSettings favorite_store_;
   ThumbnailGenerator thumbnail_generator_;
   lockscreen::Settings lockscreen_settings_;
+  input::Monitor input_monitor_;
 
   /* The window thread should be the last thing removed, as c++ does it in reverse order */
   std::unique_ptr<nux::WindowThread> wt;

=== modified file 'unity-shared/CMakeLists.txt'
--- unity-shared/CMakeLists.txt	2016-08-12 11:21:48 +0000
+++ unity-shared/CMakeLists.txt	2016-08-22 10:28:22 +0000
@@ -82,6 +82,7 @@
   set (UNITY_SHARED_SOURCES
     XKeyboardUtil.cpp
     XWindowManager.cpp
+    InputMonitor.cpp
     ${UNITY_SHARED_SOURCES}
     )
 else()

=== added file 'unity-shared/InputMonitor.cpp'
--- unity-shared/InputMonitor.cpp	1970-01-01 00:00:00 +0000
+++ unity-shared/InputMonitor.cpp	2016-08-22 10:28:22 +0000
@@ -0,0 +1,386 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2014 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Marco Trevisan <[e-mail]>
+ */
+
+#include "InputMonitor.h"
+
+#include <Nux/Nux.h>
+#include <NuxCore/Logger.h>
+#include <X11/extensions/XInput2.h>
+#include <UnityCore/GLibSource.h>
+#include <unordered_set>
+#include <gdk/gdkx.h>
+#include <glib.h>
+
+namespace unity
+{
+namespace input
+{
+namespace
+{
+DECLARE_LOGGER(logger, "unity.input.monitor");
+
+Monitor* instance_ = nullptr;
+
+const unsigned XINPUT_MAJOR_VERSION = 2;
+const unsigned XINPUT_MINOR_VERSION = 3;
+
+bool operator&(Events l, Events r)
+{
+  typedef std::underlying_type<Events>::type ut;
+  return static_cast<ut>(static_cast<ut>(l) & static_cast<ut>(r));
+}
+
+template <typename EVENT>
+void initialize_event_common(EVENT* ev, XIDeviceEvent* xiev)
+{
+  ev->serial = xiev->serial;
+  ev->send_event = xiev->send_event;
+  ev->display = xiev->display;
+  ev->window = xiev->event;
+  ev->root = xiev->root;
+  ev->subwindow = xiev->child;
+  ev->time = xiev->time;
+  ev->x = std::round(xiev->event_x);
+  ev->y = std::round(xiev->event_y);
+  ev->x_root = std::round(xiev->root_x);
+  ev->y_root = std::round(xiev->root_y);
+  ev->state = xiev->mods.effective;
+  ev->same_screen = True;
+}
+
+template <typename EVENT_TYPE, typename NATIVE_TYPE>
+void initialize_event(XEvent* ev, NATIVE_TYPE* xiev);
+
+template <>
+void initialize_event<XButtonEvent>(XEvent* ev, XIDeviceEvent* xiev)
+{
+  XButtonEvent* bev = &ev->xbutton;
+  ev->type = (xiev->evtype == XI_ButtonPress) ? ButtonPress : ButtonRelease;
+  initialize_event_common(bev, xiev);
+  bev->button = xiev->detail;
+}
+
+template <>
+void initialize_event<XKeyEvent>(XEvent* ev, XIDeviceEvent* xiev)
+{
+  XKeyEvent* kev = &ev->xkey;
+  ev->type = (xiev->evtype == XI_KeyPress) ? KeyPress : KeyRelease;
+  initialize_event_common(kev, xiev);
+  kev->keycode = xiev->detail;
+}
+
+template <>
+void initialize_event<XMotionEvent>(XEvent* ev, XIDeviceEvent* xiev)
+{
+  XMotionEvent* mev = &ev->xmotion;
+  ev->type = MotionNotify;
+  initialize_event_common(mev, xiev);
+  mev->is_hint = NotifyNormal;
+
+  for (int i = 0; i < xiev->buttons.mask_len * 8; ++i)
+  {
+    if (XIMaskIsSet(xiev->buttons.mask, i))
+    {
+      mev->is_hint = NotifyHint;
+      break;
+    }
+  }
+}
+
+template <>
+void initialize_event<XGenericEventCookie>(XEvent* ev, XIBarrierEvent* xiev)
+{
+  XGenericEventCookie* cev = &ev->xcookie;
+  cev->type = GenericEvent;
+  cev->serial = xiev->serial;
+  cev->send_event = xiev->send_event;
+  cev->display = xiev->display;
+  cev->evtype = xiev->evtype;
+  cev->data = xiev;
+}
+}
+
+struct Monitor::Impl
+{
+  Impl()
+    : xi_opcode_(0)
+    , event_filter_set_(false)
+    , invoking_callbacks_(false)
+  {
+    Display *dpy = gdk_x11_get_default_xdisplay();
+    int event_base, error_base;
+
+    if (XQueryExtension(dpy, "XInputExtension", &xi_opcode_, &event_base, &error_base))
+    {
+      int maj = XINPUT_MAJOR_VERSION;
+      int min = XINPUT_MINOR_VERSION;
+
+      if (XIQueryVersion(dpy, &maj, &min) == BadRequest)
+      {
+        LOG_ERROR(logger) << "Need XInput version "<< maj << "." << min << ", "
+                          << "impossible, to setup an InputMonitor";
+      }
+    }
+    else
+    {
+      LOG_ERROR(logger) << "Missing XInput, impossible to setup an InputMonitor";
+    }
+  }
+
+  ~Impl()
+  {
+    if (event_filter_set_)
+    {
+      pointer_callbacks_.clear();
+      key_callbacks_.clear();
+      barrier_callbacks_.clear();
+      UpdateEventMonitor();
+    }
+  }
+
+  bool RegisterClient(Events type, EventCallback const& cb)
+  {
+    bool added = false;
+
+    if (type & Events::POINTER)
+      added = pointer_callbacks_.insert(cb).second || added;
+
+    if (type & Events::KEYS)
+      added = key_callbacks_.insert(cb).second || added;
+
+    if (type & Events::BARRIER)
+      added = barrier_callbacks_.insert(cb).second || added;
+
+    if (added)
+      UpdateEventMonitor();
+
+    return added;
+  }
+
+  bool UnregisterClient(EventCallback const& cb)
+  {
+    if (invoking_callbacks_)
+    {
+      // Delay the event removal if we're currently invoking a callback
+      // not to break the callbacks loop
+      removal_queue_.insert(cb);
+      return false;
+    }
+
+    bool removed = false;
+    removed = pointer_callbacks_.erase(cb) > 0 || removed;
+    removed = key_callbacks_.erase(cb) > 0 || removed;
+    removed = barrier_callbacks_.erase(cb) > 0 || removed;
+
+    if (removed)
+      UpdateEventMonitor();
+
+    return removed;
+  }
+
+  void UpdateEventMonitor()
+  {
+    auto* dpy = nux::GetGraphicsDisplay()->GetX11Display();
+    Window root = DefaultRootWindow(dpy);
+
+    unsigned char master_dev_bits[XIMaskLen(XI_LASTEVENT)] = { 0 };
+    XIEventMask master_dev = { XIAllMasterDevices, sizeof(master_dev_bits), master_dev_bits };
+
+    if (!barrier_callbacks_.empty())
+    {
+      XISetMask(master_dev.mask, XI_BarrierHit);
+      XISetMask(master_dev.mask, XI_BarrierLeave);
+    }
+
+    unsigned char all_devs_bits[XIMaskLen(XI_LASTEVENT)] = { 0 };
+    XIEventMask all_devs = { XIAllDevices, sizeof(all_devs_bits), all_devs_bits };
+
+    if (!pointer_callbacks_.empty())
+    {
+      XISetMask(all_devs.mask, XI_Motion);
+      XISetMask(all_devs.mask, XI_ButtonPress);
+      XISetMask(all_devs.mask, XI_ButtonRelease);
+    }
+
+    if (!key_callbacks_.empty())
+    {
+      XISetMask(all_devs.mask, XI_KeyPress);
+      XISetMask(all_devs.mask, XI_KeyRelease);
+    }
+
+    XIEventMask selected[] = {master_dev, all_devs};
+    XISelectEvents(dpy, root, selected, G_N_ELEMENTS(selected));
+    XSync(dpy, False);
+
+    LOG_DEBUG(logger) << "Pointer clients: " << pointer_callbacks_.size() << ", "
+                      << "Key clients: " << key_callbacks_.size() << ", "
+                      << "Barrier clients: " << barrier_callbacks_.size();
+
+    if (!pointer_callbacks_.empty() || !key_callbacks_.empty() || !barrier_callbacks_.empty())
+    {
+      if (!event_filter_set_)
+      {
+        nux::GetGraphicsDisplay()->AddEventFilter({[] (XEvent event, void* data) {
+          return static_cast<Impl*>(data)->HandleEvent(event);
+        }, this});
+
+        event_filter_set_ = true;
+        LOG_DEBUG(logger) << "Event filter enabled";
+      }
+    }
+    else if (event_filter_set_)
+    {
+      nux::GetGraphicsDisplay()->RemoveEventFilter(this);
+      event_filter_set_ = false;
+      LOG_DEBUG(logger) << "Event filter disabled";
+    }
+  }
+
+  bool HandleEvent(XEvent& event)
+  {
+    bool handled = false;
+
+    if (event.type != GenericEvent || event.xcookie.extension != xi_opcode_)
+      return handled;
+
+    switch (event.xcookie.evtype)
+    {
+      case XI_ButtonPress:
+      case XI_ButtonRelease:
+        handled = InvokeCallbacks<XButtonEvent>(pointer_callbacks_, event);
+        break;
+      case XI_Motion:
+        handled = InvokeCallbacks<XMotionEvent>(pointer_callbacks_, event);
+        break;
+      case XI_KeyPress:
+      case XI_KeyRelease:
+        handled = InvokeCallbacks<XKeyEvent>(key_callbacks_, event);
+        break;
+      case XI_BarrierHit:
+      case XI_BarrierLeave:
+        handled = InvokeCallbacks<XGenericEventCookie, XIBarrierEvent>(barrier_callbacks_, event);
+        break;
+    }
+
+    return handled;
+  }
+
+  template <typename EVENT_TYPE, typename NATIVE_TYPE = XIDeviceEvent>
+  bool InvokeCallbacks(std::unordered_set<EventCallback>& callbacks, XEvent& xiev)
+  {
+    XGenericEventCookie *cookie = &xiev.xcookie;
+
+    if (!XGetEventData(xiev.xany.display, cookie))
+      return false;
+
+    XEvent event;
+    initialize_event<EVENT_TYPE>(&event, reinterpret_cast<NATIVE_TYPE*>(cookie->data));
+    invoking_callbacks_ = true;
+
+    for (auto it = callbacks.begin(); it != callbacks.end();)
+    {
+      if (it->empty())
+      {
+        it = callbacks.erase(it);
+        continue;
+      }
+
+      (*it)(event);
+      ++it;
+    }
+
+    XFreeEventData(xiev.xany.display, cookie);
+    invoking_callbacks_ = false;
+
+    // A callback might unregister itself on the event callback, causing the
+    // above callbacks loop to crash, so in this case we save the event in the
+    // removal queue and eventually we unregistered these callbacks.
+    bool update_event_monitor = false;
+    for (auto it = removal_queue_.begin(); it != removal_queue_.end(); it = removal_queue_.erase(it))
+    {
+      auto const& cb = *it;
+      pointer_callbacks_.erase(cb);
+      key_callbacks_.erase(cb);
+      barrier_callbacks_.erase(cb);
+      update_event_monitor = true;
+    }
+
+    if (callbacks.empty() || update_event_monitor)
+    {
+      idle_removal_.reset(new glib::Idle([this] {
+        UpdateEventMonitor();
+        return false;
+      }));
+
+      return false;
+    }
+
+    return true;
+  }
+
+  int xi_opcode_;
+  bool event_filter_set_;
+  bool invoking_callbacks_;
+  glib::Source::UniquePtr idle_removal_;
+  std::unordered_set<EventCallback> pointer_callbacks_;
+  std::unordered_set<EventCallback> key_callbacks_;
+  std::unordered_set<EventCallback> barrier_callbacks_;
+  std::unordered_set<EventCallback> removal_queue_;
+};
+
+Monitor::Monitor()
+{
+  if (instance_)
+  {
+    LOG_WARN(logger) << "More than one input::Monitor created.";
+    return;
+  }
+
+  instance_ = this;
+  impl_.reset(new Impl());
+}
+
+Monitor::~Monitor()
+{
+  if (this == instance_)
+    instance_ = nullptr;
+}
+
+Monitor& Monitor::Get()
+{
+  if (!instance_)
+  {
+    LOG_ERROR(logger) << "No input::Monitor created yet.";
+  }
+
+  return *instance_;
+}
+
+bool Monitor::RegisterClient(Events events, EventCallback const& cb)
+{
+  return impl_->RegisterClient(events, cb);
+}
+
+bool Monitor::UnregisterClient(EventCallback const& cb)
+{
+  return impl_->UnregisterClient(cb);
+}
+
+} // input namespace
+} // unity namespace

=== added file 'unity-shared/InputMonitor.h'
--- unity-shared/InputMonitor.h	1970-01-01 00:00:00 +0000
+++ unity-shared/InputMonitor.h	2016-08-22 10:28:22 +0000
@@ -0,0 +1,91 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2014 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Marco Trevisan <[e-mail]>
+ */
+
+#ifndef __UNITY_INPUT_MONITOR__
+#define __UNITY_INPUT_MONITOR__
+
+#include <X11/Xlib.h>
+#include <sigc++/slot.h>
+#include <memory>
+
+namespace unity
+{
+namespace input
+{
+enum class Events : unsigned
+{
+  POINTER = (1 << 0),
+  KEYS = (1 << 1),
+  BARRIER = (1 << 2),
+  INPUT = POINTER | KEYS,
+  ALL = POINTER | KEYS | BARRIER
+};
+
+class Monitor : public sigc::trackable
+{
+public:
+  typedef sigc::slot<void, XEvent const&> EventCallback;
+
+  static Monitor& Get();
+
+  Monitor();
+  ~Monitor();
+
+  bool RegisterClient(Events, EventCallback const&);
+  bool UnregisterClient(EventCallback const&);
+
+private:
+  Monitor(Monitor const&) = delete;
+  Monitor& operator=(Monitor const&) = delete;
+
+  struct Impl;
+  std::unique_ptr<Impl> impl_;
+};
+
+} // input namespace
+} // unity namespace
+
+namespace std
+{
+template<>
+struct hash<unity::input::Monitor::EventCallback>
+{
+  size_t operator()(unity::input::Monitor::EventCallback const& cb) const
+  {
+    if (cb.rep_)
+      return std::hash<size_t>()(reinterpret_cast<size_t>(cb.rep_->call_));
+
+    return std::hash<size_t>()(reinterpret_cast<size_t>(cb.rep_));
+  }
+};
+
+template<>
+struct equal_to<unity::input::Monitor::EventCallback>
+{
+  bool operator()(unity::input::Monitor::EventCallback const& lhs, unity::input::Monitor::EventCallback const& rhs) const
+  {
+    if (!lhs.rep_ || !rhs.rep_)
+      return (lhs.rep_ == rhs.rep_);
+
+    return (lhs.rep_->call_ == rhs.rep_->call_);
+  }
+};
+} // std namespace
+
+#endif // __UNITY_INPUT_MONITOR__

=== modified file 'unity-shared/StandaloneWindowManager.cpp'
--- unity-shared/StandaloneWindowManager.cpp	2015-11-20 11:33:38 +0000
+++ unity-shared/StandaloneWindowManager.cpp	2016-08-22 10:28:22 +0000
@@ -624,6 +624,9 @@
   return std::string();
 }
 
+void StandaloneWindowManager::SetCardinalProperty(Window, Atom, std::vector<long> const&)
+{}
+
 std::vector<long> StandaloneWindowManager::GetCardinalProperty(Window, Atom) const
 {
   return std::vector<long>();

=== modified file 'unity-shared/StandaloneWindowManager.h'
--- unity-shared/StandaloneWindowManager.h	2016-03-18 18:58:26 +0000
+++ unity-shared/StandaloneWindowManager.h	2016-08-22 10:28:22 +0000
@@ -165,6 +165,7 @@
   virtual std::string GetWindowName(Window window_id) const;
   virtual bool IsOnscreenKeyboard(Window window_id) const;
   virtual std::string GetStringProperty(Window window_id, Atom) const;
+  virtual void SetCardinalProperty(Window window_id, Atom, std::vector<long> const&);
   virtual std::vector<long> GetCardinalProperty(Window window_id, Atom) const;
 
   // Mock functions

=== modified file 'unity-shared/WindowManager.h'
--- unity-shared/WindowManager.h	2016-03-18 18:58:26 +0000
+++ unity-shared/WindowManager.h	2016-08-22 10:28:22 +0000
@@ -170,6 +170,7 @@
   virtual bool IsOnscreenKeyboard(Window window_id) const = 0;
 
   virtual std::string GetStringProperty(Window, Atom) const = 0;
+  virtual void SetCardinalProperty(Window, Atom, std::vector<long> const&) = 0;
   virtual std::vector<long> GetCardinalProperty(Window, Atom) const = 0;
 
   virtual Cursor GetCachedCursor(unsigned int cursor_name) const = 0;

=== modified file 'unity-shared/XWindowManager.cpp'
--- unity-shared/XWindowManager.cpp	2015-01-21 15:28:59 +0000
+++ unity-shared/XWindowManager.cpp	2016-08-22 10:28:22 +0000
@@ -123,6 +123,12 @@
   return std::string(val, n_items);
 }
 
+void XWindowManager::SetCardinalProperty(Window window_id, Atom atom, std::vector<long> const& values)
+{
+  XChangeProperty(screen->dpy(), window_id, atom, XA_CARDINAL, 32, PropModeReplace,
+                  (unsigned char *) values.data(), values.size());
+}
+
 std::vector<long> XWindowManager::GetCardinalProperty(Window window_id, Atom atom) const
 {
   Atom type;

=== modified file 'unity-shared/XWindowManager.h'
--- unity-shared/XWindowManager.h	2015-01-21 15:28:59 +0000
+++ unity-shared/XWindowManager.h	2016-08-22 10:28:22 +0000
@@ -36,6 +36,7 @@
   std::string GetWindowName(Window window_id) const;
   bool IsOnscreenKeyboard(Window window_id) const;
   std::string GetStringProperty(Window window_id, Atom atom) const;
+  void SetCardinalProperty(Window, Atom, std::vector<long> const&);
   std::vector<long> GetCardinalProperty(Window, Atom) const;
 };