| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 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/aura/window_tree_host_x11.h" | |
| 6 | |
| 7 #include <strings.h> | |
| 8 #include <X11/cursorfont.h> | |
| 9 #include <X11/extensions/XInput2.h> | |
| 10 #include <X11/extensions/Xrandr.h> | |
| 11 #include <X11/Xatom.h> | |
| 12 #include <X11/Xcursor/Xcursor.h> | |
| 13 #include <X11/Xlib.h> | |
| 14 | |
| 15 #include <algorithm> | |
| 16 #include <limits> | |
| 17 #include <string> | |
| 18 | |
| 19 #include "base/basictypes.h" | |
| 20 #include "base/command_line.h" | |
| 21 #include "base/debug/trace_event.h" | |
| 22 #include "base/stl_util.h" | |
| 23 #include "base/strings/string_number_conversions.h" | |
| 24 #include "base/strings/string_util.h" | |
| 25 #include "base/strings/stringprintf.h" | |
| 26 #include "base/sys_info.h" | |
| 27 #include "ui/aura/client/cursor_client.h" | |
| 28 #include "ui/aura/env.h" | |
| 29 #include "ui/aura/window.h" | |
| 30 #include "ui/aura/window_event_dispatcher.h" | |
| 31 #include "ui/base/cursor/cursor.h" | |
| 32 #include "ui/base/ui_base_switches.h" | |
| 33 #include "ui/base/view_prop.h" | |
| 34 #include "ui/base/x/x11_util.h" | |
| 35 #include "ui/compositor/compositor.h" | |
| 36 #include "ui/compositor/dip_util.h" | |
| 37 #include "ui/compositor/layer.h" | |
| 38 #include "ui/events/event.h" | |
| 39 #include "ui/events/event_switches.h" | |
| 40 #include "ui/events/event_utils.h" | |
| 41 #include "ui/events/keycodes/keyboard_codes.h" | |
| 42 #include "ui/events/platform/platform_event_observer.h" | |
| 43 #include "ui/events/platform/x11/x11_event_source.h" | |
| 44 #include "ui/events/x/device_data_manager_x11.h" | |
| 45 #include "ui/events/x/device_list_cache_x.h" | |
| 46 #include "ui/events/x/touch_factory_x11.h" | |
| 47 #include "ui/gfx/screen.h" | |
| 48 | |
| 49 using std::max; | |
| 50 using std::min; | |
| 51 | |
| 52 namespace aura { | |
| 53 | |
| 54 namespace { | |
| 55 | |
| 56 const char* kAtomsToCache[] = { | |
| 57 "WM_DELETE_WINDOW", | |
| 58 "_NET_WM_PING", | |
| 59 "_NET_WM_PID", | |
| 60 NULL | |
| 61 }; | |
| 62 | |
| 63 ::Window FindEventTarget(const base::NativeEvent& xev) { | |
| 64 ::Window target = xev->xany.window; | |
| 65 if (xev->type == GenericEvent) | |
| 66 target = static_cast<XIDeviceEvent*>(xev->xcookie.data)->event; | |
| 67 return target; | |
| 68 } | |
| 69 | |
| 70 void SelectXInput2EventsForRootWindow(XDisplay* display, ::Window root_window) { | |
| 71 CHECK(ui::IsXInput2Available()); | |
| 72 unsigned char mask[XIMaskLen(XI_LASTEVENT)] = {}; | |
| 73 memset(mask, 0, sizeof(mask)); | |
| 74 | |
| 75 XISetMask(mask, XI_HierarchyChanged); | |
| 76 | |
| 77 XIEventMask evmask; | |
| 78 evmask.deviceid = XIAllDevices; | |
| 79 evmask.mask_len = sizeof(mask); | |
| 80 evmask.mask = mask; | |
| 81 XISelectEvents(display, root_window, &evmask, 1); | |
| 82 | |
| 83 #if defined(OS_CHROMEOS) | |
| 84 if (base::SysInfo::IsRunningOnChromeOS()) { | |
| 85 // It is necessary to listen for touch events on the root window for proper | |
| 86 // touch event calibration on Chrome OS, but this is not currently necessary | |
| 87 // on the desktop. This seems to fail in some cases (e.g. when logging | |
| 88 // in incognito). So select for non-touch events first, and then select for | |
| 89 // touch-events (but keep the other events in the mask, i.e. do not memset | |
| 90 // |mask| back to 0). | |
| 91 // TODO(sad): Figure out why this happens. http://crbug.com/153976 | |
| 92 XISetMask(mask, XI_TouchBegin); | |
| 93 XISetMask(mask, XI_TouchUpdate); | |
| 94 XISetMask(mask, XI_TouchEnd); | |
| 95 XISelectEvents(display, root_window, &evmask, 1); | |
| 96 } | |
| 97 #endif | |
| 98 } | |
| 99 | |
| 100 bool default_override_redirect = false; | |
| 101 | |
| 102 } // namespace | |
| 103 | |
| 104 namespace internal { | |
| 105 | |
| 106 // TODO(miletus) : Move this into DeviceDataManager. | |
| 107 // Accomplishes 2 tasks concerning touch event calibration: | |
| 108 // 1. Being a message-pump observer, | |
| 109 // routes all the touch events to the X root window, | |
| 110 // where they can be calibrated later. | |
| 111 // 2. Has the Calibrate method that does the actual bezel calibration, | |
| 112 // when invoked from X root window's event dispatcher. | |
| 113 class TouchEventCalibrate : public ui::PlatformEventObserver { | |
| 114 public: | |
| 115 TouchEventCalibrate() : left_(0), right_(0), top_(0), bottom_(0) { | |
| 116 if (ui::PlatformEventSource::GetInstance()) | |
| 117 ui::PlatformEventSource::GetInstance()->AddPlatformEventObserver(this); | |
| 118 #if defined(USE_XI2_MT) | |
| 119 std::vector<std::string> parts; | |
| 120 if (Tokenize(CommandLine::ForCurrentProcess()->GetSwitchValueASCII( | |
| 121 switches::kTouchCalibration), | |
| 122 ",", | |
| 123 &parts) >= 4) { | |
| 124 if (!base::StringToInt(parts[0], &left_)) | |
| 125 DLOG(ERROR) << "Incorrect left border calibration value passed."; | |
| 126 if (!base::StringToInt(parts[1], &right_)) | |
| 127 DLOG(ERROR) << "Incorrect right border calibration value passed."; | |
| 128 if (!base::StringToInt(parts[2], &top_)) | |
| 129 DLOG(ERROR) << "Incorrect top border calibration value passed."; | |
| 130 if (!base::StringToInt(parts[3], &bottom_)) | |
| 131 DLOG(ERROR) << "Incorrect bottom border calibration value passed."; | |
| 132 } | |
| 133 #endif // defined(USE_XI2_MT) | |
| 134 } | |
| 135 | |
| 136 virtual ~TouchEventCalibrate() { | |
| 137 if (ui::PlatformEventSource::GetInstance()) | |
| 138 ui::PlatformEventSource::GetInstance()->RemovePlatformEventObserver(this); | |
| 139 } | |
| 140 | |
| 141 // Modify the location of the |event|, | |
| 142 // expanding it from |bounds| to (|bounds| + bezels). | |
| 143 // Required when touchscreen is bigger than screen (i.e. has bezels), | |
| 144 // because we receive events in touchscreen coordinates, | |
| 145 // which need to be expanded when converting to screen coordinates, | |
| 146 // so that location on bezels will be outside of screen area. | |
| 147 void Calibrate(ui::TouchEvent* event, const gfx::Rect& bounds) { | |
| 148 #if defined(USE_XI2_MT) | |
| 149 int x = event->x(); | |
| 150 int y = event->y(); | |
| 151 | |
| 152 if (!left_ && !right_ && !top_ && !bottom_) | |
| 153 return; | |
| 154 | |
| 155 const int resolution_x = bounds.width(); | |
| 156 const int resolution_y = bounds.height(); | |
| 157 // The "grace area" (10% in this case) is to make it easier for the user to | |
| 158 // navigate to the corner. | |
| 159 const double kGraceAreaFraction = 0.1; | |
| 160 if (left_ || right_) { | |
| 161 // Offset the x position to the real | |
| 162 x -= left_; | |
| 163 // Check if we are in the grace area of the left side. | |
| 164 // Note: We might not want to do this when the gesture is locked? | |
| 165 if (x < 0 && x > -left_ * kGraceAreaFraction) | |
| 166 x = 0; | |
| 167 // Check if we are in the grace area of the right side. | |
| 168 // Note: We might not want to do this when the gesture is locked? | |
| 169 if (x > resolution_x - left_ && | |
| 170 x < resolution_x - left_ + right_ * kGraceAreaFraction) | |
| 171 x = resolution_x - left_; | |
| 172 // Scale the screen area back to the full resolution of the screen. | |
| 173 x = (x * resolution_x) / (resolution_x - (right_ + left_)); | |
| 174 } | |
| 175 if (top_ || bottom_) { | |
| 176 // When there is a top bezel we add our border, | |
| 177 y -= top_; | |
| 178 | |
| 179 // Check if we are in the grace area of the top side. | |
| 180 // Note: We might not want to do this when the gesture is locked? | |
| 181 if (y < 0 && y > -top_ * kGraceAreaFraction) | |
| 182 y = 0; | |
| 183 | |
| 184 // Check if we are in the grace area of the bottom side. | |
| 185 // Note: We might not want to do this when the gesture is locked? | |
| 186 if (y > resolution_y - top_ && | |
| 187 y < resolution_y - top_ + bottom_ * kGraceAreaFraction) | |
| 188 y = resolution_y - top_; | |
| 189 // Scale the screen area back to the full resolution of the screen. | |
| 190 y = (y * resolution_y) / (resolution_y - (bottom_ + top_)); | |
| 191 } | |
| 192 | |
| 193 // Set the modified coordinate back to the event. | |
| 194 if (event->root_location() == event->location()) { | |
| 195 // Usually those will be equal, | |
| 196 // if not, I am not sure what the correct value should be. | |
| 197 event->set_root_location(gfx::Point(x, y)); | |
| 198 } | |
| 199 event->set_location(gfx::Point(x, y)); | |
| 200 #endif // defined(USE_XI2_MT) | |
| 201 } | |
| 202 | |
| 203 private: | |
| 204 // ui::PlatformEventObserver: | |
| 205 virtual void WillProcessEvent(const ui::PlatformEvent& event) override { | |
| 206 #if defined(USE_XI2_MT) | |
| 207 if (event->type == GenericEvent && | |
| 208 (event->xgeneric.evtype == XI_TouchBegin || | |
| 209 event->xgeneric.evtype == XI_TouchUpdate || | |
| 210 event->xgeneric.evtype == XI_TouchEnd)) { | |
| 211 XIDeviceEvent* xievent = static_cast<XIDeviceEvent*>(event->xcookie.data); | |
| 212 xievent->event = xievent->root; | |
| 213 xievent->event_x = xievent->root_x; | |
| 214 xievent->event_y = xievent->root_y; | |
| 215 } | |
| 216 #endif // defined(USE_XI2_MT) | |
| 217 } | |
| 218 | |
| 219 virtual void DidProcessEvent(const ui::PlatformEvent& event) override {} | |
| 220 | |
| 221 // The difference in screen's native resolution pixels between | |
| 222 // the border of the touchscreen and the border of the screen, | |
| 223 // aka bezel sizes. | |
| 224 int left_; | |
| 225 int right_; | |
| 226 int top_; | |
| 227 int bottom_; | |
| 228 | |
| 229 DISALLOW_COPY_AND_ASSIGN(TouchEventCalibrate); | |
| 230 }; | |
| 231 | |
| 232 } // namespace internal | |
| 233 | |
| 234 //////////////////////////////////////////////////////////////////////////////// | |
| 235 // WindowTreeHostX11 | |
| 236 | |
| 237 WindowTreeHostX11::WindowTreeHostX11(const gfx::Rect& bounds) | |
| 238 : xdisplay_(gfx::GetXDisplay()), | |
| 239 xwindow_(0), | |
| 240 x_root_window_(DefaultRootWindow(xdisplay_)), | |
| 241 current_cursor_(ui::kCursorNull), | |
| 242 window_mapped_(false), | |
| 243 bounds_(bounds), | |
| 244 touch_calibrate_(new internal::TouchEventCalibrate), | |
| 245 atom_cache_(xdisplay_, kAtomsToCache) { | |
| 246 XSetWindowAttributes swa; | |
| 247 memset(&swa, 0, sizeof(swa)); | |
| 248 swa.background_pixmap = None; | |
| 249 swa.override_redirect = default_override_redirect; | |
| 250 xwindow_ = XCreateWindow( | |
| 251 xdisplay_, x_root_window_, | |
| 252 bounds.x(), bounds.y(), bounds.width(), bounds.height(), | |
| 253 0, // border width | |
| 254 CopyFromParent, // depth | |
| 255 InputOutput, | |
| 256 CopyFromParent, // visual | |
| 257 CWBackPixmap | CWOverrideRedirect, | |
| 258 &swa); | |
| 259 if (ui::PlatformEventSource::GetInstance()) | |
| 260 ui::PlatformEventSource::GetInstance()->AddPlatformEventDispatcher(this); | |
| 261 | |
| 262 long event_mask = ButtonPressMask | ButtonReleaseMask | FocusChangeMask | | |
| 263 KeyPressMask | KeyReleaseMask | | |
| 264 EnterWindowMask | LeaveWindowMask | | |
| 265 ExposureMask | VisibilityChangeMask | | |
| 266 StructureNotifyMask | PropertyChangeMask | | |
| 267 PointerMotionMask; | |
| 268 XSelectInput(xdisplay_, xwindow_, event_mask); | |
| 269 XFlush(xdisplay_); | |
| 270 | |
| 271 if (ui::IsXInput2Available()) { | |
| 272 ui::TouchFactory::GetInstance()->SetupXI2ForXWindow(xwindow_); | |
| 273 SelectXInput2EventsForRootWindow(xdisplay_, x_root_window_); | |
| 274 } | |
| 275 | |
| 276 // TODO(erg): We currently only request window deletion events. We also | |
| 277 // should listen for activation events and anything else that GTK+ listens | |
| 278 // for, and do something useful. | |
| 279 ::Atom protocols[2]; | |
| 280 protocols[0] = atom_cache_.GetAtom("WM_DELETE_WINDOW"); | |
| 281 protocols[1] = atom_cache_.GetAtom("_NET_WM_PING"); | |
| 282 XSetWMProtocols(xdisplay_, xwindow_, protocols, 2); | |
| 283 | |
| 284 // We need a WM_CLIENT_MACHINE and WM_LOCALE_NAME value so we integrate with | |
| 285 // the desktop environment. | |
| 286 XSetWMProperties(xdisplay_, xwindow_, NULL, NULL, NULL, 0, NULL, NULL, NULL); | |
| 287 | |
| 288 // Likewise, the X server needs to know this window's pid so it knows which | |
| 289 // program to kill if the window hangs. | |
| 290 // XChangeProperty() expects "pid" to be long. | |
| 291 COMPILE_ASSERT(sizeof(long) >= sizeof(pid_t), pid_t_bigger_than_long); | |
| 292 long pid = getpid(); | |
| 293 XChangeProperty(xdisplay_, | |
| 294 xwindow_, | |
| 295 atom_cache_.GetAtom("_NET_WM_PID"), | |
| 296 XA_CARDINAL, | |
| 297 32, | |
| 298 PropModeReplace, | |
| 299 reinterpret_cast<unsigned char*>(&pid), 1); | |
| 300 | |
| 301 // Allow subclasses to create and cache additional atoms. | |
| 302 atom_cache_.allow_uncached_atoms(); | |
| 303 | |
| 304 XRRSelectInput(xdisplay_, x_root_window_, | |
| 305 RRScreenChangeNotifyMask | RROutputChangeNotifyMask); | |
| 306 CreateCompositor(GetAcceleratedWidget()); | |
| 307 } | |
| 308 | |
| 309 WindowTreeHostX11::~WindowTreeHostX11() { | |
| 310 if (ui::PlatformEventSource::GetInstance()) | |
| 311 ui::PlatformEventSource::GetInstance()->RemovePlatformEventDispatcher(this); | |
| 312 | |
| 313 DestroyCompositor(); | |
| 314 DestroyDispatcher(); | |
| 315 XDestroyWindow(xdisplay_, xwindow_); | |
| 316 } | |
| 317 | |
| 318 bool WindowTreeHostX11::CanDispatchEvent(const ui::PlatformEvent& event) { | |
| 319 ::Window target = FindEventTarget(event); | |
| 320 return target == xwindow_ || target == x_root_window_; | |
| 321 } | |
| 322 | |
| 323 uint32_t WindowTreeHostX11::DispatchEvent(const ui::PlatformEvent& event) { | |
| 324 XEvent* xev = event; | |
| 325 if (FindEventTarget(xev) == x_root_window_) { | |
| 326 if (xev->type == GenericEvent) | |
| 327 DispatchXI2Event(xev); | |
| 328 return ui::POST_DISPATCH_NONE; | |
| 329 } | |
| 330 | |
| 331 if (xev->type == MotionNotify) { | |
| 332 // Discard all but the most recent motion event that targets the same | |
| 333 // window with unchanged state. | |
| 334 XEvent last_event; | |
| 335 while (XPending(xev->xany.display)) { | |
| 336 XEvent next_event; | |
| 337 XPeekEvent(xev->xany.display, &next_event); | |
| 338 if (next_event.type == MotionNotify && | |
| 339 next_event.xmotion.window == xev->xmotion.window && | |
| 340 next_event.xmotion.subwindow == xev->xmotion.subwindow && | |
| 341 next_event.xmotion.state == xev->xmotion.state) { | |
| 342 XNextEvent(xev->xany.display, &last_event); | |
| 343 xev = &last_event; | |
| 344 } else { | |
| 345 break; | |
| 346 } | |
| 347 } | |
| 348 } | |
| 349 | |
| 350 if ((xev->type == EnterNotify || xev->type == LeaveNotify) && | |
| 351 xev->xcrossing.detail == NotifyInferior) { | |
| 352 // Ignore EventNotify and LeaveNotify events from children of |xwindow_|. | |
| 353 // NativeViewGLSurfaceGLX adds a child to |xwindow_|. | |
| 354 // TODO(pkotwicz|tdanderson): Figure out whether the suppression is | |
| 355 // necessary. crbug.com/385716 | |
| 356 return ui::POST_DISPATCH_STOP_PROPAGATION; | |
| 357 } | |
| 358 | |
| 359 if (xev->type == EnterNotify || | |
| 360 xev->type == LeaveNotify || | |
| 361 xev->type == KeyPress || | |
| 362 xev->type == KeyRelease || | |
| 363 xev->type == ButtonPress || | |
| 364 xev->type == ButtonRelease || | |
| 365 xev->type == MotionNotify) { | |
| 366 switch (ui::EventTypeFromNative(xev)) { | |
| 367 case ui::ET_KEY_PRESSED: | |
| 368 case ui::ET_KEY_RELEASED: { | |
| 369 ui::KeyEvent keydown_event(xev); | |
| 370 SendEventToProcessor(&keydown_event); | |
| 371 break; | |
| 372 } | |
| 373 case ui::ET_MOUSE_MOVED: | |
| 374 case ui::ET_MOUSE_DRAGGED: | |
| 375 case ui::ET_MOUSE_ENTERED: | |
| 376 case ui::ET_MOUSE_EXITED: | |
| 377 case ui::ET_MOUSE_PRESSED: | |
| 378 case ui::ET_MOUSE_RELEASED: { | |
| 379 ui::MouseEvent mouse_event(xev); | |
| 380 if (xev->type == EnterNotify) { | |
| 381 aura::Window* root_window = window(); | |
| 382 client::CursorClient* cursor_client = | |
| 383 client::GetCursorClient(root_window); | |
| 384 if (cursor_client) { | |
| 385 const gfx::Display display = gfx::Screen::GetScreenFor( | |
| 386 root_window)->GetDisplayNearestWindow(root_window); | |
| 387 cursor_client->SetDisplay(display); | |
| 388 } | |
| 389 // EnterNotify creates ET_MOUSE_MOVE. Mark as synthesized as this is | |
| 390 // not a real mouse move event. | |
| 391 mouse_event.set_flags(mouse_event.flags() | ui::EF_IS_SYNTHESIZED); | |
| 392 } | |
| 393 | |
| 394 TranslateAndDispatchLocatedEvent(&mouse_event); | |
| 395 break; | |
| 396 } | |
| 397 case ui::ET_MOUSEWHEEL: { | |
| 398 ui::MouseWheelEvent mouseev(xev); | |
| 399 TranslateAndDispatchLocatedEvent(&mouseev); | |
| 400 break; | |
| 401 } | |
| 402 case ui::ET_UNKNOWN: | |
| 403 // No event is created for X11-release events for mouse-wheel buttons. | |
| 404 break; | |
| 405 default: | |
| 406 NOTREACHED(); | |
| 407 } | |
| 408 return ui::POST_DISPATCH_STOP_PROPAGATION; | |
| 409 } | |
| 410 | |
| 411 switch (xev->type) { | |
| 412 case Expose: { | |
| 413 gfx::Rect damage_rect(xev->xexpose.x, xev->xexpose.y, | |
| 414 xev->xexpose.width, xev->xexpose.height); | |
| 415 compositor()->ScheduleRedrawRect(damage_rect); | |
| 416 break; | |
| 417 } | |
| 418 case FocusOut: | |
| 419 if (xev->xfocus.mode != NotifyGrab) | |
| 420 OnHostLostWindowCapture(); | |
| 421 break; | |
| 422 case ConfigureNotify: { | |
| 423 DCHECK_EQ(xwindow_, xev->xconfigure.event); | |
| 424 DCHECK_EQ(xwindow_, xev->xconfigure.window); | |
| 425 // It's possible that the X window may be resized by some other means | |
| 426 // than from within aura (e.g. the X window manager can change the | |
| 427 // size). Make sure the root window size is maintained properly. | |
| 428 gfx::Rect bounds(xev->xconfigure.x, xev->xconfigure.y, | |
| 429 xev->xconfigure.width, xev->xconfigure.height); | |
| 430 bool size_changed = bounds_.size() != bounds.size(); | |
| 431 bool origin_changed = bounds_.origin() != bounds.origin(); | |
| 432 bounds_ = bounds; | |
| 433 OnConfigureNotify(); | |
| 434 if (size_changed) | |
| 435 OnHostResized(bounds.size()); | |
| 436 if (origin_changed) | |
| 437 OnHostMoved(bounds_.origin()); | |
| 438 break; | |
| 439 } | |
| 440 case GenericEvent: | |
| 441 DispatchXI2Event(xev); | |
| 442 break; | |
| 443 case ClientMessage: { | |
| 444 Atom message_type = static_cast<Atom>(xev->xclient.data.l[0]); | |
| 445 if (message_type == atom_cache_.GetAtom("WM_DELETE_WINDOW")) { | |
| 446 // We have received a close message from the window manager. | |
| 447 OnHostCloseRequested(); | |
| 448 } else if (message_type == atom_cache_.GetAtom("_NET_WM_PING")) { | |
| 449 XEvent reply_event = *xev; | |
| 450 reply_event.xclient.window = x_root_window_; | |
| 451 | |
| 452 XSendEvent(xdisplay_, | |
| 453 reply_event.xclient.window, | |
| 454 False, | |
| 455 SubstructureRedirectMask | SubstructureNotifyMask, | |
| 456 &reply_event); | |
| 457 XFlush(xdisplay_); | |
| 458 } | |
| 459 break; | |
| 460 } | |
| 461 case MappingNotify: { | |
| 462 switch (xev->xmapping.request) { | |
| 463 case MappingModifier: | |
| 464 case MappingKeyboard: | |
| 465 XRefreshKeyboardMapping(&xev->xmapping); | |
| 466 break; | |
| 467 case MappingPointer: | |
| 468 ui::DeviceDataManagerX11::GetInstance()->UpdateButtonMap(); | |
| 469 break; | |
| 470 default: | |
| 471 NOTIMPLEMENTED() << " Unknown request: " << xev->xmapping.request; | |
| 472 break; | |
| 473 } | |
| 474 break; | |
| 475 } | |
| 476 } | |
| 477 return ui::POST_DISPATCH_STOP_PROPAGATION; | |
| 478 } | |
| 479 | |
| 480 ui::EventSource* WindowTreeHostX11::GetEventSource() { | |
| 481 return this; | |
| 482 } | |
| 483 | |
| 484 gfx::AcceleratedWidget WindowTreeHostX11::GetAcceleratedWidget() { | |
| 485 return xwindow_; | |
| 486 } | |
| 487 | |
| 488 void WindowTreeHostX11::Show() { | |
| 489 if (!window_mapped_) { | |
| 490 // Before we map the window, set size hints. Otherwise, some window managers | |
| 491 // will ignore toplevel XMoveWindow commands. | |
| 492 XSizeHints size_hints; | |
| 493 size_hints.flags = PPosition | PWinGravity; | |
| 494 size_hints.x = bounds_.x(); | |
| 495 size_hints.y = bounds_.y(); | |
| 496 // Set StaticGravity so that the window position is not affected by the | |
| 497 // frame width when running with window manager. | |
| 498 size_hints.win_gravity = StaticGravity; | |
| 499 XSetWMNormalHints(xdisplay_, xwindow_, &size_hints); | |
| 500 | |
| 501 XMapWindow(xdisplay_, xwindow_); | |
| 502 | |
| 503 // We now block until our window is mapped. Some X11 APIs will crash and | |
| 504 // burn if passed |xwindow_| before the window is mapped, and XMapWindow is | |
| 505 // asynchronous. | |
| 506 if (ui::X11EventSource::GetInstance()) | |
| 507 ui::X11EventSource::GetInstance()->BlockUntilWindowMapped(xwindow_); | |
| 508 window_mapped_ = true; | |
| 509 } | |
| 510 } | |
| 511 | |
| 512 void WindowTreeHostX11::Hide() { | |
| 513 if (window_mapped_) { | |
| 514 XWithdrawWindow(xdisplay_, xwindow_, 0); | |
| 515 window_mapped_ = false; | |
| 516 } | |
| 517 } | |
| 518 | |
| 519 gfx::Rect WindowTreeHostX11::GetBounds() const { | |
| 520 return bounds_; | |
| 521 } | |
| 522 | |
| 523 void WindowTreeHostX11::SetBounds(const gfx::Rect& bounds) { | |
| 524 // Even if the host window's size doesn't change, aura's root window | |
| 525 // size, which is in DIP, changes when the scale changes. | |
| 526 float current_scale = compositor()->device_scale_factor(); | |
| 527 float new_scale = gfx::Screen::GetScreenFor(window())-> | |
| 528 GetDisplayNearestWindow(window()).device_scale_factor(); | |
| 529 bool origin_changed = bounds_.origin() != bounds.origin(); | |
| 530 bool size_changed = bounds_.size() != bounds.size(); | |
| 531 XWindowChanges changes = {0}; | |
| 532 unsigned value_mask = 0; | |
| 533 | |
| 534 if (size_changed) { | |
| 535 changes.width = bounds.width(); | |
| 536 changes.height = bounds.height(); | |
| 537 value_mask = CWHeight | CWWidth; | |
| 538 } | |
| 539 | |
| 540 if (origin_changed) { | |
| 541 changes.x = bounds.x(); | |
| 542 changes.y = bounds.y(); | |
| 543 value_mask |= CWX | CWY; | |
| 544 } | |
| 545 if (value_mask) | |
| 546 XConfigureWindow(xdisplay_, xwindow_, value_mask, &changes); | |
| 547 | |
| 548 // Assume that the resize will go through as requested, which should be the | |
| 549 // case if we're running without a window manager. If there's a window | |
| 550 // manager, it can modify or ignore the request, but (per ICCCM) we'll get a | |
| 551 // (possibly synthetic) ConfigureNotify about the actual size and correct | |
| 552 // |bounds_| later. | |
| 553 bounds_ = bounds; | |
| 554 if (origin_changed) | |
| 555 OnHostMoved(bounds.origin()); | |
| 556 if (size_changed || current_scale != new_scale) { | |
| 557 OnHostResized(bounds.size()); | |
| 558 } else { | |
| 559 window()->SchedulePaintInRect(window()->bounds()); | |
| 560 } | |
| 561 } | |
| 562 | |
| 563 gfx::Point WindowTreeHostX11::GetLocationOnNativeScreen() const { | |
| 564 return bounds_.origin(); | |
| 565 } | |
| 566 | |
| 567 void WindowTreeHostX11::SetCapture() { | |
| 568 // TODO(oshima): Grab x input. | |
| 569 } | |
| 570 | |
| 571 void WindowTreeHostX11::ReleaseCapture() { | |
| 572 // TODO(oshima): Release x input. | |
| 573 } | |
| 574 | |
| 575 void WindowTreeHostX11::PostNativeEvent( | |
| 576 const base::NativeEvent& native_event) { | |
| 577 DCHECK(xwindow_); | |
| 578 DCHECK(xdisplay_); | |
| 579 XEvent xevent = *native_event; | |
| 580 xevent.xany.display = xdisplay_; | |
| 581 xevent.xany.window = xwindow_; | |
| 582 | |
| 583 switch (xevent.type) { | |
| 584 case EnterNotify: | |
| 585 case LeaveNotify: | |
| 586 case MotionNotify: | |
| 587 case KeyPress: | |
| 588 case KeyRelease: | |
| 589 case ButtonPress: | |
| 590 case ButtonRelease: { | |
| 591 // The fields used below are in the same place for all of events | |
| 592 // above. Using xmotion from XEvent's unions to avoid repeating | |
| 593 // the code. | |
| 594 xevent.xmotion.root = x_root_window_; | |
| 595 xevent.xmotion.time = CurrentTime; | |
| 596 | |
| 597 gfx::Point point(xevent.xmotion.x, xevent.xmotion.y); | |
| 598 ConvertPointToNativeScreen(&point); | |
| 599 xevent.xmotion.x_root = point.x(); | |
| 600 xevent.xmotion.y_root = point.y(); | |
| 601 } | |
| 602 default: | |
| 603 break; | |
| 604 } | |
| 605 XSendEvent(xdisplay_, xwindow_, False, 0, &xevent); | |
| 606 XFlush(xdisplay_); | |
| 607 } | |
| 608 | |
| 609 void WindowTreeHostX11::SetCursorNative(gfx::NativeCursor cursor) { | |
| 610 if (cursor == current_cursor_) | |
| 611 return; | |
| 612 current_cursor_ = cursor; | |
| 613 SetCursorInternal(cursor); | |
| 614 } | |
| 615 | |
| 616 void WindowTreeHostX11::MoveCursorToNative(const gfx::Point& location) { | |
| 617 XWarpPointer(xdisplay_, None, x_root_window_, 0, 0, 0, 0, | |
| 618 bounds_.x() + location.x(), | |
| 619 bounds_.y() + location.y()); | |
| 620 } | |
| 621 | |
| 622 void WindowTreeHostX11::OnCursorVisibilityChangedNative(bool show) { | |
| 623 } | |
| 624 | |
| 625 ui::EventProcessor* WindowTreeHostX11::GetEventProcessor() { | |
| 626 return dispatcher(); | |
| 627 } | |
| 628 | |
| 629 void WindowTreeHostX11::DispatchXI2Event(const base::NativeEvent& event) { | |
| 630 ui::TouchFactory* factory = ui::TouchFactory::GetInstance(); | |
| 631 XEvent* xev = event; | |
| 632 XIDeviceEvent* xiev = static_cast<XIDeviceEvent*>(xev->xcookie.data); | |
| 633 if (!factory->ShouldProcessXI2Event(xev)) | |
| 634 return; | |
| 635 | |
| 636 TRACE_EVENT1("input", "WindowTreeHostX11::DispatchXI2Event", | |
| 637 "event_latency_us", | |
| 638 (ui::EventTimeForNow() - ui::EventTimeFromNative(event)). | |
| 639 InMicroseconds()); | |
| 640 | |
| 641 int num_coalesced = 0; | |
| 642 XEvent last_event; | |
| 643 if (xev->xgeneric.evtype == XI_Motion) { | |
| 644 // If this is a motion event, we want to coalesce all pending motion | |
| 645 // events that are at the top of the queue. Note, we don't coalesce | |
| 646 // touch update events here. | |
| 647 num_coalesced = ui::CoalescePendingMotionEvents(xev, &last_event); | |
| 648 if (num_coalesced > 0) | |
| 649 xev = &last_event; | |
| 650 } | |
| 651 ui::EventType type = ui::EventTypeFromNative(xev); | |
| 652 | |
| 653 switch (type) { | |
| 654 case ui::ET_TOUCH_MOVED: | |
| 655 case ui::ET_TOUCH_PRESSED: | |
| 656 case ui::ET_TOUCH_CANCELLED: | |
| 657 case ui::ET_TOUCH_RELEASED: { | |
| 658 ui::TouchEvent touchev(xev); | |
| 659 if (ui::DeviceDataManagerX11::GetInstance()->TouchEventNeedsCalibrate( | |
| 660 xiev->deviceid)) { | |
| 661 touch_calibrate_->Calibrate(&touchev, bounds_); | |
| 662 } | |
| 663 TranslateAndDispatchLocatedEvent(&touchev); | |
| 664 break; | |
| 665 } | |
| 666 case ui::ET_MOUSE_MOVED: | |
| 667 case ui::ET_MOUSE_DRAGGED: | |
| 668 case ui::ET_MOUSE_PRESSED: | |
| 669 case ui::ET_MOUSE_RELEASED: | |
| 670 case ui::ET_MOUSE_ENTERED: | |
| 671 case ui::ET_MOUSE_EXITED: { | |
| 672 ui::MouseEvent mouseev(xev); | |
| 673 TranslateAndDispatchLocatedEvent(&mouseev); | |
| 674 break; | |
| 675 } | |
| 676 case ui::ET_MOUSEWHEEL: { | |
| 677 ui::MouseWheelEvent mouseev(xev); | |
| 678 TranslateAndDispatchLocatedEvent(&mouseev); | |
| 679 break; | |
| 680 } | |
| 681 case ui::ET_SCROLL_FLING_START: | |
| 682 case ui::ET_SCROLL_FLING_CANCEL: | |
| 683 case ui::ET_SCROLL: { | |
| 684 ui::ScrollEvent scrollev(xev); | |
| 685 SendEventToProcessor(&scrollev); | |
| 686 break; | |
| 687 } | |
| 688 case ui::ET_KEY_PRESSED: | |
| 689 case ui::ET_KEY_RELEASED: { | |
| 690 ui::KeyEvent key_event(xev); | |
| 691 SendEventToProcessor(&key_event); | |
| 692 break; | |
| 693 } | |
| 694 case ui::ET_UMA_DATA: | |
| 695 break; | |
| 696 case ui::ET_UNKNOWN: | |
| 697 break; | |
| 698 default: | |
| 699 NOTREACHED(); | |
| 700 } | |
| 701 | |
| 702 // If we coalesced an event we need to free its cookie. | |
| 703 if (num_coalesced > 0) | |
| 704 XFreeEventData(xev->xgeneric.display, &last_event.xcookie); | |
| 705 } | |
| 706 | |
| 707 void WindowTreeHostX11::SetCursorInternal(gfx::NativeCursor cursor) { | |
| 708 XDefineCursor(xdisplay_, xwindow_, cursor.platform()); | |
| 709 } | |
| 710 | |
| 711 void WindowTreeHostX11::OnConfigureNotify() {} | |
| 712 | |
| 713 void WindowTreeHostX11::TranslateAndDispatchLocatedEvent( | |
| 714 ui::LocatedEvent* event) { | |
| 715 SendEventToProcessor(event); | |
| 716 } | |
| 717 | |
| 718 // static | |
| 719 WindowTreeHost* WindowTreeHost::Create(const gfx::Rect& bounds) { | |
| 720 return new WindowTreeHostX11(bounds); | |
| 721 } | |
| 722 | |
| 723 // static | |
| 724 gfx::Size WindowTreeHost::GetNativeScreenSize() { | |
| 725 ::XDisplay* xdisplay = gfx::GetXDisplay(); | |
| 726 return gfx::Size(DisplayWidth(xdisplay, 0), DisplayHeight(xdisplay, 0)); | |
| 727 } | |
| 728 | |
| 729 namespace test { | |
| 730 | |
| 731 void SetUseOverrideRedirectWindowByDefault(bool override_redirect) { | |
| 732 default_override_redirect = override_redirect; | |
| 733 } | |
| 734 | |
| 735 } // namespace test | |
| 736 } // namespace aura | |
| OLD | NEW |
|---|
Chromium Code Reviews
