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. This struct doesn't seem 64-bit safe though, but it's what GDK
+// does.
+typedef struct {
+  unsigned long flags;
+  unsigned long functions;
+  unsigned long decorations;
+  long input_mode;
+  unsigned long status;
+} 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::SetUseHostWindowBorders(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));
+}
+
+bool RootWindowHostLinux::DispatchHostWindowDragMovement(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. We need to dump it
+  // 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.
+  XUngrabPointer(xdisplay_, CurrentTime);
+
+  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