ash: ozone: apply transformation to events outside the root window

ui/events/ozone/evdev/libgestures_glue/gesture_interpreter_libevdev_cros.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/events/ozone/evdev/libgestures_glue/gesture_interpreter_libevdev_cros.h"
 
 #include <gestures/gestures.h>
 #include <libevdev/libevdev.h>
 
 #include "base/strings/stringprintf.h"
@@ skipping 233 matching lines @@
                                  move->dy,
                                  move->ordinal_dx,
                                  move->ordinal_dy);
   if (!cursor_)
     return;  // No cursor!
 
   cursor_->MoveCursor(gfx::Vector2dF(move->dx, move->dy));
   // TODO(spang): Use move->ordinal_dx, move->ordinal_dy
   // TODO(spang): Use move->start_time, move->end_time
   Dispatch(make_scoped_ptr(new MouseEvent(ET_MOUSE_MOVED,
-                                          cursor_->location(),
-                                          cursor_->location(),
+                                          cursor_->GetLocation(),
+                                          cursor_->GetRootLocation(),
                                           modifiers_->GetModifierFlags(),
                                           /* changed_button_flags */ 0)));
 }
 
 void GestureInterpreterLibevdevCros::OnGestureScroll(
     const Gesture* gesture,
     const GestureScroll* scroll) {
   DVLOG(3) << base::StringPrintf("Gesture Scroll: (%f, %f) [%f, %f]",
                                  scroll->dx,
                                  scroll->dy,
                                  scroll->ordinal_dx,
                                  scroll->ordinal_dy);
   if (!cursor_)
     return;  // No cursor!
 
   // TODO(spang): Support SetNaturalScroll
   // TODO(spang): Use scroll->start_time
   Dispatch(make_scoped_ptr(new ScrollEvent(ET_SCROLL,
-                                           cursor_->location(),
+                                           cursor_->GetLocation(),
+                                           cursor_->GetRootLocation(),
                                            StimeToTimedelta(gesture->end_time),
                                            modifiers_->GetModifierFlags(),
                                            scroll->dx,
                                            scroll->dy,
                                            scroll->ordinal_dx,
                                            scroll->ordinal_dy,
                                            kGestureScrollFingerCount)));
 }
 
 void GestureInterpreterLibevdevCros::OnGestureButtonsChange(
@@ skipping 46 matching lines @@
 
   if (!cursor_)
     return;  // No cursor!
 
   EventType type =
       (fling->fling_state == GESTURES_FLING_START ? ET_SCROLL_FLING_START
                                                   : ET_SCROLL_FLING_CANCEL);
 
   // Fling is like 2-finger scrolling but with velocity instead of displacement.
   Dispatch(make_scoped_ptr(new ScrollEvent(type,
-                                           cursor_->location(),
+                                           cursor_->GetLocation(),
+                                           cursor_->GetRootLocation(),
                                            StimeToTimedelta(gesture->end_time),
                                            modifiers_->GetModifierFlags(),
                                            fling->vx,
                                            fling->vy,
                                            fling->ordinal_vx,
                                            fling->ordinal_vy,
                                            kGestureScrollFingerCount)));
 }
 
 void GestureInterpreterLibevdevCros::OnGestureSwipe(const Gesture* gesture,
                                                     const GestureSwipe* swipe) {
   DVLOG(3) << base::StringPrintf("Gesture Swipe: (%f, %f) [%f, %f]",
                                  swipe->dx,
                                  swipe->dy,
                                  swipe->ordinal_dx,
                                  swipe->ordinal_dy);
 
   if (!cursor_)
     return;  // No cursor!
 
   // Swipe is 3-finger scrolling.
   Dispatch(make_scoped_ptr(new ScrollEvent(ET_SCROLL,
-                                           cursor_->location(),
+                                           cursor_->GetLocation(),
+                                           cursor_->GetRootLocation(),
                                            StimeToTimedelta(gesture->end_time),
                                            modifiers_->GetModifierFlags(),
                                            swipe->dx,
                                            swipe->dy,
                                            swipe->ordinal_dx,
                                            swipe->ordinal_dy,
                                            kGestureSwipeFingerCount)));
 }
 
 void GestureInterpreterLibevdevCros::OnGestureSwipeLift(
     const Gesture* gesture,
     const GestureSwipeLift* swipelift) {
   DVLOG(3) << base::StringPrintf("Gesture Swipe Lift");
 
   if (!cursor_)
     return;  // No cursor!
 
   // Turn a swipe lift into a fling start.
   // TODO(spang): Figure out why and put it in this comment.
 
   Dispatch(make_scoped_ptr(new ScrollEvent(ET_SCROLL_FLING_START,
-                                           cursor_->location(),
+                                           cursor_->GetLocation(),
+                                           cursor_->GetRootLocation(),
                                            StimeToTimedelta(gesture->end_time),
                                            modifiers_->GetModifierFlags(),
                                            /* x_offset */ 0,
                                            /* y_offset */ 0,
                                            /* x_offset_ordinal */ 0,
                                            /* y_offset_ordinal */ 0,
                                            kGestureScrollFingerCount)));
 }
 
 void GestureInterpreterLibevdevCros::OnGesturePinch(const Gesture* gesture,
@@ skipping 16 matching lines @@
                                  metrics->type);
   NOTIMPLEMENTED();
 }
 
 void GestureInterpreterLibevdevCros::Dispatch(scoped_ptr<Event> event) {
   dispatch_callback_.Run(event.Pass());
 }
 
 void GestureInterpreterLibevdevCros::DispatchMouseButton(unsigned int modifier,
                                                          bool down) {
-  const gfx::PointF& loc = cursor_->location();
+  const gfx::PointF& loc = cursor_->GetLocation();
+  const gfx::PointF& root_loc = cursor_->GetRootLocation();

[sadrul, 2014/11/24 22:27:04]

Do these need to be &?

   int flag = modifiers_->GetEventFlagFromModifier(modifier);
   EventType type = (down ? ET_MOUSE_PRESSED : ET_MOUSE_RELEASED);
   modifiers_->UpdateModifier(modifier, down);
   Dispatch(make_scoped_ptr(new MouseEvent(
-      type, loc, loc, modifiers_->GetModifierFlags() | flag, flag)));
+      type, loc, root_loc, modifiers_->GetModifierFlags() | flag, flag)));
 }
 
 void GestureInterpreterLibevdevCros::DispatchChangedKeys(Evdev* evdev,
                                                          const timeval& time) {
   unsigned long key_state_diff[EVDEV_BITS_TO_LONGS(KEY_CNT)];
 
   // Find changed keys.
   for (unsigned long i = 0; i < arraysize(key_state_diff); ++i)
     key_state_diff[i] = evdev->key_state_bitmask[i] ^ prev_key_state_[i];
 
@@ skipping 14 matching lines @@
       keyboard_->OnKeyChange(key, value);
     }
   }
 
   // Update internal key state.
   for (unsigned long i = 0; i < EVDEV_BITS_TO_LONGS(KEY_CNT); ++i)
     prev_key_state_[i] = evdev->key_state_bitmask[i];
 }
 
 }  // namespace ui