Merge lp:~brandontschaefer/unity/move-pointer-barrier-to-xi-1.6.99.1 into lp:unity

[Brandon Schaefer]

Move unity to the new libxi changes, along with the new 1.14 xserver.

Some big changes. Updating pointer barrier logic new versions of xfixes and xi (1.6.99.1).

Had to move a bunch of things around, due to the fact that we didn't handle any kind of XI2 events before. Also re worked somethings so they only run once now...before we had a bunch of things being ran every time a barrier was being created that was not necessary.

So now the new logic, simplified:
Mouse hits barrier, XIBarrierEvent generated and sent off.
Nux receives XEvent and passes it back to EdgeBarrierController.cpp::HandleEventCB
In HandleEventCB we check to see of the opcode matches, if so pass it to HandleEvent
In HandleEvent we check if its a type XI_BarrierHit
If so, then find the barrier wrapper the event belongs to.
(XGetEventData works onces per event, so the logic we had before didn't work).
From here we pass it to PointerBarrier.cpp::HandleBarrierEvent,
Here we are pretty much back to where we were before the changed :).

[Andrea Azzarone (azzar1)]

review: Approve

[Sebastien Bacher (seb128)]

trying to build with the old libxfixes it fails on:

"/usr/include/X11/extensions/XInput2.h:173:22: error: conflicting declaration ‘typedef unsigned int BarrierEventID’
  typedef unsigned int BarrierEventID;

the requirement/build-depends on that one should probably be bumped as well

works fine otherwise ;-)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3175
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~brandontschaefer/unity/move-pointer-barrier-to-xi-1.6.99.1/+merge/150175/+edit-commit-message

http://jenkins.qa.ubuntu.com/job/unity-ci/182/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-saucy-amd64-ci/70/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-saucy-armhf-ci/70/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-saucy-i386-ci/70/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/unity-ci/182/rebuild

review: Needs Fixing (continuous-integration)

[Timo Jyrinki (timo-jyrinki)]

Continuing at https://code.launchpad.net/~timo-jyrinki/unity/move-pointer-barries-to-xi-1.6.99.1_try2/+merge/172975 for the missing epoch and libxfixes dep.

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2013-06-26 14:29:55 +0000
+++ CMakeLists.txt	2013-07-03 16:16:23 +0000
@@ -10,7 +10,7 @@
 set (PROJECT_NAME "unity")
 set (UNITY_MAJOR 7)
 set (UNITY_MINOR 0)
-set (UNITY_MICRO 1)
+set (UNITY_MICRO 2)
 set (UNITY_VERSION "${UNITY_MAJOR}.${UNITY_MINOR}.${UNITY_MICRO}")
 set (UNITY_API_VERSION "6.0")
 set (UNITY_COMPONENTS_VERSION "6")
@@ -244,6 +244,7 @@
       libgeis
       x11
       xfixes
+      xi>=1.6.99.1
       xrender>=0.9
   )
 endif ()

=== modified file 'debian/changelog'
--- debian/changelog	2013-07-03 04:03:34 +0000
+++ debian/changelog	2013-07-03 16:16:23 +0000
@@ -401,9 +401,6 @@
 unity (7.0.0daily13.05.08ubuntu.unity.next-0ubuntu1) raring; urgency=low
 
   * Automatic snapshot from revision 3317 (ubuntu-unity/next)
- 
- -- Ubuntu daily release <[e-mail]>   Wed, 08 May 2013 04:57:49 +0000
-
 unity (7.0.0daily13.05.01.1ubuntu.unity.next-0ubuntu1) raring; urgency=low
 
   [ Sebastien Bacher ]
@@ -942,6 +939,10 @@
   [ Automatic PS uploader ]
   * Automatic snapshot from revision 3140
 
+  [ Brandon Schaefer ]
+  * Moved PointerBarrier logic to the new xserver 1.14 (libXi 1.6.99.1)
+    version.
+
  -- Automatic PS uploader <[e-mail]>  Fri, 08 Feb 2013 04:02:00 +0000
 
 unity (6.12.0daily13.02.07-0ubuntu1) raring; urgency=low

=== modified file 'debian/control'
--- debian/control	2013-07-02 09:30:43 +0000
+++ debian/control	2013-07-03 16:16:23 +0000
@@ -44,6 +44,7 @@
                libunity-scopes-json-def-desktop,
                libzeitgeist-dev (>= 0.3.18),
                libxfixes-dev (>= 1:5.0-4ubuntu4),
+               libxi-dev (>= 1.6.99.1),
                libxpathselect-dev (>=1.3),
                libgtest-dev,
                google-mock,

=== modified file 'launcher/EdgeBarrierController.cpp'
--- launcher/EdgeBarrierController.cpp	2013-04-02 01:57:03 +0000
+++ launcher/EdgeBarrierController.cpp	2013-07-03 16:16:23 +0000
@@ -21,6 +21,7 @@
 #include "EdgeBarrierController.h"
 #include "EdgeBarrierControllerPrivate.h"
 #include "Decaymulator.h"
+#include <NuxCore/Logger.h>
 #include "unity-shared/UScreen.h"
 #include "UnityCore/GLibSource.h"
 
@@ -32,11 +33,50 @@
 namespace
 {
   int const Y_BREAK_BUFFER = 20;
-}
-
+  int const MAJOR = 2;
+  int const MINOR = 3;
+}
+
+DECLARE_LOGGER(logger, "unity.edge_barrier_controller");
+
+int GetXI2OpCode()
+{
+  Display *dpy = nux::GetGraphicsDisplay()->GetX11Display();
+
+  int opcode, event_base, error_base;
+  if (!XQueryExtension(dpy, "XFIXES",
+                       &opcode,
+                       &event_base,
+                       &error_base))
+  {
+    LOG_ERROR(logger) << "Missing XFixes";
+    return -1;
+  }
+
+  if (!XQueryExtension (dpy, "XInputExtension",
+                        &opcode,
+                        &event_base,
+                        &error_base))
+  {
+    LOG_ERROR(logger) << "Missing XInput";
+    return -1;
+  }
+
+  int maj = MAJOR;
+  int min = MINOR;
+
+  if (XIQueryVersion(dpy, &maj, &min) == BadRequest)
+  {
+    LOG_ERROR(logger) << "Need XInput version 2.3";
+    return -1;
+  }
+
+  return opcode;
+}
 
 EdgeBarrierController::Impl::Impl(EdgeBarrierController *parent)
-  : edge_overcome_pressure_(0)
+  : xi2_opcode_(-1)
+  , edge_overcome_pressure_(0)
   , parent_(parent)
 {
   UScreen *uscreen = UScreen::GetDefault();
@@ -68,6 +108,13 @@
     });
     SetupBarriers(UScreen::GetDefault()->GetMonitors());
   });
+
+  xi2_opcode_ = GetXI2OpCode();
+}
+
+EdgeBarrierController::Impl::~Impl()
+{
+  nux::GetGraphicsDisplay()->RemoveEventFilter(this);
 }
 
 void EdgeBarrierController::Impl::ResizeBarrierList(std::vector<nux::Geometry> const& layout)
@@ -86,6 +133,18 @@
   }
 }
 
+void SetupXI2Events()
+{
+  Display *dpy = nux::GetGraphicsDisplay()->GetX11Display();
+
+  unsigned char mask_bits[XIMaskLen (XI_LASTEVENT)] = { 0 };
+  XIEventMask mask = { XIAllMasterDevices, sizeof (mask_bits), mask_bits };
+
+  XISetMask(mask.mask, XI_BarrierHit);
+  XISetMask(mask.mask, XI_BarrierLeave);
+  XISelectEvents (dpy, DefaultRootWindow(dpy), &mask, 1);
+}
+
 void EdgeBarrierController::Impl::SetupBarriers(std::vector<nux::Geometry> const& layout)
 {
   bool edge_resist = parent_->sticky_edges();
@@ -112,6 +171,9 @@
     barrier->ConstructBarrier();
   }
 
+  SetupXI2Events();
+  AddEventFilter();
+
   float decay_responsiveness_mult = ((parent_->options()->edge_responsiveness() - 1) * .3f) + 1;
   decaymulator_.rate_of_decay = parent_->options()->edge_decay_rate() * decay_responsiveness_mult;
 
@@ -119,6 +181,67 @@
   edge_overcome_pressure_ = parent_->options()->edge_overcome_pressure() * overcome_responsiveness_mult;
 }
 
+void EdgeBarrierController::Impl::AddEventFilter()
+{
+  // Remove an old one, if it exists
+  nux::GetGraphicsDisplay()->RemoveEventFilter(this);
+
+  nux::GraphicsDisplay::EventFilterArg event_filter;
+  event_filter.filter = &HandleEventCB;
+  event_filter.data = this;
+
+  nux::GetGraphicsDisplay()->AddEventFilter(event_filter);
+}
+
+bool EdgeBarrierController::Impl::HandleEvent(XEvent xevent)
+{
+  Display *dpy = nux::GetGraphicsDisplay()->GetX11Display();
+  XGenericEventCookie *cookie = &xevent.xcookie;
+  bool ret = false;
+
+  switch (cookie->evtype)
+  {
+    case (XI_BarrierHit):
+    {
+      if (XGetEventData(dpy, cookie))
+      {
+        XIBarrierEvent* barrier_event = (XIBarrierEvent*)cookie->data;
+        PointerBarrierWrapper::Ptr wrapper = FindBarrierEventOwner(barrier_event);
+
+        if (wrapper)
+          ret = wrapper->HandleBarrierEvent(barrier_event);
+      }
+
+      XFreeEventData(dpy, cookie);
+      break;
+    }
+    default:
+      break;
+  }
+
+  return ret;
+}
+
+bool EdgeBarrierController::Impl::HandleEventCB(XEvent xevent, void* data)
+{
+  auto edge_barrier_controller = static_cast<EdgeBarrierController::Impl*>(data);
+  int const xi2_opcode = edge_barrier_controller->xi2_opcode_;
+
+  if (xevent.type != GenericEvent || xevent.xcookie.extension != xi2_opcode)
+    return false;
+
+  return edge_barrier_controller->HandleEvent(xevent);
+}
+
+PointerBarrierWrapper::Ptr EdgeBarrierController::Impl::FindBarrierEventOwner(XIBarrierEvent* barrier_event)
+{
+  for (auto barrier : barriers_)
+    if (barrier->OwnsBarrierEvent(barrier_event->barrier))
+      return barrier;
+
+  return nullptr;
+}
+
 void EdgeBarrierController::Impl::BarrierReset()
 {
   decaymulator_.value = 0;

=== modified file 'launcher/EdgeBarrierControllerPrivate.h'
--- launcher/EdgeBarrierControllerPrivate.h	2013-02-13 19:21:49 +0000
+++ launcher/EdgeBarrierControllerPrivate.h	2013-07-03 16:16:23 +0000
@@ -33,6 +33,7 @@
 struct EdgeBarrierController::Impl
 {
   Impl(EdgeBarrierController *parent);
+  ~Impl();
 
   void ResizeBarrierList(std::vector<nux::Geometry> const& layout);
   void SetupBarriers(std::vector<nux::Geometry> const& layout);
@@ -44,10 +45,18 @@
 
   bool EventIsInsideYBreakZone(BarrierEvent::Ptr const& event);
 
+  void AddEventFilter();
+
+  PointerBarrierWrapper::Ptr FindBarrierEventOwner(XIBarrierEvent* barrier_event);
+
+  static bool HandleEventCB(XEvent event, void* data);
+  bool HandleEvent(XEvent event);
+
   std::vector<PointerBarrierWrapper::Ptr> barriers_;
   std::vector<EdgeBarrierSubscriber*> subscribers_;
   Decaymulator decaymulator_;
   glib::Source::UniquePtr release_timeout_;
+  int xi2_opcode_;
   float edge_overcome_pressure_;
   EdgeBarrierController* parent_;
 };

=== modified file 'launcher/PointerBarrier.cpp'
--- launcher/PointerBarrier.cpp	2013-02-11 23:57:09 +0000
+++ launcher/PointerBarrier.cpp	2013-07-03 16:16:23 +0000
@@ -13,12 +13,14 @@
 *
 * 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: Jason Smith <[e-mail]>
+*              Brandon Schaefer <[e-mail]>
+*
 */
 
 #include <unistd.h>
 #include <stdlib.h>
-#include <stdio.h>
-#include <X11/extensions/Xfixes.h>
 
 #include "PointerBarrier.h"
 
@@ -27,14 +29,6 @@
 namespace ui
 {
 
-namespace local
-{
-namespace
-{
-  bool is_selected_for = false;
-}
-}
-
 PointerBarrierWrapper::PointerBarrierWrapper()
   : active(false)
   , released(false)
@@ -42,10 +36,11 @@
   , smoothing(75)
   , max_velocity_multiplier(1.0f)
   , direction(BOTH)
-  , event_base_(0)
+  , xi2_opcode_(0)
   , last_event_(0)
+  , current_device_(0)
   , first_event_(false)
-  , barrier(0)
+  , barrier_(0)
   , smoothing_count_(0)
   , smoothing_accum_(0)
 {}
@@ -62,34 +57,14 @@
 
   Display *dpy = nux::GetGraphicsDisplay()->GetX11Display();
 
-  int error_base;
-  XFixesQueryExtension(dpy, &event_base_, &error_base);
-
-  int maj,min;
-  XFixesQueryVersion(dpy, &maj, &min);
-
-  barrier = XFixesCreatePointerBarrierVelocity(dpy,
-                                               DefaultRootWindow(dpy),
-                                               x1, y1,
-                                               x2, y2,
-                                               static_cast<int>(direction),
-                                               threshold,
-                                               0,
-                                               NULL);
-
-  if (!local::is_selected_for)
-  {
-    XFixesSelectBarrierInput(dpy, DefaultRootWindow(dpy), 0xdeadbeef);
-    local::is_selected_for = true;
-  }
+  barrier_ = XFixesCreatePointerBarrier(dpy,
+                                        DefaultRootWindow(dpy),
+                                        x1, y1,
+                                        x2, y2,
+                                        static_cast<int>(direction),
+                                        0, NULL);
 
   active = true;
-
-  nux::GraphicsDisplay::EventFilterArg event_filter;
-  event_filter.filter = &PointerBarrierWrapper::HandleEventWrapper;
-  event_filter.data = this;
-
-  nux::GetGraphicsDisplay()->AddEventFilter(event_filter);
 }
 
 void PointerBarrierWrapper::DestroyBarrier()
@@ -100,14 +75,13 @@
   active = false;
 
   Display *dpy = nux::GetGraphicsDisplay()->GetX11Display();
-  XFixesDestroyPointerBarrier(dpy, barrier);
-
-  nux::GetGraphicsDisplay()->RemoveEventFilter(this);
+  XFixesDestroyPointerBarrier(dpy, barrier_);
 }
 
 void PointerBarrierWrapper::ReleaseBarrier(int event_id)
 {
-  XFixesBarrierReleasePointer(nux::GetGraphicsDisplay()->GetX11Display(), barrier, event_id);
+  Display *dpy = nux::GetGraphicsDisplay()->GetX11Display();
+  XIBarrierReleasePointer(dpy, current_device_, barrier_, event_id);
 }
 
 void PointerBarrierWrapper::EmitCurrentData(int event_id, int x, int y)
@@ -134,63 +108,77 @@
   return first_event_;
 }
 
-bool PointerBarrierWrapper::HandleEvent(XEvent xevent)
-{
-  if (xevent.type - event_base_ == XFixesBarrierNotify)
-  {
-    auto notify_event = reinterpret_cast<XFixesBarrierNotifyEvent*>(&xevent);
-
-    if (notify_event->barrier == barrier && notify_event->subtype == XFixesBarrierHitNotify)
+int GetEventVelocity(XIBarrierEvent* event)
+{
+  double dx, dy;
+  double speed;
+  unsigned int millis;
+
+  dx = event->dx;
+  dy = event->dy;
+
+  // Sometimes dtime is 0, if so we don't want to divide by zero!
+  millis = event->dtime ?: 1;
+
+  speed = sqrt(dx * dx + dy * dy) / millis * 1000;
+
+  return speed;
+}
+
+bool PointerBarrierWrapper::OwnsBarrierEvent(PointerBarrier const barrier) const
+{
+  return barrier_ == barrier;
+}
+
+bool PointerBarrierWrapper::HandleBarrierEvent(XIBarrierEvent* barrier_event)
+{
+  int velocity = GetEventVelocity(barrier_event);
+  smoothing_accum_ += velocity;
+  smoothing_count_++;
+
+  current_device_ = barrier_event->deviceid;
+
+  if (velocity > threshold)
+  {
+    smoothing_timeout_.reset();
+    ReleaseBarrier(barrier_event->eventid);
+  }
+  else if (released)
+  {
+     /* If the barrier is released, just emit the current event without
+     * waiting, so there won't be any delay on releasing the barrier. */
+    smoothing_timeout_.reset();
+
+    SendBarrierEvent(barrier_event->root_x, barrier_event->root_y,
+                     velocity, barrier_event->eventid);
+  }
+  else if (!smoothing_timeout_)
+  {
+    int x = barrier_event->root_x;
+    int y = barrier_event->root_y;
+    int event = barrier_event->eventid;
+
+    // If we are a new event, don't delay sending the first event
+    if (last_event_ != event)
     {
-      smoothing_accum_ += notify_event->velocity;
-      smoothing_count_++;
-
-      if (released)
-      {
-        /* If the barrier is released, just emit the current event without
-         * waiting, so there won't be any delay on releasing the barrier. */
-        smoothing_timeout_.reset();
-
-        SendBarrierEvent(notify_event->x, notify_event->y,
-                         notify_event->velocity, notify_event->event_id);
-      }
-      else if (!smoothing_timeout_)
-      {
-        int x = notify_event->x;
-        int y = notify_event->y;
-        int event = notify_event->event_id;
-
-        // If we are a new event, don't delay sending the first event
-        if (last_event_ != event)
-        {
-          first_event_ = true;
-          last_event_ = event;
-
-          SendBarrierEvent(notify_event->x, notify_event->y,
-                           notify_event->velocity, notify_event->event_id);
-
-          first_event_ = false;
-        }
-
-        smoothing_timeout_.reset(new glib::Timeout(smoothing, [this, event, x, y] () {
-          EmitCurrentData(event, x, y);
-
-          smoothing_timeout_.reset();
-          return false;
-        }));
-      }
+      first_event_ = true;
+      last_event_ = event;
+
+      SendBarrierEvent(barrier_event->root_x, barrier_event->root_y,
+                       velocity, barrier_event->eventid);
+
+      first_event_ = false;
     }
 
-    return notify_event->barrier == barrier;
+    smoothing_timeout_.reset(new glib::Timeout(smoothing, [this, event, x, y] () {
+      EmitCurrentData(event, x, y);
+
+      smoothing_timeout_.reset();
+      return false;
+    }));
   }
 
-  return false;
-}
-
-bool PointerBarrierWrapper::HandleEventWrapper(XEvent event, void* data)
-{
-  PointerBarrierWrapper* wrapper = (PointerBarrierWrapper*)data;
-  return wrapper->HandleEvent(event);
+  return true;
 }
 
 }

=== modified file 'launcher/PointerBarrier.h'
--- launcher/PointerBarrier.h	2013-02-11 23:57:09 +0000
+++ launcher/PointerBarrier.h	2013-07-03 16:16:23 +0000
@@ -23,6 +23,7 @@
 #include <Nux/Nux.h>
 #include <X11/Xlib.h>
 #include <X11/extensions/Xfixes.h>
+#include <X11/extensions/XInput2.h>
 #include <UnityCore/GLibSource.h>
 
 namespace unity
@@ -88,19 +89,20 @@
 
   bool IsFirstEvent() const;
 
+  bool OwnsBarrierEvent(PointerBarrier const barrier) const;
+  bool HandleBarrierEvent(XIBarrierEvent* barrier_event);
+
 protected:
   void EmitCurrentData(int event_id, int x, int y);
-  bool HandleEvent(XEvent event);
 
 private:
-  static bool HandleEventWrapper(XEvent event, void* data);
-
   void SendBarrierEvent(int x, int y, int velocity, int event_id);
 
-  int event_base_;
+  int xi2_opcode_;
   int last_event_;
+  int current_device_;
   bool first_event_;
-  PointerBarrier barrier;
+  PointerBarrier barrier_;
 
   int smoothing_count_;
   int smoothing_accum_;

=== modified file 'tests/test_pointer_barrier.cpp'
--- tests/test_pointer_barrier.cpp	2013-02-12 23:48:23 +0000
+++ tests/test_pointer_barrier.cpp	2013-07-03 16:16:23 +0000
@@ -15,6 +15,7 @@
  * <http://www.gnu.org/licenses/>
  *
  * Authored by: Marco Trevisan (Treviño) <[e-mail]>
+ *              Brandon Schaefer <[e-mail]>
  *
  */
 
@@ -32,20 +33,21 @@
 class MockPointerBarrier : public PointerBarrierWrapper
 {
 public:
-  bool HandleEvent(XEvent ev) { return PointerBarrierWrapper::HandleEvent(ev); }
+  bool HandleBarrierEvent(XIBarrierEvent* b_ev) { return PointerBarrierWrapper::HandleBarrierEvent(b_ev); }
 };
 
-XFixesBarrierNotifyEvent GetGenericEvent (unsigned int id)
+XIBarrierEvent GetGenericEvent (unsigned int id)
 {
-  XFixesBarrierNotifyEvent ev;
+  XIBarrierEvent ev;
 
-  ev.type = XFixesBarrierNotify;
-  ev.subtype = XFixesBarrierHitNotify;
+  ev.evtype = GenericEvent;
   ev.barrier = 0;
-  ev.event_id = id;
-  ev.x = 555;
-  ev.y = 333;
-  ev.velocity = std::numeric_limits<int>::max();
+  ev.eventid = id;
+  ev.root_x = 555;
+  ev.root_y = 333;
+  ev.dx = 10;
+  ev.dy = 10;
+  ev.dtime = 15;
 
   return ev;
 }
@@ -70,29 +72,11 @@
   EXPECT_EQ(bev.event_id, 4);
 }
 
-TEST(TestPointerBarrier, HandleInvalidEvents)
-{
-  MockPointerBarrier pb;
-  XFixesBarrierNotifyEvent ev;
-  auto xev = reinterpret_cast<XEvent*>(&ev);
-
-  ev.type = XFixesBarrierNotify + 1;
-  EXPECT_FALSE(pb.HandleEvent(*xev));
-
-  ev.type = XFixesBarrierNotify;
-  ev.subtype = XFixesBarrierHitNotify + 1;
-  ev.barrier = 1;
-  EXPECT_FALSE(pb.HandleEvent(*xev));
-
-  ev.barrier = 0;
-  EXPECT_TRUE(pb.HandleEvent(*xev));
-}
-
 TEST(TestPointerBarrier, HandleHitNotifyEvents)
 {
   MockPointerBarrier pb;
-  XFixesBarrierNotifyEvent ev = GetGenericEvent(0xdeadbeef);
-  auto xev = reinterpret_cast<XEvent*>(&ev);
+  pb.threshold = 1000;
+  XIBarrierEvent ev = GetGenericEvent(0xdeadbeef);
 
   bool got_event = false;
 
@@ -102,14 +86,14 @@
       got_event = true;
 
       EXPECT_EQ(pbw, &pb);
-      EXPECT_EQ(bev->x, ev.x);
-      EXPECT_EQ(bev->y, ev.y);
+      EXPECT_EQ(bev->x, ev.root_x);
+      EXPECT_EQ(bev->y, ev.root_y);
       EXPECT_EQ(bev->velocity, 600 * pb.max_velocity_multiplier);
-      EXPECT_EQ(bev->event_id, ev.event_id);
+      EXPECT_EQ(bev->event_id, ev.eventid);
      }
   });
 
-  EXPECT_TRUE(pb.HandleEvent(*xev));
+  EXPECT_TRUE(pb.HandleBarrierEvent(&ev));
   EXPECT_FALSE(got_event);
 
   Utils::WaitForTimeoutMSec(pb.smoothing());
@@ -120,30 +104,30 @@
 TEST(TestPointerBarrier, HandleHitNotifyReleasedEvents)
 {
   MockPointerBarrier pb;
-  XFixesBarrierNotifyEvent ev = GetGenericEvent(0xabba);
-  auto xev = reinterpret_cast<XEvent*>(&ev);
+  pb.threshold = 1000;
+  XIBarrierEvent ev = GetGenericEvent(0xabba);
   bool got_event = false;
 
   pb.barrier_event.connect([&] (PointerBarrierWrapper* pbw, BarrierEvent::Ptr bev) {
     got_event = true;
 
     EXPECT_EQ(pbw, &pb);
-    EXPECT_EQ(bev->x, ev.x);
-    EXPECT_EQ(bev->y, ev.y);
-    EXPECT_EQ(bev->velocity, ev.velocity);
-    EXPECT_EQ(bev->event_id, ev.event_id);
+    EXPECT_EQ(bev->x, ev.root_x);
+    EXPECT_EQ(bev->y, ev.root_y);
+    EXPECT_GT(bev->velocity, 0);
+    EXPECT_EQ(bev->event_id, ev.eventid);
   });
 
   pb.released = true;
-  EXPECT_TRUE(pb.HandleEvent(*xev));
+  EXPECT_TRUE(pb.HandleBarrierEvent(&ev));
   EXPECT_TRUE(got_event);
 }
 
 TEST(TestPointerBarrier, ReciveFirstEvent)
 {
   MockPointerBarrier pb;
-  XFixesBarrierNotifyEvent ev = GetGenericEvent(0xabba);
-  auto xev = reinterpret_cast<XEvent*>(&ev);
+  pb.threshold = 1000;
+  XIBarrierEvent ev = GetGenericEvent(0xabba);
 
   bool first_is_true = false;
 
@@ -151,15 +135,15 @@
     first_is_true = true;
   });
 
-  EXPECT_TRUE(pb.HandleEvent(*xev));
+  EXPECT_TRUE(pb.HandleBarrierEvent(&ev));
   EXPECT_TRUE(first_is_true);
 }
 
 TEST(TestPointerBarrier, ReciveSecondEventFirstFalse)
 {
   MockPointerBarrier pb;
-  XFixesBarrierNotifyEvent ev = GetGenericEvent(0xabba);
-  auto xev = reinterpret_cast<XEvent*>(&ev);
+  pb.threshold = 1000;
+  XIBarrierEvent ev = GetGenericEvent(0xabba);
   int events_recived = 0;
 
   pb.barrier_event.connect([&] (PointerBarrierWrapper* pbw, BarrierEvent::Ptr bev) {
@@ -171,7 +155,7 @@
         EXPECT_FALSE(pbw->IsFirstEvent());
   });
 
-  EXPECT_TRUE(pb.HandleEvent(*xev));
+  EXPECT_TRUE(pb.HandleBarrierEvent(&ev));
 
   Utils::WaitForTimeoutMSec(pb.smoothing());