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