Implement ui_controls for aura

ui/aura/desktop_host_linux.cc

 // Copyright (c) 2011 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/aura/desktop_host.h"
 
 #include <X11/cursorfont.h>
 #include <X11/Xlib.h>
 
 // Get rid of a macro from Xlib.h that conflicts with Aura's RootWindow class.
@@ skipping 223 matching lines @@
   // DesktopHost Overrides.
   virtual void SetDesktop(Desktop* desktop) OVERRIDE;
   virtual gfx::AcceleratedWidget GetAcceleratedWidget() OVERRIDE;
   virtual void Show() OVERRIDE;
   virtual void ToggleFullScreen() OVERRIDE;
   virtual gfx::Size GetSize() const OVERRIDE;
   virtual void SetSize(const gfx::Size& size) OVERRIDE;
   virtual void SetCursor(gfx::NativeCursor cursor_type) OVERRIDE;
   virtual gfx::Point QueryMouseLocation() OVERRIDE;
   virtual void PostNativeEvent(const base::NativeEvent& event) OVERRIDE;
+  virtual void ConvertPointToNativeScreen(gfx::Point* point) const OVERRIDE;
 
   // Returns true if there's an X window manager present... in most cases.  Some
   // window managers (notably, ion3) don't implement enough of ICCCM for us to
   // detect that they're there.
   bool IsWindowManagerPresent();
 
   Desktop* desktop_;
 
   // The display and the native X window hosting the desktop.
   Display* xdisplay_;
   ::Window xwindow_;
 
   // Current Aura cursor.
   gfx::NativeCursor current_cursor_;
 
-  // The size of |xwindow_|.
-  gfx::Size size_;
+  // The bounds of |xwindow_|.
+  gfx::Rect bounds_;
 
   DISALLOW_COPY_AND_ASSIGN(DesktopHostLinux);
 };
 
 DesktopHostLinux::DesktopHostLinux(const gfx::Rect& bounds)
     : desktop_(NULL),
       xdisplay_(base::MessagePumpX::GetDefaultXDisplay()),
       xwindow_(0),
       current_cursor_(aura::kCursorNull),
-      size_(bounds.size()) {
+      bounds_(bounds) {
   xwindow_ = XCreateSimpleWindow(xdisplay_, DefaultRootWindow(xdisplay_),
                                  bounds.x(), bounds.y(),
                                  bounds.width(), bounds.height(),
                                  0, 0, 0);
 
   long event_mask = ButtonPressMask | ButtonReleaseMask |
                     KeyPressMask | KeyReleaseMask |
                     ExposureMask | VisibilityChangeMask |
                     StructureNotifyMask | PropertyChangeMask |
                     PointerMotionMask;
@@ skipping 43 matching lines @@
       break;
     }
     case ConfigureNotify: {
       DCHECK_EQ(xdisplay_, xev->xconfigure.display);
       DCHECK_EQ(xwindow_, xev->xconfigure.window);
       DCHECK_EQ(xwindow_, xev->xconfigure.event);
 
       // It's possible that the X window may be resized by some other means than
       // from within aura (e.g. the X window manager can change the size). Make
       // sure the desktop size is maintained properly.
-      gfx::Size size(xev->xconfigure.width, xev->xconfigure.height);
-      if (size_ != size) {
-        size_ = size;
-        desktop_->OnHostResized(size);
-      }
+      gfx::Rect bounds(xev->xconfigure.x, xev->xconfigure.y,
+                       xev->xconfigure.width, xev->xconfigure.height);
+      bool size_changed = bounds_.size() != bounds.size();
+      bounds_ = bounds;
+      if (size_changed)
+        desktop_->OnHostResized(bounds.size());
       handled = true;
       break;
     }
     case GenericEvent: {
       ui::TouchFactory* factory = ui::TouchFactory::GetInstance();
       if (!factory->ShouldProcessXI2Event(xev))
         break;
 
       // If this is a motion event we want to coalesce all pending motion
       // events that are at the top of the queue.
@@ skipping 81 matching lines @@
 
 void DesktopHostLinux::Show() {
   XMapWindow(xdisplay_, xwindow_);
 }
 
 void DesktopHostLinux::ToggleFullScreen() {
   NOTIMPLEMENTED();
 }
 
 gfx::Size DesktopHostLinux::GetSize() const {
-  return size_;
+  return bounds_.size();
 }
 
 void DesktopHostLinux::SetSize(const gfx::Size& size) {
-  if (size == size_)
+  if (size == bounds_.size())
     return;
 
   XResizeWindow(xdisplay_, xwindow_, size.width(), size.height());
 
   // Assume that the resize will go through as requested, which should be the
   // case if we're running without a window manager.  If there's a window
   // manager, it can modify or ignore the request, but (per ICCCM) we'll get a
   // (possibly synthetic) ConfigureNotify about the actual size and correct
-  // |size_| later.
-  size_ = size;
+  // |bounds_| later.
+  bounds_.set_size(size);
   desktop_->OnHostResized(size);
 }
 
 void DesktopHostLinux::SetCursor(gfx::NativeCursor cursor) {
   if (current_cursor_ == cursor)
     return;
   current_cursor_ = cursor;
   // Custom web cursors are handled directly.
   if (cursor == kCursorCustom)
     return;
   int cursor_shape = CursorShapeFromNative(cursor);
   ::Cursor xcursor = ui::GetXCursor(cursor_shape);
   XDefineCursor(xdisplay_, xwindow_, xcursor);
 }
 
 gfx::Point DesktopHostLinux::QueryMouseLocation() {
   ::Window root_return, child_return;
   int root_x_return, root_y_return, win_x_return, win_y_return;
   unsigned int mask_return;
   XQueryPointer(xdisplay_,
                 xwindow_,
                 &root_return,
                 &child_return,
                 &root_x_return, &root_y_return,
                 &win_x_return, &win_y_return,
                 &mask_return);
-  return gfx::Point(max(0, min(size_.width(), win_x_return)),
-                    max(0, min(size_.height(), win_y_return)));
+  return gfx::Point(max(0, min(bounds_.width(), win_x_return)),
+                    max(0, min(bounds_.height(), win_y_return)));
+}
+
+void DesktopHostLinux::ConvertPointToNativeScreen(gfx::Point* point) const {
+  point->Offset(bounds_.x(), bounds_.y());
 }
 
 void DesktopHostLinux::PostNativeEvent(const base::NativeEvent& native_event) {
+  const long kInputEventMask = KeyReleaseMask | KeyPressMask |
+      PointerMotionMask | ButtonPressMask | ButtonReleaseMask;
   DCHECK(xwindow_);
   DCHECK(xdisplay_);
   XEvent xevent = *native_event;
   xevent.xany.display = xdisplay_;
   xevent.xany.window = xwindow_;
-  ::XPutBackEvent(xdisplay_, &xevent);
+
+  switch (xevent.type) {
+    case MotionNotify:
+    case KeyPress:
+    case KeyRelease:
+    case ButtonPress:
+    case ButtonRelease: {

[Daniel Erat, 2011/11/22 00:25:32]

i know that we don't do anything with them (now), but for completeness, you
should include EnterNotify and LeaveNotify (and the corresponding masks above)

[oshima, 2011/11/22 01:36:10]

Because X's Enter/Leave notify doesn't trigger aura events, they do not seem
to be necessary. Can you explain?

[Daniel Erat, 2011/11/22 01:46:14]

They could get added to aura later, and things would break if they weren't also
added here.  Are there any downsides to handling them here?

[oshima, 2011/11/22 03:02:09]

I just couldn't imagine how this will be needed. Only downside I can imagine
is that it would make it looks like Notify/LeaveNotify does something, which is
not (that is, we're sending event that are not handled in Dispatch.) That's
being said, it's less likely to cause real confusion, so done.

+      xevent.xmotion.root = DefaultRootWindow(xdisplay_);

[Daniel Erat, 2011/11/22 00:25:32]

maybe add a comment mentioning that you're choosing xmotion arbitrarily from the
union since the fields that you're assigning to are in the same place in all of
these structs

[oshima, 2011/11/22 01:36:10]

Done.

+      xevent.xmotion.time = CurrentTime;
+
+      gfx::Point point(xevent.xmotion.x, xevent.xmotion.y);
+      ConvertPointToNativeScreen(&point);
+      xevent.xmotion.x_root = point.x();
+      xevent.xmotion.y_root = point.y();
+    }
+    default:
+      break;
+  }
+  ::XSendEvent(xdisplay_, xwindow_, False, kInputEventMask, &xevent);

[Daniel Erat, 2011/11/22 00:25:32]

nit: "::" seems unnecessary here; this function name is unlikely to conflict
with anything in chrome and we don't use it for most other Xlib function calls

[oshima, 2011/11/22 01:36:10]

Done.

 }
 
 bool DesktopHostLinux::IsWindowManagerPresent() {
   // Per ICCCM 2.8, "Manager Selections", window managers should take ownership
   // of WM_Sn selections (where n is a screen number).
   ::Atom wm_s0_atom = XInternAtom(xdisplay_, "WM_S0", False);
   return XGetSelectionOwner(xdisplay_, wm_s0_atom) != None;
 }
 
 }  // namespace
 
 // static
 DesktopHost* DesktopHost::Create(const gfx::Rect& bounds) {
   return new DesktopHostLinux(bounds);
 }
 
 // static
 gfx::Size DesktopHost::GetNativeDisplaySize() {
   ::Display* xdisplay = base::MessagePumpX::GetDefaultXDisplay();
   return gfx::Size(DisplayWidth(xdisplay, 0), DisplayHeight(xdisplay, 0));
 }
 
 }  // namespace aura