ui/platform_window/x11/x11_window.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/platform_window/x11/x11_window.h"
   6
   7 #include <X11/extensions/XInput2.h>
   8 #include <X11/Xatom.h>
   9 #include <X11/Xlib.h>
  10 #include <X11/Xutil.h>
  11
  12 #include "ui/events/event.h"
  13 #include "ui/events/event_utils.h"
  14 #include "ui/events/platform/platform_event_dispatcher.h"
  15 #include "ui/events/platform/platform_event_source.h"
  16 #include "ui/events/platform/x11/x11_event_source.h"
  17 #include "ui/events/x/touch_factory_x11.h"
  18 #include "ui/gfx/geometry/rect.h"
  19 #include "ui/gfx/x/x11_atom_cache.h"
  20 #include "ui/gfx/x/x11_types.h"
  21 #include "ui/platform_window/platform_window_delegate.h"
  22
  23 namespace ui {
  24
  25 namespace {
  26
  27 const char* kAtomsToCache[] = {
  28   "WM_DELETE_WINDOW",
  29   "_NET_WM_PING",
  30   "_NET_WM_PID",
  31   NULL
  32 };
  33
  34 XID FindXEventTarget(XEvent* xevent) {
  35   XID target = xevent->xany.window;
  36   if (xevent->type == GenericEvent)
  37     target = static_cast<XIDeviceEvent*>(xevent->xcookie.data)->event;
  38   return target;
  39 }
  40
  41 }  // namespace
  42
  43 X11Window::X11Window(PlatformWindowDelegate* delegate)
  44     : delegate_(delegate),
  45       xdisplay_(gfx::GetXDisplay()),
  46       xwindow_(None),
  47       xroot_window_(DefaultRootWindow(xdisplay_)),
  48       atom_cache_(xdisplay_, kAtomsToCache),
  49       window_mapped_(false) {
  50   CHECK(delegate_);
  51   TouchFactory::SetTouchDeviceListFromCommandLine();
  52 }
  53
  54 X11Window::~X11Window() {
  55   Destroy();
  56 }
  57
  58 void X11Window::Destroy() {
  59   if (xwindow_ == None)
  60     return;
  61
  62   // Stop processing events.
  63   PlatformEventSource::GetInstance()->RemovePlatformEventDispatcher(this);
  64   XDestroyWindow(xdisplay_, xwindow_);
  65   xwindow_ = None;
  66 }
  67
  68 void X11Window::ProcessXInput2Event(XEvent* xev) {
  69   if (!TouchFactory::GetInstance()->ShouldProcessXI2Event(xev))
  70     return;
  71   EventType event_type = EventTypeFromNative(xev);
  72   switch (event_type) {
  73     case ET_KEY_PRESSED:
  74     case ET_KEY_RELEASED: {
  75       KeyEvent key_event(xev);
  76       delegate_->DispatchEvent(&key_event);
  77       break;
  78     }
  79     case ET_MOUSE_PRESSED:
  80     case ET_MOUSE_MOVED:
  81     case ET_MOUSE_DRAGGED:
  82     case ET_MOUSE_RELEASED: {
  83       MouseEvent mouse_event(xev);
  84       delegate_->DispatchEvent(&mouse_event);
  85       break;
  86     }
  87     case ET_MOUSEWHEEL: {
  88       MouseWheelEvent wheel_event(xev);
  89       delegate_->DispatchEvent(&wheel_event);
  90       break;
  91     }
  92     case ET_SCROLL_FLING_START:
  93     case ET_SCROLL_FLING_CANCEL:
  94     case ET_SCROLL: {
  95       ScrollEvent scroll_event(xev);
  96       delegate_->DispatchEvent(&scroll_event);
  97       break;
  98     }
  99     case ET_TOUCH_MOVED:
 100     case ET_TOUCH_PRESSED:
 101     case ET_TOUCH_CANCELLED:
 102     case ET_TOUCH_RELEASED: {
 103       TouchEvent touch_event(xev);
 104       delegate_->DispatchEvent(&touch_event);
 105       break;
 106     }
 107     default:
 108       break;
 109   }
 110 }
 111
 112 void X11Window::Show() {
 113   if (window_mapped_)
 114     return;
 115
 116   CHECK(PlatformEventSource::GetInstance());
 117   PlatformEventSource::GetInstance()->AddPlatformEventDispatcher(this);
 118
 119   XSetWindowAttributes swa;
 120   memset(&swa, 0, sizeof(swa));
 121   swa.background_pixmap = None;
 122   swa.override_redirect = False;
 123   xwindow_ = XCreateWindow(xdisplay_,
 124                            xroot_window_,
 125                            requested_bounds_.x(),
 126                            requested_bounds_.y(),
 127                            requested_bounds_.width(),
 128                            requested_bounds_.height(),
 129                            0,               // border width
 130                            CopyFromParent,  // depth
 131                            InputOutput,
 132                            CopyFromParent,  // visual
 133                            CWBackPixmap | CWOverrideRedirect,
 134                            &swa);
 135
 136   long event_mask = ButtonPressMask | ButtonReleaseMask | FocusChangeMask |
 137                     KeyPressMask | KeyReleaseMask | EnterWindowMask |
 138                     LeaveWindowMask | ExposureMask | VisibilityChangeMask |
 139                     StructureNotifyMask | PropertyChangeMask |
 140                     PointerMotionMask;
 141   XSelectInput(xdisplay_, xwindow_, event_mask);
 142
 143   unsigned char mask[XIMaskLen(XI_LASTEVENT)];
 144   memset(mask, 0, sizeof(mask));
 145
 146   XISetMask(mask, XI_TouchBegin);
 147   XISetMask(mask, XI_TouchUpdate);
 148   XISetMask(mask, XI_TouchEnd);
 149   XISetMask(mask, XI_ButtonPress);
 150   XISetMask(mask, XI_ButtonRelease);
 151   XISetMask(mask, XI_Motion);
 152   XISetMask(mask, XI_KeyPress);
 153   XISetMask(mask, XI_KeyRelease);
 154
 155   XIEventMask evmask;
 156   evmask.deviceid = XIAllDevices;
 157   evmask.mask_len = sizeof(mask);
 158   evmask.mask = mask;
 159   XISelectEvents(xdisplay_, xwindow_, &evmask, 1);
 160   XFlush(xdisplay_);
 161
 162   ::Atom protocols[2];
 163   protocols[0] = atom_cache_.GetAtom("WM_DELETE_WINDOW");
 164   protocols[1] = atom_cache_.GetAtom("_NET_WM_PING");
 165   XSetWMProtocols(xdisplay_, xwindow_, protocols, 2);
 166
 167   // We need a WM_CLIENT_MACHINE and WM_LOCALE_NAME value so we integrate with
 168   // the desktop environment.
 169   XSetWMProperties(
 170       xdisplay_, xwindow_, NULL, NULL, NULL, 0, NULL, NULL, NULL);
 171
 172   // Likewise, the X server needs to know this window's pid so it knows which
 173   // program to kill if the window hangs.
 174   // XChangeProperty() expects "pid" to be long.
 175   COMPILE_ASSERT(sizeof(long) >= sizeof(pid_t), pid_t_bigger_than_long);
 176   long pid = getpid();
 177   XChangeProperty(xdisplay_,
 178                   xwindow_,
 179                   atom_cache_.GetAtom("_NET_WM_PID"),
 180                   XA_CARDINAL,
 181                   32,
 182                   PropModeReplace,
 183                   reinterpret_cast<unsigned char*>(&pid),
 184                   1);
 185   // Before we map the window, set size hints. Otherwise, some window managers
 186   // will ignore toplevel XMoveWindow commands.
 187   XSizeHints size_hints;
 188   size_hints.flags = PPosition | PWinGravity;
 189   size_hints.x = requested_bounds_.x();
 190   size_hints.y = requested_bounds_.y();
 191   // Set StaticGravity so that the window position is not affected by the
 192   // frame width when running with window manager.
 193   size_hints.win_gravity = StaticGravity;
 194   XSetWMNormalHints(xdisplay_, xwindow_, &size_hints);
 195
 196   delegate_->OnAcceleratedWidgetAvailable(xwindow_);
 197
 198   XMapWindow(xdisplay_, xwindow_);
 199
 200   // We now block until our window is mapped. Some X11 APIs will crash and
 201   // burn if passed |xwindow_| before the window is mapped, and XMapWindow is
 202   // asynchronous.
 203   if (X11EventSource::GetInstance())
 204     X11EventSource::GetInstance()->BlockUntilWindowMapped(xwindow_);
 205   window_mapped_ = true;
 206 }
 207
 208 void X11Window::Hide() {
 209   if (!window_mapped_)
 210     return;
 211   XWithdrawWindow(xdisplay_, xwindow_, 0);
 212   window_mapped_ = false;
 213 }
 214
 215 void X11Window::Close() {
 216   Destroy();
 217 }
 218
 219 void X11Window::SetBounds(const gfx::Rect& bounds) {
 220   requested_bounds_ = bounds;
 221   if (!window_mapped_)
 222     return;
 223   XWindowChanges changes = {0};
 224   unsigned value_mask = CWX | CWY | CWWidth | CWHeight;
 225   changes.x = bounds.x();
 226   changes.y = bounds.y();
 227   changes.width = bounds.width();
 228   changes.height = bounds.height();
 229   XConfigureWindow(xdisplay_, xwindow_, value_mask, &changes);
 230 }
 231
 232 gfx::Rect X11Window::GetBounds() {
 233   return confirmed_bounds_;
 234 }
 235
 236 void X11Window::SetCapture() {}
 237
 238 void X11Window::ReleaseCapture() {}
 239
 240 void X11Window::ToggleFullscreen() {}
 241
 242 void X11Window::Maximize() {}
 243
 244 void X11Window::Minimize() {}
 245
 246 void X11Window::Restore() {}
 247
 248 void X11Window::SetCursor(PlatformCursor cursor) {}
 249
 250 void X11Window::MoveCursorTo(const gfx::Point& location) {}
 251
 252 bool X11Window::CanDispatchEvent(const PlatformEvent& event) {
 253   return FindXEventTarget(event) == xwindow_;
 254 }
 255
 256 uint32_t X11Window::DispatchEvent(const PlatformEvent& event) {
 257   XEvent* xev = event;
 258   switch (xev->type) {
 259     case EnterNotify: {
 260       // EnterNotify creates ET_MOUSE_MOVED. Mark as synthesized as this is
 261       // not real mouse move event.
 262       MouseEvent mouse_event(xev);
 263       CHECK_EQ(ET_MOUSE_MOVED, mouse_event.type());
 264       mouse_event.set_flags(mouse_event.flags() | EF_IS_SYNTHESIZED);
 265       delegate_->DispatchEvent(&mouse_event);
 266       break;
 267     }
 268     case LeaveNotify: {
 269       MouseEvent mouse_event(xev);
 270       delegate_->DispatchEvent(&mouse_event);
 271       break;
 272     }
 273
 274     case Expose: {
 275       gfx::Rect damage_rect(xev->xexpose.x,
 276                             xev->xexpose.y,
 277                             xev->xexpose.width,
 278                             xev->xexpose.height);
 279       delegate_->OnDamageRect(damage_rect);
 280       break;
 281     }
 282
 283     case KeyPress:
 284     case KeyRelease: {
 285       KeyEvent key_event(xev);
 286       delegate_->DispatchEvent(&key_event);
 287       break;
 288     }
 289
 290     case ButtonPress:
 291     case ButtonRelease: {
 292       switch (EventTypeFromNative(xev)) {
 293         case ET_MOUSEWHEEL: {
 294           MouseWheelEvent mouseev(xev);
 295           delegate_->DispatchEvent(&mouseev);
 296           break;
 297         }
 298         case ET_MOUSE_PRESSED:
 299         case ET_MOUSE_RELEASED: {
 300           MouseEvent mouseev(xev);
 301           delegate_->DispatchEvent(&mouseev);
 302           break;
 303         }
 304         case ET_UNKNOWN:
 305           // No event is created for X11-release events for mouse-wheel
 306           // buttons.
 307           break;
 308         default:
 309           NOTREACHED();
 310       }
 311       break;
 312     }
 313
 314     case FocusOut:
 315       if (xev->xfocus.mode != NotifyGrab)
 316         delegate_->OnLostCapture();
 317       break;
 318
 319     case ConfigureNotify: {
 320       DCHECK_EQ(xwindow_, xev->xconfigure.event);
 321       DCHECK_EQ(xwindow_, xev->xconfigure.window);
 322       gfx::Rect bounds(xev->xconfigure.x,
 323                        xev->xconfigure.y,
 324                        xev->xconfigure.width,
 325                        xev->xconfigure.height);
 326       if (confirmed_bounds_ != bounds) {
 327         confirmed_bounds_ = bounds;
 328         delegate_->OnBoundsChanged(confirmed_bounds_);
 329       }
 330       break;
 331     }
 332
 333     case ClientMessage: {
 334       Atom message = static_cast<Atom>(xev->xclient.data.l[0]);
 335       if (message == atom_cache_.GetAtom("WM_DELETE_WINDOW")) {
 336         delegate_->OnCloseRequest();
 337       } else if (message == atom_cache_.GetAtom("_NET_WM_PING")) {
 338         XEvent reply_event = *xev;
 339         reply_event.xclient.window = xroot_window_;
 340
 341         XSendEvent(xdisplay_,
 342                    reply_event.xclient.window,
 343                    False,
 344                    SubstructureRedirectMask | SubstructureNotifyMask,
 345                    &reply_event);
 346         XFlush(xdisplay_);
 347       }
 348       break;
 349     }
 350
 351     case GenericEvent: {
 352       ProcessXInput2Event(xev);
 353       break;
 354     }
 355   }
 356   return POST_DISPATCH_STOP_PROPAGATION;
 357 }
 358
 359 }  // namespace ui