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/wm/tablet_mode/scoped_disable_internal_mouse_and_keyboard_x11.h" |
| 6 |
| 7 #include <X11/Xlib.h> |
| 8 #include <X11/extensions/XInput2.h> |
| 9 |
| 10 #include <memory> |
| 11 #include <set> |
| 12 #include <utility> |
| 13 |
| 14 #include "ash/display/window_tree_host_manager.h" |
| 15 #include "ash/shell.h" |
| 16 #include "base/strings/string_util.h" |
| 17 #include "ui/aura/client/cursor_client.h" |
| 18 #include "ui/aura/client/screen_position_client.h" |
| 19 #include "ui/aura/env.h" |
| 20 #include "ui/aura/window.h" |
| 21 #include "ui/aura/window_event_dispatcher.h" |
| 22 #include "ui/aura/window_tree_host.h" |
| 23 #include "ui/events/devices/input_device.h" |
| 24 #include "ui/events/devices/x11/device_data_manager_x11.h" |
| 25 #include "ui/events/devices/x11/device_list_cache_x11.h" |
| 26 #include "ui/events/event.h" |
| 27 #include "ui/events/event_utils.h" |
| 28 #include "ui/events/keycodes/keyboard_codes_posix.h" |
| 29 #include "ui/events/platform/platform_event_source.h" |
| 30 #include "ui/gfx/x/x11_types.h" |
| 31 |
| 32 namespace ash { |
| 33 |
| 34 namespace { |
| 35 |
| 36 // The name of the xinput device corresponding to the internal touchpad. |
| 37 const char kInternalTouchpadName[] = "Elan Touchpad"; |
| 38 |
| 39 // Repeated key events have their source set to the core keyboard device. |
| 40 // These must be disabled also until http://crbug.com/402898 is resolved. |
| 41 const char kCoreKeyboardName[] = "Virtual core keyboard"; |
| 42 |
| 43 // Device id used to indicate that a device has not been detected. |
| 44 const int kDeviceIdNone = -1; |
| 45 |
| 46 gfx::Point GetMouseLocationInScreen() { |
| 47 return aura::Env::GetInstance()->last_mouse_location(); |
| 48 } |
| 49 |
| 50 void SetMouseLocationInScreen(const gfx::Point& screen_location) { |
| 51 const display::Display& display = |
| 52 Shell::Get()->display_manager()->FindDisplayContainingPoint( |
| 53 screen_location); |
| 54 if (!display.is_valid()) |
| 55 return; |
| 56 aura::Window* root_window = |
| 57 Shell::Get()->window_tree_host_manager()->GetRootWindowForDisplayId( |
| 58 display.id()); |
| 59 gfx::Point host_location(screen_location); |
| 60 aura::client::ScreenPositionClient* client = |
| 61 aura::client::GetScreenPositionClient(root_window); |
| 62 if (client) |
| 63 client->ConvertPointFromScreen(root_window, &host_location); |
| 64 root_window->GetHost()->MoveCursorToLocationInDIP(host_location); |
| 65 } |
| 66 |
| 67 } // namespace |
| 68 |
| 69 ScopedDisableInternalMouseAndKeyboardX11:: |
| 70 ScopedDisableInternalMouseAndKeyboardX11() |
| 71 : touchpad_device_id_(kDeviceIdNone), |
| 72 keyboard_device_id_(kDeviceIdNone), |
| 73 core_keyboard_device_id_(kDeviceIdNone), |
| 74 last_mouse_location_(GetMouseLocationInScreen()) { |
| 75 ui::DeviceDataManagerX11* device_data_manager = |
| 76 ui::DeviceDataManagerX11::GetInstance(); |
| 77 if (device_data_manager->IsXInput2Available()) { |
| 78 const XIDeviceList& xi_dev_list = |
| 79 ui::DeviceListCacheX11::GetInstance()->GetXI2DeviceList( |
| 80 gfx::GetXDisplay()); |
| 81 for (int i = 0; i < xi_dev_list.count; ++i) { |
| 82 std::string device_name(xi_dev_list[i].name); |
| 83 base::TrimWhitespaceASCII(device_name, base::TRIM_TRAILING, &device_name); |
| 84 if (device_name == kInternalTouchpadName) { |
| 85 if (device_data_manager->IsDeviceEnabled(xi_dev_list[i].deviceid)) { |
| 86 // If the touchpad is already disabled we will do nothing about it. |
| 87 // This will result in doing nothing in the destructor as well since |
| 88 // |touchpad_device_id_| will remain |kDeviceIdNone|. |
| 89 touchpad_device_id_ = xi_dev_list[i].deviceid; |
| 90 device_data_manager->DisableDevice(touchpad_device_id_); |
| 91 Shell::Get()->cursor_manager()->HideCursor(); |
| 92 } |
| 93 } else if (device_name == kCoreKeyboardName) { |
| 94 core_keyboard_device_id_ = xi_dev_list[i].deviceid; |
| 95 device_data_manager->DisableDevice(core_keyboard_device_id_); |
| 96 } |
| 97 } |
| 98 |
| 99 for (const ui::InputDevice& device : |
| 100 device_data_manager->GetKeyboardDevices()) { |
| 101 if (device.type == ui::InputDeviceType::INPUT_DEVICE_INTERNAL) { |
| 102 keyboard_device_id_ = device.id; |
| 103 device_data_manager->DisableDevice(keyboard_device_id_); |
| 104 break; |
| 105 } |
| 106 } |
| 107 } |
| 108 // Allow the accessible keys present on the side of some devices to continue |
| 109 // working. |
| 110 std::unique_ptr<std::set<ui::KeyboardCode>> excepted_keys( |
| 111 new std::set<ui::KeyboardCode>); |
| 112 excepted_keys->insert(ui::VKEY_VOLUME_DOWN); |
| 113 excepted_keys->insert(ui::VKEY_VOLUME_UP); |
| 114 excepted_keys->insert(ui::VKEY_POWER); |
| 115 device_data_manager->SetDisabledKeyboardAllowedKeys(std::move(excepted_keys)); |
| 116 ui::PlatformEventSource::GetInstance()->AddPlatformEventObserver(this); |
| 117 } |
| 118 |
| 119 ScopedDisableInternalMouseAndKeyboardX11:: |
| 120 ~ScopedDisableInternalMouseAndKeyboardX11() { |
| 121 ui::DeviceDataManagerX11* device_data_manager = |
| 122 static_cast<ui::DeviceDataManagerX11*>( |
| 123 ui::DeviceDataManager::GetInstance()); |
| 124 if (touchpad_device_id_ != kDeviceIdNone) { |
| 125 device_data_manager->EnableDevice(touchpad_device_id_); |
| 126 Shell::Get()->cursor_manager()->ShowCursor(); |
| 127 } |
| 128 if (keyboard_device_id_ != kDeviceIdNone) |
| 129 device_data_manager->EnableDevice(keyboard_device_id_); |
| 130 if (core_keyboard_device_id_ != kDeviceIdNone) |
| 131 device_data_manager->EnableDevice(core_keyboard_device_id_); |
| 132 device_data_manager->SetDisabledKeyboardAllowedKeys( |
| 133 std::unique_ptr<std::set<ui::KeyboardCode>>()); |
| 134 ui::PlatformEventSource::GetInstance()->RemovePlatformEventObserver(this); |
| 135 } |
| 136 |
| 137 void ScopedDisableInternalMouseAndKeyboardX11::WillProcessEvent( |
| 138 const ui::PlatformEvent& event) {} |
| 139 |
| 140 void ScopedDisableInternalMouseAndKeyboardX11::DidProcessEvent( |
| 141 const ui::PlatformEvent& event) { |
| 142 if (event->type != GenericEvent) |
| 143 return; |
| 144 XIDeviceEvent* xievent = static_cast<XIDeviceEvent*>(event->xcookie.data); |
| 145 ui::DeviceDataManagerX11* device_data_manager = |
| 146 static_cast<ui::DeviceDataManagerX11*>( |
| 147 ui::DeviceDataManager::GetInstance()); |
| 148 if (xievent->evtype != XI_Motion || |
| 149 device_data_manager->IsFlingEvent(*event) || |
| 150 device_data_manager->IsScrollEvent(*event) || |
| 151 device_data_manager->IsCMTMetricsEvent(*event)) { |
| 152 return; |
| 153 } |
| 154 if (xievent->sourceid == touchpad_device_id_) { |
| 155 // The cursor will have already moved even though the move event will be |
| 156 // blocked. Move the mouse cursor back to its last known location resulting |
| 157 // from an external mouse to prevent the internal touchpad from moving it. |
| 158 SetMouseLocationInScreen(last_mouse_location_); |
| 159 } else { |
| 160 // Track the last location seen from an external mouse event. |
| 161 last_mouse_location_ = GetMouseLocationInScreen(); |
| 162 } |
| 163 } |
| 164 |
| 165 } // namespace ash |
OLD | NEW |