linux_aura: Fix cursors and popup menu location

ui/views/widget/desktop_root_window_host_linux.cc

 // Copyright (c) 2012 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/views/widget/desktop_root_window_host_linux.h"
 
 #include <X11/extensions/XInput2.h>
 #include <X11/Xatom.h>
 #include <X11/Xutil.h>
 
@@ skipping 47 matching lines @@
 DesktopRootWindowHostLinux::DesktopRootWindowHostLinux(
     internal::NativeWidgetDelegate* native_widget_delegate,
     const gfx::Rect& initial_bounds)
     : xdisplay_(base::MessagePumpAuraX11::GetDefaultXDisplay()),
       xwindow_(0),
       x_root_window_(DefaultRootWindow(xdisplay_)),
       atom_cache_(xdisplay_, kAtomsToCache),
       window_mapped_(false),
       focus_when_shown_(false),
       has_capture_(false),
+      cursor_loader_(),
+      current_cursor_(ui::kCursorNull),
+      cursor_shown_(true),
       native_widget_delegate_(native_widget_delegate) {
 }
 
 DesktopRootWindowHostLinux::~DesktopRootWindowHostLinux() {
   base::MessagePumpAuraX11::Current()->RemoveDispatcherForWindow(xwindow_);
   XDestroyWindow(xdisplay_, xwindow_);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopRootWindowHostLinux, private:
@@ skipping 26 matching lines @@
 
   long event_mask = ButtonPressMask | ButtonReleaseMask | FocusChangeMask |
                     KeyPressMask | KeyReleaseMask |
                     EnterWindowMask | LeaveWindowMask |
                     ExposureMask | VisibilityChangeMask |
                     StructureNotifyMask | PropertyChangeMask |
                     PointerMotionMask;
   XSelectInput(xdisplay_, xwindow_, event_mask);
   XFlush(xdisplay_);
 
-  // TODO(erg): Something about an invisible cursor here? Don't think I need
-  // it, but this is where it was.
+  invisible_cursor_ = ui::CreateInvisibleCursor();
 
   // TODO(erg): We currently only request window deletion events. We also
   // should listen for activation events and anything else that GTK+ listens
   // for, and do something useful.
   ::Atom protocols[2];
   protocols[0] = atom_cache_.GetAtom("WM_DELETE_WINDOW");
   protocols[1] = atom_cache_.GetAtom("_NET_WM_PING");
   XSetWMProtocols(xdisplay_, xwindow_, protocols, 2);
 
   // We need a WM_CLIENT_MACHINE and WM_LOCALE_NAME value so we integrate with
@@ skipping 42 matching lines @@
 
   aura::DesktopActivationClient* activation_client =
       X11DesktopHandler::get()->get_activation_client();
   aura::client::SetActivationClient(
       root_window_.get(), activation_client);
 
   dispatcher_client_.reset(new aura::DesktopDispatcherClient);
   aura::client::SetDispatcherClient(root_window_.get(),
                                     dispatcher_client_.get());
 
+  // The cursor client is a curious thing; it proxies some, but not all, calls
+  // to our SetCursor() method. We require all calls to go through a route that
+  // uses a CursorLoader, which includes all the ones in views:: internal.
+  //
+  // TODO(erg): This is a code smell. I suspect that I'm working around the
+  // CursorClient's interface being plain wrong.
+  aura::client::SetCursorClient(root_window_.get(), this);
+
   // No event filter for aura::Env. Create CompoundEvnetFilter per RootWindow.
   root_window_event_filter_ = new aura::shared::CompoundEventFilter;
   // Pass ownership of the filter to the root_window.
   root_window_->SetEventFilter(root_window_event_filter_);
 
   input_method_filter_.reset(new aura::shared::InputMethodEventFilter());
   input_method_filter_->SetInputMethodPropertyInRootWindow(root_window_.get());
   root_window_event_filter_->AddFilter(input_method_filter_.get());
 
   // TODO(erg): Unify this code once the other consumer goes away.
@@ skipping 114 matching lines @@
   // TODO(erg): This needs a better implementation. For now, we're just pass
   // back the normal state until we keep track of this.
   *show_state = ui::SHOW_STATE_NORMAL;
 }
 
 gfx::Rect DesktopRootWindowHostLinux::GetWindowBoundsInScreen() const {
   return bounds_;
 }
 
 gfx::Rect DesktopRootWindowHostLinux::GetClientAreaBoundsInScreen() const {
-  NOTIMPLEMENTED();
-  // TODO(erg): This is wrong, but would require looking at the actual views
-  // hierarchy to do correctly.
+  // TODO(erg): The NativeWidgetAura version returns |bounds_|, claiming its
+  // needed for View::ConvertPointToScreen() to work
+  // correctly. DesktopRootWindowHostWin::GetClientAreaBoundsInScreen() just
+  // asks windows what it thinks the client rect is.
+  //
+  // Attempts to calculate the rect by asking the NonClientFrameView what it
+  // thought its GetBoundsForClientView() were broke combobox drop down
+  // placement.
   return bounds_;
 }
 
 gfx::Rect DesktopRootWindowHostLinux::GetRestoredBounds() const {
   // TODO(erg):
   NOTIMPLEMENTED();
   return gfx::Rect();
 }
 
 gfx::Rect DesktopRootWindowHostLinux::GetWorkAreaBoundsInScreen() const {
-  // TODO(erg):
+  std::vector<int> value;
+  if (ui::GetIntArrayProperty(x_root_window_, "_NET_WORKAREA", &value) &&
+      value.size() >= 4) {
+    return gfx::Rect(value[0], value[1], value[2], value[3]);
+  }
+
+  // TODO(erg): As a fallback, we should return the bounds for the current
+  // monitor. However, that's pretty difficult and requires futzing with XRR.
   NOTIMPLEMENTED();
   return gfx::Rect();
 }
 
 void DesktopRootWindowHostLinux::SetShape(gfx::NativeRegion native_region) {
   // TODO(erg):
   NOTIMPLEMENTED();
 }
 
 void DesktopRootWindowHostLinux::Activate() {
@@ skipping 30 matching lines @@
 
 bool DesktopRootWindowHostLinux::IsMaximized() const {
   return (HasWMSpecProperty("_NET_WM_STATE_MAXIMIZED_VERT") ||
           HasWMSpecProperty("_NET_WM_STATE_MAXIMIZED_HORZ"));
 }
 
 bool DesktopRootWindowHostLinux::IsMinimized() const {
   return HasWMSpecProperty("_NET_WM_STATE_HIDDEN");
 }
 
+void DesktopRootWindowHostLinux::SetCursorInternal(gfx::NativeCursor cursor) {
+  XDefineCursor(xdisplay_, xwindow_, cursor.platform());
+}
+
 bool DesktopRootWindowHostLinux::HasCapture() const {
   return has_capture_;
 }
 
 void DesktopRootWindowHostLinux::SetAlwaysOnTop(bool always_on_top) {
   // TODO(erg):
   NOTIMPLEMENTED();
 }
 
 InputMethod* DesktopRootWindowHostLinux::CreateInputMethod() {
@@ skipping 172 matching lines @@
   // when asked fixes the case where buttons pressed don't receive button
   // release events.
   has_capture_ = true;
 }
 
 void DesktopRootWindowHostLinux::ReleaseCapture() {
   has_capture_ = false;
 }
 
 void DesktopRootWindowHostLinux::SetCursor(gfx::NativeCursor cursor) {
-  NOTIMPLEMENTED();
+  cursor_loader_.SetPlatformCursor(&cursor);
+
+  if (cursor == current_cursor_)
+    return;
+  current_cursor_ = cursor;
+
+  if (cursor_shown_)
+    SetCursorInternal(cursor);
 }
 
 void DesktopRootWindowHostLinux::ShowCursor(bool show) {
-  NOTIMPLEMENTED();
+  if (show == cursor_shown_)
+    return;
+  cursor_shown_ = show;
+  SetCursorInternal(show ? current_cursor_ : invisible_cursor_);
 }
 
 bool DesktopRootWindowHostLinux::QueryMouseLocation(
     gfx::Point* location_return) {
   ::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,
@@ skipping 73 matching lines @@
 }
 
 void DesktopRootWindowHostLinux::OnDeviceScaleFactorChanged(
     float device_scale_factor) {
 }
 
 void DesktopRootWindowHostLinux::PrepareForShutdown() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// DesktopRootWindowHostLinux, aura::CursorClient implementation:
+
+bool DesktopRootWindowHostLinux::IsCursorVisible() const {
+  return cursor_shown_;
+}
+
+void DesktopRootWindowHostLinux::SetDeviceScaleFactor(
+    float device_scale_factor) {
+  cursor_loader_.UnloadAll();
+  cursor_loader_.set_device_scale_factor(device_scale_factor);
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // DesktopRootWindowHostLinux, MessageLoop::Dispatcher implementation:
 
 bool DesktopRootWindowHostLinux::Dispatch(const base::NativeEvent& event) {
   XEvent* xev = event;
 
   // May want to factor CheckXEventForConsistency(xev); into a common location
   // since it is called here.
   switch (xev->type) {
     case Expose:
       // TODO(erg): Can we only redraw the affected areas?
@@ skipping 216 matching lines @@
 // DesktopRootWindowHost, public:
 
 // static
 DesktopRootWindowHost* DesktopRootWindowHost::Create(
     internal::NativeWidgetDelegate* native_widget_delegate,
     const gfx::Rect& initial_bounds) {
   return new DesktopRootWindowHostLinux(native_widget_delegate, initial_bounds);
 }
 
 }  // namespace views