Aura/ash split: Don't use X11 window borders.

ui/aura/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/aura/root_window_host_linux.h"
 
 #include <X11/Xatom.h>
 #include <X11/cursorfont.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/extensions/Xfixes.h>
 #include <X11/extensions/Xrandr.h>
 #include <algorithm>
 
 #include "base/message_pump_x.h"
 #include "base/stl_util.h"
 #include "base/stringprintf.h"
 #include "ui/aura/client/user_gesture_client.h"
 #include "ui/aura/dispatcher_linux.h"
 #include "ui/aura/env.h"
 #include "ui/aura/event.h"
 #include "ui/aura/root_window.h"
 #include "ui/base/cursor/cursor.h"
+#include "ui/base/hit_test.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/base/touch/touch_factory.h"
 #include "ui/base/view_prop.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/compositor/layer.h"
 
 using std::max;
 using std::min;
 
 namespace aura {
 
 namespace {
 
 // Standard Linux mouse buttons for going back and forward.
 const int kBackMouseButton = 8;
 const int kForwardMouseButton = 9;
 
 const char kRootWindowHostLinuxKey[] = "__AURA_ROOT_WINDOW_HOST_LINUX__";
 
+// These constants are defined in the Extended Window Manager Hints
+// standard...and aren't in any header that I can find.
+const int k_NET_WM_MOVERESIZE_SIZE_TOPLEFT =     0;
+const int k_NET_WM_MOVERESIZE_SIZE_TOP =         1;
+const int k_NET_WM_MOVERESIZE_SIZE_TOPRIGHT =    2;
+const int k_NET_WM_MOVERESIZE_SIZE_RIGHT =       3;
+const int k_NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT = 4;
+const int k_NET_WM_MOVERESIZE_SIZE_BOTTOM =      5;
+const int k_NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT =  6;
+const int k_NET_WM_MOVERESIZE_SIZE_LEFT =        7;
+const int k_NET_WM_MOVERESIZE_MOVE =             8;
+
+// This data structure represents additional hints that we send to the window
+// manager and has a direct lineage back to Motif, which defined this de facto
+// standard.
+typedef struct {
+    unsigned long flags;

[Daniel Erat, 2012/05/09 20:58:27]

nit: indent 2 spaces instead of 4

+    unsigned long functions;
+    unsigned long decorations;
+    long input_mode;
+    unsigned long status;

[Daniel Erat, 2012/05/09 20:58:27]

Holy 64-bit-unsafety!  Still, it looks like this is what metacity does, so i
guess it's safest to match it... Add a comment, though?

+} MotifWmHints;
+
+// The bitflag in |flags| in MotifWmHints that signals that the reader should
+// pay attention to the value in |decorations|.
+const unsigned long kHintsDecorations = (1L << 1);
+
 // The events reported for slave devices can have incorrect information for some
 // fields. This utility function is used to check for such inconsistencies.
 void CheckXEventForConsistency(XEvent* xevent) {
 #if defined(USE_XI2_MT)
   static bool expect_master_event = false;
   static XIDeviceEvent slave_event;
   static gfx::Point slave_location;
   static int slave_button;
 
   // Note: If an event comes from a slave pointer device, then it will be
@@ skipping 226 matching lines @@
       return true;
     default:
       return false;
   }
 }
 
 // A list of atoms that we'll intern on host creation to save roundtrips to the
 // X11 server. Must be kept in sync with RootWindowHostLinux::AtomList
 const char* kAtomList[] = {
   "WM_DELETE_WINDOW",
+  "_NET_WM_MOVERESIZE",
   "_NET_WM_PING",
   "_NET_WM_PID",
-  "WM_S0"
+  "WM_S0",
+  "_MOTIF_WM_HINTS"
 };
 
 }  // namespace
 
 RootWindowHostLinux::RootWindowHostLinux(const gfx::Rect& bounds)
     : root_window_(NULL),
       xdisplay_(base::MessagePumpX::GetDefaultXDisplay()),
       xwindow_(0),
       x_root_window_(DefaultRootWindow(xdisplay_)),
       current_cursor_(ui::kCursorNull),
@@ skipping 198 matching lines @@
                     ui::IsTouchpadEvent(xev) && ui::IsNaturalScrollEnabled();
                 gesture_client->OnUserGesture(
                     (button == kBackMouseButton && !reverse_direction) ||
                     (button == kForwardMouseButton && reverse_direction) ?
                     client::UserGestureClient::GESTURE_BACK :
                     client::UserGestureClient::GESTURE_FORWARD);
               }
               break;
             }
           }
+
           MouseEvent mouseev(xev);
           root_window_->DispatchMouseEvent(&mouseev);
           break;
         }
         case ui::ET_SCROLL_FLING_START:
         case ui::ET_SCROLL_FLING_CANCEL:
         case ui::ET_SCROLL: {
           ScrollEvent scrollev(xev);
           root_window_->DispatchScrollEvent(&scrollev);
           break;
@@ skipping 260 matching lines @@
       root_window_->ConvertPointToNativeScreen(&point);
       xevent.xmotion.x_root = point.x();
       xevent.xmotion.y_root = point.y();
     }
     default:
       break;
   }
   XSendEvent(xdisplay_, xwindow_, False, 0, &xevent);
 }
 
+void RootWindowHostLinux::SetUseOSWindowBorders(bool use_os_border) {
+  MotifWmHints motif_hints;
+  memset(&motif_hints, 0, sizeof(motif_hints));
+  motif_hints.flags = kHintsDecorations;
+  motif_hints.decorations = use_os_border ? 1 : 0;
+  XChangeProperty(xdisplay_,
+                  xwindow_,
+                  cached_atoms_[ATOM__MOTIF_WM_HINTS],
+                  cached_atoms_[ATOM__MOTIF_WM_HINTS],
+                  32,
+                  PropModeReplace,
+                  reinterpret_cast<unsigned char*>(&motif_hints),
+                  sizeof(MotifWmHints)/sizeof(long));

[Daniel Erat, 2012/05/09 20:58:27]

does this break on 64-bit?  should you be dividing by 4 instead?  the man page
says:

nelements: Specifies the number of elements of the specified data format.

hate Xlib so much.

[Elliot Glaysher, 2012/05/09 22:23:09]

This is what GDK does and I'm testing this in a 64-bit build.

[Daniel Erat, 2012/05/09 22:38:16]

Okay.

+}
+
+bool RootWindowHostLinux::DispatchWindowDragMovement(int hittest,
+                                                     MouseEvent* event) {
+  int direction = -1;
+  switch (hittest) {
+    case HTBOTTOM:
+      direction = k_NET_WM_MOVERESIZE_SIZE_BOTTOM;
+      break;
+    case HTBOTTOMLEFT:
+      direction = k_NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT;
+      break;
+    case HTBOTTOMRIGHT:
+      direction = k_NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT;
+      break;
+    case HTCAPTION:
+      direction = k_NET_WM_MOVERESIZE_MOVE;
+      break;
+    case HTLEFT:
+      direction = k_NET_WM_MOVERESIZE_SIZE_LEFT;
+      break;
+    case HTRIGHT:
+      direction = k_NET_WM_MOVERESIZE_SIZE_RIGHT;
+      break;
+    case HTTOP:
+      direction = k_NET_WM_MOVERESIZE_SIZE_TOP;
+      break;
+    case HTTOPLEFT:
+      direction = k_NET_WM_MOVERESIZE_SIZE_TOPLEFT;
+      break;
+    case HTTOPRIGHT:
+      direction = k_NET_WM_MOVERESIZE_SIZE_TOPRIGHT;
+      break;
+    default:
+      return false;
+  }
+
+  gfx::Point point = event->root_location();
+  SendWMMoveResize(direction, point.x(), point.y());
+  return true;
+}
+
 bool RootWindowHostLinux::IsWindowManagerPresent() {
   // Per ICCCM 2.8, "Manager Selections", window managers should take ownership
   // of WM_Sn selections (where n is a screen number).
   return XGetSelectionOwner(xdisplay_, cached_atoms_[ATOM_WM_S0]) != None;
 }
 
 void RootWindowHostLinux::SetCursorInternal(gfx::NativeCursor cursor) {
   ::Cursor xcursor =
       cursor == ui::kCursorNone ?
       invisible_cursor_ :
       cursor == ui::kCursorCustom ?
       cursor.platform() :
       ui::GetXCursor(CursorShapeFromNative(cursor));
   XDefineCursor(xdisplay_, xwindow_, xcursor);
 }
 
+void RootWindowHostLinux::SendWMMoveResize(int direction,
+                                           int x_root,
+                                           int y_root) {
+  // We most likely have an implicit grab right here. Release it.
+  XUngrabPointer(xdisplay_, CurrentTime);

[Daniel Erat, 2012/05/09 20:58:27]

this seems strange to me.  won't it get released automatically when the user
releases the mouse button?

[Elliot Glaysher, 2012/05/09 22:23:09]

Yeap, and that's the point. The application needs to dump it's pointer grab
because what we're about to do is tell the window manager that it's now
responsible for moving the window around; it immediately grabs when it receives
the event below.

If we don't release our grab before we send this message, we're still holding
the grab and the window manager doesn't grab for the drag.

Hate X11.

[Daniel Erat, 2012/05/09 22:38:16]

Thanks, had forgotten the super-flaky, racy "grab pass" that EWMH uses for this.
 Mind adding a comment?

+
+  XEvent event;
+  memset(&event, 0, sizeof(event));
+  event.xclient.type = ClientMessage;
+  event.xclient.display = xdisplay_;
+  event.xclient.window = xwindow_;
+  event.xclient.message_type = cached_atoms_[ATOM__NET_WM_MOVERESIZE];
+  event.xclient.format = 32;
+  event.xclient.data.l[0] = x_root;
+  event.xclient.data.l[1] = y_root;
+  event.xclient.data.l[2] = direction;
+  event.xclient.data.l[3] = 0;
+  event.xclient.data.l[4] = 0;
+
+  XSendEvent(xdisplay_, x_root_window_, False,
+             SubstructureRedirectMask | SubstructureNotifyMask,
+             &event);
+}
+
 // static
 RootWindowHost* RootWindowHost::Create(const gfx::Rect& bounds) {
   return new RootWindowHostLinux(bounds);
 }
 
 // static
 RootWindowHost* RootWindowHost::GetForAcceleratedWidget(
     gfx::AcceleratedWidget accelerated_widget) {
   return reinterpret_cast<RootWindowHost*>(
       ui::ViewProp::GetValue(accelerated_widget, kRootWindowHostLinuxKey));
 }
 
 // static
 gfx::Size RootWindowHost::GetNativeScreenSize() {
   ::Display* xdisplay = base::MessagePumpX::GetDefaultXDisplay();
   return gfx::Size(DisplayWidth(xdisplay, 0), DisplayHeight(xdisplay, 0));
 }
 
 }  // namespace aura