OLD | NEW |
(Empty) | |
| 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 "ash/host/ash_window_tree_host_x11.h" |
| 6 |
| 7 #include <X11/extensions/Xfixes.h> |
| 8 #include <X11/extensions/XInput2.h> |
| 9 #include <X11/Xatom.h> |
| 10 #include <X11/Xlib.h> |
| 11 |
| 12 #include <string> |
| 13 #include <vector> |
| 14 |
| 15 #include "ash/host/root_window_transformer.h" |
| 16 #include "base/basictypes.h" |
| 17 #include "base/command_line.h" |
| 18 #include "base/strings/string_number_conversions.h" |
| 19 #include "base/strings/string_util.h" |
| 20 #include "base/sys_info.h" |
| 21 #include "ui/aura/client/screen_position_client.h" |
| 22 #include "ui/aura/env.h" |
| 23 #include "ui/aura/window.h" |
| 24 #include "ui/base/x/x11_util.h" |
| 25 #include "ui/events/event.h" |
| 26 #include "ui/events/event_switches.h" |
| 27 #include "ui/events/event_utils.h" |
| 28 #include "ui/events/platform/platform_event_observer.h" |
| 29 #include "ui/events/platform/x11/x11_event_source.h" |
| 30 #include "ui/events/x/device_data_manager.h" |
| 31 #include "ui/events/x/device_list_cache_x.h" |
| 32 #include "ui/events/x/touch_factory_x11.h" |
| 33 |
| 34 #include "ui/gfx/rect.h" |
| 35 #include "ui/gfx/screen.h" |
| 36 |
| 37 namespace ash { |
| 38 |
| 39 // Accomplishes 2 tasks concerning touch event calibration: |
| 40 // 1. Being a message-pump observer, |
| 41 // routes all the touch events to the X root window, |
| 42 // where they can be calibrated later. |
| 43 // 2. Has the Calibrate method that does the actual bezel calibration, |
| 44 // when invoked from X root window's event dispatcher. |
| 45 class AshWindowTreeHostX11::TouchEventCalibrate |
| 46 : public ui::PlatformEventObserver { |
| 47 public: |
| 48 TouchEventCalibrate() : left_(0), right_(0), top_(0), bottom_(0) { |
| 49 if (ui::PlatformEventSource::GetInstance()) |
| 50 ui::PlatformEventSource::GetInstance()->AddPlatformEventObserver(this); |
| 51 #if defined(USE_XI2_MT) |
| 52 std::vector<std::string> parts; |
| 53 if (Tokenize(CommandLine::ForCurrentProcess()->GetSwitchValueASCII( |
| 54 switches::kTouchCalibration), |
| 55 ",", |
| 56 &parts) >= 4) { |
| 57 if (!base::StringToInt(parts[0], &left_)) |
| 58 DLOG(ERROR) << "Incorrect left border calibration value passed."; |
| 59 if (!base::StringToInt(parts[1], &right_)) |
| 60 DLOG(ERROR) << "Incorrect right border calibration value passed."; |
| 61 if (!base::StringToInt(parts[2], &top_)) |
| 62 DLOG(ERROR) << "Incorrect top border calibration value passed."; |
| 63 if (!base::StringToInt(parts[3], &bottom_)) |
| 64 DLOG(ERROR) << "Incorrect bottom border calibration value passed."; |
| 65 } |
| 66 #endif // defined(USE_XI2_MT) |
| 67 } |
| 68 |
| 69 virtual ~TouchEventCalibrate() { |
| 70 if (ui::PlatformEventSource::GetInstance()) |
| 71 ui::PlatformEventSource::GetInstance()->RemovePlatformEventObserver(this); |
| 72 } |
| 73 |
| 74 // Modify the location of the |event|, |
| 75 // expanding it from |bounds| to (|bounds| + bezels). |
| 76 // Required when touchscreen is bigger than screen (i.e. has bezels), |
| 77 // because we receive events in touchscreen coordinates, |
| 78 // which need to be expanded when converting to screen coordinates, |
| 79 // so that location on bezels will be outside of screen area. |
| 80 void Calibrate(ui::TouchEvent* event, const gfx::Rect& bounds) { |
| 81 #if defined(USE_XI2_MT) |
| 82 int x = event->x(); |
| 83 int y = event->y(); |
| 84 |
| 85 if (!left_ && !right_ && !top_ && !bottom_) |
| 86 return; |
| 87 |
| 88 const int resolution_x = bounds.width(); |
| 89 const int resolution_y = bounds.height(); |
| 90 // The "grace area" (10% in this case) is to make it easier for the user to |
| 91 // navigate to the corner. |
| 92 const double kGraceAreaFraction = 0.1; |
| 93 if (left_ || right_) { |
| 94 // Offset the x position to the real |
| 95 x -= left_; |
| 96 // Check if we are in the grace area of the left side. |
| 97 // Note: We might not want to do this when the gesture is locked? |
| 98 if (x < 0 && x > -left_ * kGraceAreaFraction) |
| 99 x = 0; |
| 100 // Check if we are in the grace area of the right side. |
| 101 // Note: We might not want to do this when the gesture is locked? |
| 102 if (x > resolution_x - left_ && |
| 103 x < resolution_x - left_ + right_ * kGraceAreaFraction) |
| 104 x = resolution_x - left_; |
| 105 // Scale the screen area back to the full resolution of the screen. |
| 106 x = (x * resolution_x) / (resolution_x - (right_ + left_)); |
| 107 } |
| 108 if (top_ || bottom_) { |
| 109 // When there is a top bezel we add our border, |
| 110 y -= top_; |
| 111 |
| 112 // Check if we are in the grace area of the top side. |
| 113 // Note: We might not want to do this when the gesture is locked? |
| 114 if (y < 0 && y > -top_ * kGraceAreaFraction) |
| 115 y = 0; |
| 116 |
| 117 // Check if we are in the grace area of the bottom side. |
| 118 // Note: We might not want to do this when the gesture is locked? |
| 119 if (y > resolution_y - top_ && |
| 120 y < resolution_y - top_ + bottom_ * kGraceAreaFraction) |
| 121 y = resolution_y - top_; |
| 122 // Scale the screen area back to the full resolution of the screen. |
| 123 y = (y * resolution_y) / (resolution_y - (bottom_ + top_)); |
| 124 } |
| 125 |
| 126 // Set the modified coordinate back to the event. |
| 127 if (event->root_location() == event->location()) { |
| 128 // Usually those will be equal, |
| 129 // if not, I am not sure what the correct value should be. |
| 130 event->set_root_location(gfx::Point(x, y)); |
| 131 } |
| 132 event->set_location(gfx::Point(x, y)); |
| 133 #endif // defined(USE_XI2_MT) |
| 134 } |
| 135 |
| 136 private: |
| 137 // ui::PlatformEventObserver: |
| 138 virtual void WillProcessEvent(const ui::PlatformEvent& event) OVERRIDE { |
| 139 #if defined(USE_XI2_MT) |
| 140 if (event->type == GenericEvent && |
| 141 (event->xgeneric.evtype == XI_TouchBegin || |
| 142 event->xgeneric.evtype == XI_TouchUpdate || |
| 143 event->xgeneric.evtype == XI_TouchEnd)) { |
| 144 XIDeviceEvent* xievent = static_cast<XIDeviceEvent*>(event->xcookie.data); |
| 145 xievent->event = xievent->root; |
| 146 xievent->event_x = xievent->root_x; |
| 147 xievent->event_y = xievent->root_y; |
| 148 } |
| 149 #endif // defined(USE_XI2_MT) |
| 150 } |
| 151 |
| 152 virtual void DidProcessEvent(const ui::PlatformEvent& event) OVERRIDE {} |
| 153 |
| 154 // The difference in screen's native resolution pixels between |
| 155 // the border of the touchscreen and the border of the screen, |
| 156 // aka bezel sizes. |
| 157 int left_; |
| 158 int right_; |
| 159 int top_; |
| 160 int bottom_; |
| 161 |
| 162 DISALLOW_COPY_AND_ASSIGN(TouchEventCalibrate); |
| 163 }; |
| 164 |
| 165 //////////////////////////////////////////////////////////////////////////////// |
| 166 // AshWindowTreeHostX11 |
| 167 |
| 168 AshWindowTreeHostX11::AshWindowTreeHostX11(const gfx::Rect& initial_bounds) |
| 169 : WindowTreeHostX11(initial_bounds), |
| 170 is_internal_display_(false), |
| 171 touch_calibrate_(new TouchEventCalibrate), |
| 172 transformer_helper_(this) { |
| 173 aura::Env::GetInstance()->AddObserver(this); |
| 174 } |
| 175 |
| 176 AshWindowTreeHostX11::~AshWindowTreeHostX11() { |
| 177 aura::Env::GetInstance()->RemoveObserver(this); |
| 178 UnConfineCursor(); |
| 179 } |
| 180 |
| 181 void AshWindowTreeHostX11::ToggleFullScreen() { NOTIMPLEMENTED(); } |
| 182 |
| 183 bool AshWindowTreeHostX11::ConfineCursorToRootWindow() { |
| 184 #if XFIXES_MAJOR >= 5 |
| 185 DCHECK(!pointer_barriers_.get()); |
| 186 if (pointer_barriers_) |
| 187 return false; |
| 188 pointer_barriers_.reset(new XID[4]); |
| 189 gfx::Rect barrier(bounds()); |
| 190 barrier.Inset(transformer_helper_.GetHostInsets()); |
| 191 // Horizontal, top barriers. |
| 192 pointer_barriers_[0] = XFixesCreatePointerBarrier(xdisplay(), |
| 193 x_root_window(), |
| 194 barrier.x(), |
| 195 barrier.y(), |
| 196 barrier.right(), |
| 197 barrier.y(), |
| 198 BarrierPositiveY, |
| 199 0, |
| 200 XIAllDevices); |
| 201 // Horizontal, bottom barriers. |
| 202 pointer_barriers_[1] = XFixesCreatePointerBarrier(xdisplay(), |
| 203 x_root_window(), |
| 204 barrier.x(), |
| 205 barrier.bottom(), |
| 206 barrier.right(), |
| 207 barrier.bottom(), |
| 208 BarrierNegativeY, |
| 209 0, |
| 210 XIAllDevices); |
| 211 // Vertical, left barriers. |
| 212 pointer_barriers_[2] = XFixesCreatePointerBarrier(xdisplay(), |
| 213 x_root_window(), |
| 214 barrier.x(), |
| 215 barrier.y(), |
| 216 barrier.x(), |
| 217 barrier.bottom(), |
| 218 BarrierPositiveX, |
| 219 0, |
| 220 XIAllDevices); |
| 221 // Vertical, right barriers. |
| 222 pointer_barriers_[3] = XFixesCreatePointerBarrier(xdisplay(), |
| 223 x_root_window(), |
| 224 barrier.right(), |
| 225 barrier.y(), |
| 226 barrier.right(), |
| 227 barrier.bottom(), |
| 228 BarrierNegativeX, |
| 229 0, |
| 230 XIAllDevices); |
| 231 #endif |
| 232 return true; |
| 233 } |
| 234 |
| 235 void AshWindowTreeHostX11::UnConfineCursor() { |
| 236 #if XFIXES_MAJOR >= 5 |
| 237 if (pointer_barriers_) { |
| 238 XFixesDestroyPointerBarrier(xdisplay(), pointer_barriers_[0]); |
| 239 XFixesDestroyPointerBarrier(xdisplay(), pointer_barriers_[1]); |
| 240 XFixesDestroyPointerBarrier(xdisplay(), pointer_barriers_[2]); |
| 241 XFixesDestroyPointerBarrier(xdisplay(), pointer_barriers_[3]); |
| 242 pointer_barriers_.reset(); |
| 243 } |
| 244 #endif |
| 245 } |
| 246 |
| 247 void AshWindowTreeHostX11::SetRootWindowTransformer( |
| 248 scoped_ptr<RootWindowTransformer> transformer) { |
| 249 transformer_helper_.SetRootWindowTransformer(transformer.Pass()); |
| 250 UpdateIsInternalDisplay(); |
| 251 if (pointer_barriers_) { |
| 252 UnConfineCursor(); |
| 253 ConfineCursorToRootWindow(); |
| 254 } |
| 255 } |
| 256 |
| 257 aura::WindowTreeHost* AshWindowTreeHostX11::AsWindowTreeHost() { return this; } |
| 258 |
| 259 void AshWindowTreeHostX11::SetBounds(const gfx::Rect& bounds) { |
| 260 WindowTreeHostX11::SetBounds(bounds); |
| 261 UpdateIsInternalDisplay(); |
| 262 if (pointer_barriers_) { |
| 263 UnConfineCursor(); |
| 264 ConfineCursorToRootWindow(); |
| 265 } |
| 266 } |
| 267 |
| 268 gfx::Transform AshWindowTreeHostX11::GetRootTransform() const { |
| 269 return transformer_helper_.GetTransform(); |
| 270 } |
| 271 |
| 272 void AshWindowTreeHostX11::SetRootTransform(const gfx::Transform& transform) { |
| 273 transformer_helper_.SetTransform(transform); |
| 274 } |
| 275 |
| 276 gfx::Transform AshWindowTreeHostX11::GetInverseRootTransform() const { |
| 277 return transformer_helper_.GetInverseTransform(); |
| 278 } |
| 279 |
| 280 void AshWindowTreeHostX11::UpdateRootWindowSize(const gfx::Size& host_size) { |
| 281 transformer_helper_.UpdateWindowSize(host_size); |
| 282 } |
| 283 |
| 284 void AshWindowTreeHostX11::OnCursorVisibilityChangedNative(bool show) { |
| 285 SetCrOSTapPaused(!show); |
| 286 } |
| 287 |
| 288 void AshWindowTreeHostX11::OnWindowInitialized(aura::Window* window) {} |
| 289 |
| 290 void AshWindowTreeHostX11::OnHostInitialized(aura::WindowTreeHost* host) { |
| 291 // UpdateIsInternalDisplay relies on RootWindowSettings' display_id being set |
| 292 // available by the time WED::Init is called. (set in |
| 293 // DisplayManager::CreateRootWindowForDisplay) |
| 294 // Ready when NotifyHostInitialized is called from WED::Init. |
| 295 if (host != AsWindowTreeHost()) |
| 296 return; |
| 297 UpdateIsInternalDisplay(); |
| 298 |
| 299 // We have to enable Tap-to-click by default because the cursor is set to |
| 300 // visible in Shell::InitRootWindowController. |
| 301 SetCrOSTapPaused(false); |
| 302 } |
| 303 |
| 304 void AshWindowTreeHostX11::OnConfigureNotify() { |
| 305 UpdateIsInternalDisplay(); |
| 306 |
| 307 // Always update barrier and mouse location because |bounds_| might |
| 308 // have already been updated in |SetBounds|. |
| 309 if (pointer_barriers_) { |
| 310 UnConfineCursor(); |
| 311 ConfineCursorToRootWindow(); |
| 312 } |
| 313 } |
| 314 |
| 315 void AshWindowTreeHostX11::TranslateAndDispatchLocatedEvent( |
| 316 ui::LocatedEvent* event) { |
| 317 switch (event->type()) { |
| 318 case ui::ET_TOUCH_MOVED: |
| 319 case ui::ET_TOUCH_PRESSED: |
| 320 case ui::ET_TOUCH_CANCELLED: |
| 321 case ui::ET_TOUCH_RELEASED: { |
| 322 ui::TouchEvent* touchev = static_cast<ui::TouchEvent*>(event); |
| 323 if (base::SysInfo::IsRunningOnChromeOS()) { |
| 324 // X maps the touch-surface to the size of the X root-window. |
| 325 // In multi-monitor setup, Coordinate Transformation Matrix |
| 326 // repositions the touch-surface onto part of X root-window |
| 327 // containing aura root-window corresponding to the touchscreen. |
| 328 // However, if aura root-window has non-zero origin, |
| 329 // we need to relocate the event into aura root-window coordinates. |
| 330 touchev->Relocate(bounds().origin()); |
| 331 #if defined(USE_XI2_MT) |
| 332 if (is_internal_display_) |
| 333 touch_calibrate_->Calibrate(touchev, bounds()); |
| 334 #endif // defined(USE_XI2_MT) |
| 335 } |
| 336 break; |
| 337 } |
| 338 default: { |
| 339 aura::Window* root_window = window(); |
| 340 aura::client::ScreenPositionClient* screen_position_client = |
| 341 aura::client::GetScreenPositionClient(root_window); |
| 342 gfx::Rect local(bounds().size()); |
| 343 |
| 344 if (screen_position_client && !local.Contains(event->location())) { |
| 345 gfx::Point location(event->location()); |
| 346 // In order to get the correct point in screen coordinates |
| 347 // during passive grab, we first need to find on which host window |
| 348 // the mouse is on, and find out the screen coordinates on that |
| 349 // host window, then convert it back to this host window's coordinate. |
| 350 screen_position_client->ConvertHostPointToScreen(root_window, |
| 351 &location); |
| 352 screen_position_client->ConvertPointFromScreen(root_window, &location); |
| 353 ConvertPointToHost(&location); |
| 354 event->set_location(location); |
| 355 event->set_root_location(location); |
| 356 } |
| 357 break; |
| 358 } |
| 359 } |
| 360 SendEventToProcessor(event); |
| 361 } |
| 362 |
| 363 void AshWindowTreeHostX11::UpdateIsInternalDisplay() { |
| 364 aura::Window* root_window = window(); |
| 365 gfx::Screen* screen = gfx::Screen::GetScreenFor(root_window); |
| 366 gfx::Display display = screen->GetDisplayNearestWindow(root_window); |
| 367 DCHECK(display.is_valid()); |
| 368 is_internal_display_ = display.IsInternal(); |
| 369 } |
| 370 |
| 371 void AshWindowTreeHostX11::SetCrOSTapPaused(bool state) { |
| 372 if (!ui::IsXInput2Available()) |
| 373 return; |
| 374 // Temporarily pause tap-to-click when the cursor is hidden. |
| 375 Atom prop = atom_cache()->GetAtom("Tap Paused"); |
| 376 unsigned char value = state; |
| 377 XIDeviceList dev_list = |
| 378 ui::DeviceListCacheX::GetInstance()->GetXI2DeviceList(xdisplay()); |
| 379 |
| 380 // Only slave pointer devices could possibly have tap-paused property. |
| 381 for (int i = 0; i < dev_list.count; i++) { |
| 382 if (dev_list[i].use == XISlavePointer) { |
| 383 Atom old_type; |
| 384 int old_format; |
| 385 unsigned long old_nvalues, bytes; |
| 386 unsigned char* data; |
| 387 int result = XIGetProperty(xdisplay(), |
| 388 dev_list[i].deviceid, |
| 389 prop, |
| 390 0, |
| 391 0, |
| 392 False, |
| 393 AnyPropertyType, |
| 394 &old_type, |
| 395 &old_format, |
| 396 &old_nvalues, |
| 397 &bytes, |
| 398 &data); |
| 399 if (result != Success) |
| 400 continue; |
| 401 XFree(data); |
| 402 XIChangeProperty(xdisplay(), |
| 403 dev_list[i].deviceid, |
| 404 prop, |
| 405 XA_INTEGER, |
| 406 8, |
| 407 PropModeReplace, |
| 408 &value, |
| 409 1); |
| 410 } |
| 411 } |
| 412 } |
| 413 |
| 414 AshWindowTreeHost* AshWindowTreeHost::Create(const gfx::Rect& initial_bounds) { |
| 415 return new AshWindowTreeHostX11(initial_bounds); |
| 416 } |
| 417 |
| 418 } // namespace ash |
OLD | NEW |