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 "chrome/browser/ui/ash/event_rewriter.h" 6 7 #include <vector> 8 9 #include "ash/shell.h" 10 #include "base/logging.h" 11 #include "base/prefs/pref_service.h" 12 #include "base/strings/string_util.h" 13 #include "chrome/browser/profiles/profile_manager.h" 14 #include "ui/aura/root_window.h" 15 #include "ui/events/event.h" 16 #include "ui/events/event_utils.h" 17 #include "ui/events/keycodes/keyboard_code_conversion.h" 18 19 #if defined(OS_CHROMEOS) 20 #include <X11/extensions/XInput2.h> 21 #include <X11/keysym.h> 22 #include <X11/XF86keysym.h> 23 #include <X11/Xlib.h> 24 25 // Get rid of a macro from Xlib.h that conflicts with OwnershipService class. 26 #undef Status 27 28 #include "ash/wm/window_state.h" 29 #include "base/command_line.h" 30 #include "base/sys_info.h" 31 #include "chrome/browser/chromeos/keyboard_driven_event_rewriter.h" 32 #include "chrome/browser/chromeos/login/login_display_host_impl.h" 33 #include "chrome/browser/chromeos/login/user_manager.h" 34 #include "chrome/browser/chromeos/xinput_hierarchy_changed_event_listener.h" 35 #include "chrome/common/pref_names.h" 36 #include "chromeos/chromeos_switches.h" 37 #include "chromeos/ime/input_method_manager.h" 38 #include "chromeos/ime/xkeyboard.h" 39 #include "ui/base/x/x11_util.h" 40 #include "ui/events/keycodes/keyboard_code_conversion_x.h" 41 #include "ui/views/corewm/window_util.h" 42 #endif 43 44 namespace { 45 46 const int kBadDeviceId = -1; 47 48 #if defined(OS_CHROMEOS) 49 const char kNeo2LayoutId[] = "xkb:de:neo:ger"; 50 const char kCaMultixLayoutId[] = "xkb:ca:multix:fra"; 51 52 // A key code and a flag we should use when a key is remapped to |remap_to|. 53 const struct ModifierRemapping { 54 int remap_to; 55 int flag; 56 unsigned int native_modifier; 57 ui::KeyboardCode keycode; 58 KeySym native_keysyms[4]; // left, right, shift+left, shift+right. 59 } kModifierRemappings[] = { 60 { chromeos::input_method::kSearchKey, 0, Mod4Mask, ui::VKEY_LWIN, 61 { XK_Super_L, XK_Super_L, XK_Super_L, XK_Super_L }}, 62 { chromeos::input_method::kControlKey, ui::EF_CONTROL_DOWN, ControlMask, 63 ui::VKEY_CONTROL, 64 { XK_Control_L, XK_Control_R, XK_Control_L, XK_Control_R }}, 65 { chromeos::input_method::kAltKey, ui::EF_ALT_DOWN, Mod1Mask, 66 ui::VKEY_MENU, { XK_Alt_L, XK_Alt_R, XK_Meta_L, XK_Meta_R }}, 67 { chromeos::input_method::kVoidKey, 0, 0U, ui::VKEY_UNKNOWN, 68 { XK_VoidSymbol, XK_VoidSymbol, XK_VoidSymbol, XK_VoidSymbol }}, 69 { chromeos::input_method::kCapsLockKey, 0, 0U, ui::VKEY_CAPITAL, 70 { XK_Caps_Lock, XK_Caps_Lock, XK_Caps_Lock, XK_Caps_Lock }}, 71 { chromeos::input_method::kEscapeKey, 0, 0U, ui::VKEY_ESCAPE, 72 { XK_Escape, XK_Escape, XK_Escape, XK_Escape }}, 73 }; 74 75 const ModifierRemapping* kModifierRemappingCtrl = &kModifierRemappings[1]; 76 77 // A structure for converting |native_modifier| to a pair of |flag| and 78 // |pref_name|. 79 const struct ModifierFlagToPrefName { 80 unsigned int native_modifier; 81 int flag; 82 const char* pref_name; 83 } kModifierFlagToPrefName[] = { 84 // TODO(yusukes): When the device has a Chrome keyboard (i.e. the one without 85 // Caps Lock), we should not check kLanguageRemapCapsLockKeyTo. 86 { Mod3Mask, 0, prefs::kLanguageRemapCapsLockKeyTo }, 87 { Mod4Mask, 0, prefs::kLanguageRemapSearchKeyTo }, 88 { ControlMask, ui::EF_CONTROL_DOWN, prefs::kLanguageRemapControlKeyTo }, 89 { Mod1Mask, ui::EF_ALT_DOWN, prefs::kLanguageRemapAltKeyTo }, 90 { Mod2Mask, 0, prefs::kLanguageRemapDiamondKeyTo }, 91 }; 92 93 // Gets a remapped key for |pref_name| key. For example, to find out which 94 // key Search is currently remapped to, call the function with 95 // prefs::kLanguageRemapSearchKeyTo. 96 const ModifierRemapping* GetRemappedKey(const std::string& pref_name, 97 const PrefService& pref_service) { 98 if (!pref_service.FindPreference(pref_name.c_str())) 99 return NULL; // The |pref_name| hasn't been registered. On login screen? 100 const int value = pref_service.GetInteger(pref_name.c_str()); 101 for (size_t i = 0; i < arraysize(kModifierRemappings); ++i) { 102 if (value == kModifierRemappings[i].remap_to) 103 return &kModifierRemappings[i]; 104 } 105 return NULL; 106 } 107 108 bool IsRight(KeySym native_keysym) { 109 switch (native_keysym) { 110 case XK_Alt_R: 111 case XK_Control_R: 112 case XK_Hyper_R: 113 case XK_Meta_R: 114 case XK_Shift_R: 115 case XK_Super_R: 116 return true; 117 default: 118 break; 119 } 120 return false; 121 } 122 123 bool HasDiamondKey() { 124 return CommandLine::ForCurrentProcess()->HasSwitch( 125 chromeos::switches::kHasChromeOSDiamondKey); 126 } 127 128 bool IsMod3UsedByCurrentInputMethod() { 129 // Since both German Neo2 XKB layout and Caps Lock depend on Mod3Mask, 130 // it's not possible to make both features work. For now, we don't remap 131 // Mod3Mask when Neo2 is in use. 132 // TODO(yusukes): Remove the restriction. 133 chromeos::input_method::InputMethodManager* manager = 134 chromeos::input_method::InputMethodManager::Get(); 135 return manager->GetCurrentInputMethod().id() == kNeo2LayoutId || 136 manager->GetCurrentInputMethod().id() == kCaMultixLayoutId; 137 } 138 139 #endif // defined(OS_CHROMEOS) 140 141 } // namespace 142 143 EventRewriter::EventRewriter() 144 : last_device_id_(kBadDeviceId), 145 #if defined(OS_CHROMEOS) 146 xkeyboard_for_testing_(NULL), 147 keyboard_driven_event_rewriter_( 148 new chromeos::KeyboardDrivenEventRewriter), 149 #endif 150 pref_service_for_testing_(NULL) { 151 // The ash shell isn't instantiated for our unit tests. 152 if (ash::Shell::HasInstance()) { 153 ash::Shell::GetPrimaryRootWindow()->GetDispatcher()-> 154 AddRootWindowObserver(this); 155 } 156 #if defined(OS_CHROMEOS) 157 if (base::SysInfo::IsRunningOnChromeOS()) { 158 chromeos::XInputHierarchyChangedEventListener::GetInstance() 159 ->AddObserver(this); 160 } 161 RefreshKeycodes(); 162 #endif 163 } 164 165 EventRewriter::~EventRewriter() { 166 if (ash::Shell::HasInstance()) { 167 ash::Shell::GetPrimaryRootWindow()->GetDispatcher()-> 168 RemoveRootWindowObserver(this); 169 } 170 #if defined(OS_CHROMEOS) 171 if (base::SysInfo::IsRunningOnChromeOS()) { 172 chromeos::XInputHierarchyChangedEventListener::GetInstance() 173 ->RemoveObserver(this); 174 } 175 #endif 176 } 177 178 EventRewriter::DeviceType EventRewriter::DeviceAddedForTesting( 179 int device_id, 180 const std::string& device_name) { 181 return DeviceAddedInternal(device_id, device_name); 182 } 183 184 // static 185 EventRewriter::DeviceType EventRewriter::GetDeviceType( 186 const std::string& device_name) { 187 std::vector<std::string> tokens; 188 Tokenize(device_name, " .", &tokens); 189 190 // If the |device_name| contains the two words, "apple" and "keyboard", treat 191 // it as an Apple keyboard. 192 bool found_apple = false; 193 bool found_keyboard = false; 194 for (size_t i = 0; i < tokens.size(); ++i) { 195 if (!found_apple && LowerCaseEqualsASCII(tokens[i], "apple")) 196 found_apple = true; 197 if (!found_keyboard && LowerCaseEqualsASCII(tokens[i], "keyboard")) 198 found_keyboard = true; 199 if (found_apple && found_keyboard) 200 return kDeviceAppleKeyboard; 201 } 202 203 return kDeviceUnknown; 204 } 205 206 void EventRewriter::RewriteForTesting(ui::KeyEvent* event) { 207 Rewrite(event); 208 } 209 210 ash::EventRewriterDelegate::Action EventRewriter::RewriteOrFilterKeyEvent( 211 ui::KeyEvent* event) { 212 if (event->HasNativeEvent()) 213 Rewrite(event); 214 return ash::EventRewriterDelegate::ACTION_REWRITE_EVENT; 215 } 216 217 ash::EventRewriterDelegate::Action EventRewriter::RewriteOrFilterLocatedEvent( 218 ui::LocatedEvent* event) { 219 if (event->HasNativeEvent()) 220 RewriteLocatedEvent(event); 221 return ash::EventRewriterDelegate::ACTION_REWRITE_EVENT; 222 } 223 224 void EventRewriter::OnKeyboardMappingChanged(const aura::RootWindow* root) { 225 #if defined(OS_CHROMEOS) 226 RefreshKeycodes(); 227 #endif 228 } 229 230 #if defined(OS_CHROMEOS) 231 void EventRewriter::DeviceAdded(int device_id) { 232 DCHECK_NE(XIAllDevices, device_id); 233 DCHECK_NE(XIAllMasterDevices, device_id); 234 if (device_id == XIAllDevices || device_id == XIAllMasterDevices) { 235 LOG(ERROR) << "Unexpected device_id passed: " << device_id; 236 return; 237 } 238 239 int ndevices_return = 0; 240 XIDeviceInfo* device_info = XIQueryDevice(gfx::GetXDisplay(), 241 device_id, 242 &ndevices_return); 243 244 // Since |device_id| is neither XIAllDevices nor XIAllMasterDevices, 245 // the number of devices found should be either 0 (not found) or 1. 246 if (!device_info) { 247 LOG(ERROR) << "XIQueryDevice: Device ID " << device_id << " is unknown."; 248 return; 249 } 250 251 DCHECK_EQ(1, ndevices_return); 252 for (int i = 0; i < ndevices_return; ++i) { 253 DCHECK_EQ(device_id, device_info[i].deviceid); // see the comment above. 254 DCHECK(device_info[i].name); 255 DeviceAddedInternal(device_info[i].deviceid, device_info[i].name); 256 } 257 258 XIFreeDeviceInfo(device_info); 259 } 260 261 void EventRewriter::DeviceRemoved(int device_id) { 262 device_id_to_type_.erase(device_id); 263 } 264 265 void EventRewriter::DeviceKeyPressedOrReleased(int device_id) { 266 std::map<int, DeviceType>::const_iterator iter = 267 device_id_to_type_.find(device_id); 268 if (iter == device_id_to_type_.end()) { 269 // |device_id| is unknown. This means the device was connected before 270 // booting the OS. Query the name of the device and add it to the map. 271 DeviceAdded(device_id); 272 } 273 274 last_device_id_ = device_id; 275 } 276 277 void EventRewriter::RefreshKeycodes() { 278 keysym_to_keycode_map_.clear(); 279 } 280 281 KeyCode EventRewriter::NativeKeySymToNativeKeycode(KeySym keysym) { 282 if (keysym_to_keycode_map_.count(keysym)) 283 return keysym_to_keycode_map_[keysym]; 284 285 XDisplay* display = gfx::GetXDisplay(); 286 KeyCode keycode = XKeysymToKeycode(display, keysym); 287 keysym_to_keycode_map_[keysym] = keycode; 288 return keycode; 289 } 290 291 bool EventRewriter::TopRowKeysAreFunctionKeys(ui::KeyEvent* event) const { 292 const PrefService* prefs = GetPrefService(); 293 if (prefs && 294 prefs->FindPreference(prefs::kLanguageSendFunctionKeys) && 295 prefs->GetBoolean(prefs::kLanguageSendFunctionKeys)) 296 return true; 297 298 aura::Window* target = static_cast<aura::Window*>(event->target()); 299 if (!target) 300 return false; 301 aura::Window* top_level = views::corewm::GetToplevelWindow(target); 302 return top_level && 303 ash::wm::GetWindowState(top_level)->top_row_keys_are_function_keys(); 304 } 305 306 bool EventRewriter::RewriteWithKeyboardRemappingsByKeySym( 307 const KeyboardRemapping* remappings, 308 size_t num_remappings, 309 KeySym keysym, 310 unsigned int native_mods, 311 unsigned int mods, 312 KeySym* remapped_native_keysym, 313 unsigned int* remapped_native_mods, 314 ui::KeyboardCode* remapped_keycode, 315 unsigned int* remapped_mods) { 316 for (size_t i = 0; i < num_remappings; ++i) { 317 const KeyboardRemapping& map = remappings[i]; 318 319 if (keysym != map.input_keysym) 320 continue; 321 unsigned int matched_mods = native_mods & map.input_native_mods; 322 if (matched_mods != map.input_native_mods) 323 continue; 324 325 *remapped_native_keysym = map.output_keysym; 326 *remapped_keycode = map.output_keycode; 327 *remapped_native_mods = (native_mods & ~map.input_native_mods) | 328 map.output_native_mods; 329 *remapped_mods = (mods & ~map.input_mods) | map.output_mods; 330 return true; 331 } 332 333 return false; 334 } 335 336 bool EventRewriter::RewriteWithKeyboardRemappingsByKeyCode( 337 const KeyboardRemapping* remappings, 338 size_t num_remappings, 339 KeyCode keycode, 340 unsigned int native_mods, 341 unsigned int mods, 342 KeySym* remapped_native_keysym, 343 unsigned int* remapped_native_mods, 344 ui::KeyboardCode* remapped_keycode, 345 unsigned int* remapped_mods) { 346 for (size_t i = 0; i < num_remappings; ++i) { 347 const KeyboardRemapping& map = remappings[i]; 348 349 KeyCode input_keycode = NativeKeySymToNativeKeycode(map.input_keysym); 350 if (keycode != input_keycode) 351 continue; 352 unsigned int matched_mods = native_mods & map.input_native_mods; 353 if (matched_mods != map.input_native_mods) 354 continue; 355 356 *remapped_native_keysym = map.output_keysym; 357 *remapped_keycode = map.output_keycode; 358 *remapped_native_mods = (native_mods & ~map.input_native_mods) | 359 map.output_native_mods; 360 *remapped_mods = (mods & ~map.input_mods) | map.output_mods; 361 return true; 362 } 363 364 return false; 365 } 366 #endif // defined(OS_CHROMEOS) 367 368 const PrefService* EventRewriter::GetPrefService() const { 369 if (pref_service_for_testing_) 370 return pref_service_for_testing_; 371 Profile* profile = ProfileManager::GetActiveUserProfile(); 372 return profile ? profile->GetPrefs() : NULL; 373 } 374 375 void EventRewriter::Rewrite(ui::KeyEvent* event) { 376 #if defined(OS_CHROMEOS) 377 // Do not rewrite an event sent by ui_controls::SendKeyPress(). See 378 // crbug.com/136465. 379 if (event->native_event()->xkey.send_event) 380 return; 381 382 // Keyboard driven rewriting happen first. Skip further processing if event is 383 // changed. 384 if (keyboard_driven_event_rewriter_->RewriteIfKeyboardDrivenOnLoginScreen( 385 event)) { 386 return; 387 } 388 #endif 389 RewriteModifiers(event); 390 RewriteNumPadKeys(event); 391 RewriteExtendedKeys(event); 392 RewriteFunctionKeys(event); 393 } 394 395 bool EventRewriter::IsAppleKeyboard() const { 396 if (last_device_id_ == kBadDeviceId) 397 return false; 398 399 // Check which device generated |event|. 400 std::map<int, DeviceType>::const_iterator iter = 401 device_id_to_type_.find(last_device_id_); 402 if (iter == device_id_to_type_.end()) { 403 LOG(ERROR) << "Device ID " << last_device_id_ << " is unknown."; 404 return false; 405 } 406 407 const DeviceType type = iter->second; 408 return type == kDeviceAppleKeyboard; 409 } 410 411 void EventRewriter::GetRemappedModifierMasks( 412 int original_flags, 413 unsigned int original_native_modifiers, 414 int* remapped_flags, 415 unsigned int* remapped_native_modifiers) const { 416 #if defined(OS_CHROMEOS) 417 // TODO(glotov): remove the following condition when we do not restart chrome 418 // when user logs in as guest. See Rewrite() for details. 419 if (chromeos::UserManager::Get()->IsLoggedInAsGuest() && 420 chromeos::LoginDisplayHostImpl::default_host()) { 421 return; 422 } 423 424 const PrefService* pref_service = GetPrefService(); 425 if (!pref_service) 426 return; 427 428 // When a diamond key is not available, a Mod2Mask should not treated as a 429 // configurable modifier because Mod2Mask may be worked as NumLock mask. 430 // (cf. http://crbug.com/173956) 431 const bool skip_mod2 = !HasDiamondKey(); 432 // If Mod3 is used by the current input method, don't allow the CapsLock 433 // pref to remap it, or the keyboard behavior will be broken. 434 const bool skip_mod3 = IsMod3UsedByCurrentInputMethod(); 435 436 for (size_t i = 0; i < arraysize(kModifierFlagToPrefName); ++i) { 437 if ((skip_mod2 && kModifierFlagToPrefName[i].native_modifier == Mod2Mask) || 438 (skip_mod3 && kModifierFlagToPrefName[i].native_modifier == Mod3Mask)) { 439 continue; 440 } 441 if (original_native_modifiers & 442 kModifierFlagToPrefName[i].native_modifier) { 443 const ModifierRemapping* remapped_key = 444 GetRemappedKey(kModifierFlagToPrefName[i].pref_name, *pref_service); 445 // Rewrite Command-L/R key presses on an Apple keyboard to Control-L/R. 446 if (IsAppleKeyboard() && 447 (kModifierFlagToPrefName[i].native_modifier == Mod4Mask)) { 448 remapped_key = kModifierRemappingCtrl; 449 } 450 if (remapped_key) { 451 *remapped_flags |= remapped_key->flag; 452 *remapped_native_modifiers |= remapped_key->native_modifier; 453 } else { 454 *remapped_flags |= kModifierFlagToPrefName[i].flag; 455 *remapped_native_modifiers |= 456 kModifierFlagToPrefName[i].native_modifier; 457 } 458 } 459 } 460 461 *remapped_flags = 462 (original_flags & ~(ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN)) | 463 *remapped_flags; 464 465 unsigned int native_mask = Mod4Mask | ControlMask | Mod1Mask; 466 if (!skip_mod2) 467 native_mask |= Mod2Mask; 468 if (!skip_mod3) 469 native_mask |= Mod3Mask; 470 *remapped_native_modifiers = 471 (original_native_modifiers & ~native_mask) | 472 *remapped_native_modifiers; 473 #endif 474 } 475 476 bool EventRewriter::RewriteModifiers(ui::KeyEvent* event) { 477 #if defined(OS_CHROMEOS) 478 // Do nothing if we have just logged in as guest but have not restarted chrome 479 // process yet (so we are still on the login screen). In this situations we 480 // have no user profile so can not do anything useful. 481 // Note that currently, unlike other accounts, when user logs in as guest, we 482 // restart chrome process. In future this is to be changed. 483 // TODO(glotov): remove the following condition when we do not restart chrome 484 // when user logs in as guest. 485 if (chromeos::UserManager::Get()->IsLoggedInAsGuest() && 486 chromeos::LoginDisplayHostImpl::default_host()) 487 return false; 488 489 const PrefService* pref_service = GetPrefService(); 490 if (!pref_service) 491 return false; 492 493 DCHECK_EQ(chromeos::input_method::kControlKey, 494 kModifierRemappingCtrl->remap_to); 495 496 XEvent* xev = event->native_event(); 497 XKeyEvent* xkey = &(xev->xkey); 498 KeySym keysym = XLookupKeysym(xkey, 0); 499 500 ui::KeyboardCode remapped_keycode = event->key_code(); 501 KeyCode remapped_native_keycode = xkey->keycode; 502 503 // First, remap |keysym|. 504 const ModifierRemapping* remapped_key = NULL; 505 switch (keysym) { 506 // On Chrome OS, XF86XK_Launch6 (F15) with Mod2Mask is sent when Diamond 507 // key is pressed. 508 case XF86XK_Launch6: 509 // When diamond key is not available, the configuration UI for Diamond 510 // key is not shown. Therefore, ignore the kLanguageRemapDiamondKeyTo 511 // syncable pref. 512 if (HasDiamondKey()) 513 remapped_key = 514 GetRemappedKey(prefs::kLanguageRemapDiamondKeyTo, *pref_service); 515 // Default behavior is Ctrl key. 516 if (!remapped_key) 517 remapped_key = kModifierRemappingCtrl; 518 break; 519 // On Chrome OS, XF86XK_Launch7 (F16) with Mod3Mask is sent when Caps Lock 520 // is pressed (with one exception: when IsMod3UsedByCurrentInputMethod() is 521 // true, the key generates XK_ISO_Level3_Shift with Mod3Mask, not 522 // XF86XK_Launch7). 523 case XF86XK_Launch7: 524 remapped_key = 525 GetRemappedKey(prefs::kLanguageRemapCapsLockKeyTo, *pref_service); 526 break; 527 case XK_Super_L: 528 case XK_Super_R: 529 // Rewrite Command-L/R key presses on an Apple keyboard to Control-L/R. 530 if (IsAppleKeyboard()) 531 remapped_key = kModifierRemappingCtrl; 532 else 533 remapped_key = 534 GetRemappedKey(prefs::kLanguageRemapSearchKeyTo, *pref_service); 535 // Default behavior is Super key, hence don't remap the event if the pref 536 // is unavailable. 537 break; 538 case XK_Control_L: 539 case XK_Control_R: 540 remapped_key = 541 GetRemappedKey(prefs::kLanguageRemapControlKeyTo, *pref_service); 542 break; 543 case XK_Alt_L: 544 case XK_Alt_R: 545 case XK_Meta_L: 546 case XK_Meta_R: 547 remapped_key = 548 GetRemappedKey(prefs::kLanguageRemapAltKeyTo, *pref_service); 549 break; 550 default: 551 break; 552 } 553 554 if (remapped_key) { 555 remapped_keycode = remapped_key->keycode; 556 const size_t level = (event->IsShiftDown() ? (1 << 1) : 0) + 557 (IsRight(keysym) ? (1 << 0) : 0); 558 const KeySym native_keysym = remapped_key->native_keysyms[level]; 559 remapped_native_keycode = NativeKeySymToNativeKeycode(native_keysym); 560 } 561 562 // Next, remap modifier bits. 563 int remapped_flags = 0; 564 unsigned int remapped_native_modifiers = 0U; 565 GetRemappedModifierMasks(event->flags(), xkey->state, 566 &remapped_flags, &remapped_native_modifiers); 567 568 // Toggle Caps Lock if the remapped key is ui::VKEY_CAPITAL, but do nothing if 569 // the original key is ui::VKEY_CAPITAL (i.e. a Caps Lock key on an external 570 // keyboard is pressed) since X can handle that case. 571 if ((event->type() == ui::ET_KEY_PRESSED) && 572 (event->key_code() != ui::VKEY_CAPITAL) && 573 (remapped_keycode == ui::VKEY_CAPITAL)) { 574 chromeos::input_method::XKeyboard* xkeyboard = xkeyboard_for_testing_ ? 575 xkeyboard_for_testing_ : 576 chromeos::input_method::InputMethodManager::Get()->GetXKeyboard(); 577 xkeyboard->SetCapsLockEnabled(!xkeyboard->CapsLockIsEnabled()); 578 } 579 580 OverwriteEvent(event, 581 remapped_native_keycode, remapped_native_modifiers, 582 remapped_keycode, remapped_flags); 583 return true; 584 #else 585 // TODO(yusukes): Support Ash on other platforms if needed. 586 return false; 587 #endif 588 } 589 590 bool EventRewriter::RewriteNumPadKeys(ui::KeyEvent* event) { 591 bool rewritten = false; 592 #if defined(OS_CHROMEOS) 593 XEvent* xev = event->native_event(); 594 XKeyEvent* xkey = &(xev->xkey); 595 596 const KeySym keysym = XLookupKeysym(xkey, 0); 597 switch (keysym) { 598 case XK_KP_Insert: 599 OverwriteEvent(event, NativeKeySymToNativeKeycode(XK_KP_0), 600 xkey->state | Mod2Mask, 601 ui::VKEY_NUMPAD0, event->flags()); 602 rewritten = true; 603 break; 604 case XK_KP_Delete: 605 OverwriteEvent(event, NativeKeySymToNativeKeycode(XK_KP_Decimal), 606 xkey->state | Mod2Mask, 607 ui::VKEY_DECIMAL, event->flags()); 608 rewritten = true; 609 break; 610 case XK_KP_End: 611 OverwriteEvent(event, NativeKeySymToNativeKeycode(XK_KP_1), 612 xkey->state | Mod2Mask, 613 ui::VKEY_NUMPAD1, event->flags()); 614 rewritten = true; 615 break; 616 case XK_KP_Down: 617 OverwriteEvent(event, NativeKeySymToNativeKeycode(XK_KP_2), 618 xkey->state | Mod2Mask, 619 ui::VKEY_NUMPAD2, event->flags()); 620 rewritten = true; 621 break; 622 case XK_KP_Next: 623 OverwriteEvent(event, NativeKeySymToNativeKeycode(XK_KP_3), 624 xkey->state | Mod2Mask, 625 ui::VKEY_NUMPAD3, event->flags()); 626 rewritten = true; 627 break; 628 case XK_KP_Left: 629 OverwriteEvent(event, NativeKeySymToNativeKeycode(XK_KP_4), 630 xkey->state | Mod2Mask, 631 ui::VKEY_NUMPAD4, event->flags()); 632 rewritten = true; 633 break; 634 case XK_KP_Begin: 635 OverwriteEvent(event, NativeKeySymToNativeKeycode(XK_KP_5), 636 xkey->state | Mod2Mask, 637 ui::VKEY_NUMPAD5, event->flags()); 638 rewritten = true; 639 break; 640 case XK_KP_Right: 641 OverwriteEvent(event, NativeKeySymToNativeKeycode(XK_KP_6), 642 xkey->state | Mod2Mask, 643 ui::VKEY_NUMPAD6, event->flags()); 644 rewritten = true; 645 break; 646 case XK_KP_Home: 647 OverwriteEvent(event, NativeKeySymToNativeKeycode(XK_KP_7), 648 xkey->state | Mod2Mask, 649 ui::VKEY_NUMPAD7, event->flags()); 650 rewritten = true; 651 break; 652 case XK_KP_Up: 653 OverwriteEvent(event, NativeKeySymToNativeKeycode(XK_KP_8), 654 xkey->state | Mod2Mask, 655 ui::VKEY_NUMPAD8, event->flags()); 656 rewritten = true; 657 break; 658 case XK_KP_Prior: 659 OverwriteEvent(event, NativeKeySymToNativeKeycode(XK_KP_9), 660 xkey->state | Mod2Mask, 661 ui::VKEY_NUMPAD9, event->flags()); 662 rewritten = true; 663 break; 664 case XK_KP_Divide: 665 case XK_KP_Multiply: 666 case XK_KP_Subtract: 667 case XK_KP_Add: 668 case XK_KP_Enter: 669 // Add Mod2Mask for consistency. 670 OverwriteEvent(event, xkey->keycode, xkey->state | Mod2Mask, 671 event->key_code(), event->flags()); 672 rewritten = true; 673 break; 674 default: 675 break; 676 } 677 #else 678 // TODO(yusukes): Support Ash on other platforms if needed. 679 #endif 680 return rewritten; 681 } 682 683 bool EventRewriter::RewriteExtendedKeys(ui::KeyEvent* event) { 684 #if defined(OS_CHROMEOS) 685 XEvent* xev = event->native_event(); 686 XKeyEvent* xkey = &(xev->xkey); 687 const KeySym keysym = XLookupKeysym(xkey, 0); 688 689 KeySym remapped_native_keysym = 0; 690 unsigned int remapped_native_mods = 0; 691 ui::KeyboardCode remapped_keycode = ui::VKEY_UNKNOWN; 692 unsigned int remapped_mods = 0; 693 694 if (xkey->state & Mod4Mask) { 695 // Allow Search to avoid rewriting extended keys. 696 static const KeyboardRemapping kAvoidRemappings[] = { 697 { // Alt+Backspace 698 XK_BackSpace, 699 ui::EF_ALT_DOWN, Mod1Mask | Mod4Mask, 700 XK_BackSpace, ui::VKEY_BACK, 701 ui::EF_ALT_DOWN, Mod1Mask, 702 }, 703 { // Control+Alt+Up 704 XK_Up, 705 ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN, 706 Mod1Mask | ControlMask | Mod4Mask, 707 XK_Up, ui::VKEY_UP, 708 ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN, Mod1Mask | ControlMask, 709 }, 710 { // Alt+Up 711 XK_Up, 712 ui::EF_ALT_DOWN, Mod1Mask | Mod4Mask, 713 XK_Up, ui::VKEY_UP, 714 ui::EF_ALT_DOWN, Mod1Mask, 715 }, 716 { // Control+Alt+Down 717 XK_Down, 718 ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN, 719 Mod1Mask | ControlMask | Mod4Mask, 720 XK_Down, ui::VKEY_DOWN, 721 ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN, Mod1Mask | ControlMask, 722 }, 723 { // Alt+Down 724 XK_Down, 725 ui::EF_ALT_DOWN, Mod1Mask | Mod4Mask, 726 XK_Down, ui::VKEY_DOWN, 727 ui::EF_ALT_DOWN, Mod1Mask, 728 } 729 }; 730 731 RewriteWithKeyboardRemappingsByKeySym(kAvoidRemappings, 732 arraysize(kAvoidRemappings), 733 keysym, 734 xkey->state, 735 event->flags(), 736 &remapped_native_keysym, 737 &remapped_native_mods, 738 &remapped_keycode, 739 &remapped_mods); 740 } 741 742 if (remapped_keycode == ui::VKEY_UNKNOWN) { 743 static const KeyboardRemapping kSearchRemappings[] = { 744 { // Search+BackSpace -> Delete 745 XK_BackSpace, 746 0, Mod4Mask, 747 XK_Delete, ui::VKEY_DELETE, 748 0, 0 749 }, 750 { // Search+Left -> Home 751 XK_Left, 752 0, Mod4Mask, 753 XK_Home, ui::VKEY_HOME, 754 0, 0 755 }, 756 { // Search+Up -> Prior (aka PageUp) 757 XK_Up, 758 0, Mod4Mask, 759 XK_Prior, ui::VKEY_PRIOR, 760 0, 0 761 }, 762 { // Search+Right -> End 763 XK_Right, 764 0, Mod4Mask, 765 XK_End, ui::VKEY_END, 766 0, 0 767 }, 768 { // Search+Down -> Next (aka PageDown) 769 XK_Down, 770 0, Mod4Mask, 771 XK_Next, ui::VKEY_NEXT, 772 0, 0 773 }, 774 { // Search+Period -> Insert 775 XK_period, 776 0, Mod4Mask, 777 XK_Insert, ui::VKEY_INSERT, 778 0, 0 779 } 780 }; 781 782 RewriteWithKeyboardRemappingsByKeySym(kSearchRemappings, 783 arraysize(kSearchRemappings), 784 keysym, 785 xkey->state, 786 event->flags(), 787 &remapped_native_keysym, 788 &remapped_native_mods, 789 &remapped_keycode, 790 &remapped_mods); 791 } 792 793 if (remapped_keycode == ui::VKEY_UNKNOWN) { 794 static const KeyboardRemapping kNonSearchRemappings[] = { 795 { // Alt+BackSpace -> Delete 796 XK_BackSpace, 797 ui::EF_ALT_DOWN, Mod1Mask, 798 XK_Delete, ui::VKEY_DELETE, 799 0, 0 800 }, 801 { // Control+Alt+Up -> Home 802 XK_Up, 803 ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN, Mod1Mask | ControlMask, 804 XK_Home, ui::VKEY_HOME, 805 0, 0 806 }, 807 { // Alt+Up -> Prior (aka PageUp) 808 XK_Up, 809 ui::EF_ALT_DOWN, Mod1Mask, 810 XK_Prior, ui::VKEY_PRIOR, 811 0, 0 812 }, 813 { // Control+Alt+Down -> End 814 XK_Down, 815 ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN, Mod1Mask | ControlMask, 816 XK_End, ui::VKEY_END, 817 0, 0 818 }, 819 { // Alt+Down -> Next (aka PageDown) 820 XK_Down, 821 ui::EF_ALT_DOWN, Mod1Mask, 822 XK_Next, ui::VKEY_NEXT, 823 0, 0 824 } 825 }; 826 827 RewriteWithKeyboardRemappingsByKeySym(kNonSearchRemappings, 828 arraysize(kNonSearchRemappings), 829 keysym, 830 xkey->state, 831 event->flags(), 832 &remapped_native_keysym, 833 &remapped_native_mods, 834 &remapped_keycode, 835 &remapped_mods); 836 } 837 838 if (remapped_keycode == ui::VKEY_UNKNOWN) 839 return false; 840 841 OverwriteEvent(event, 842 NativeKeySymToNativeKeycode(remapped_native_keysym), 843 remapped_native_mods, 844 remapped_keycode, 845 remapped_mods); 846 return true; 847 #else 848 // TODO(yusukes): Support Ash on other platforms if needed. 849 return false; 850 #endif 851 } 852 853 bool EventRewriter::RewriteFunctionKeys(ui::KeyEvent* event) { 854 #if defined(OS_CHROMEOS) 855 XEvent* xev = event->native_event(); 856 XKeyEvent* xkey = &(xev->xkey); 857 const KeySym keysym = XLookupKeysym(xkey, 0); 858 859 KeySym remapped_native_keysym = 0; 860 unsigned int remapped_native_mods = 0; 861 ui::KeyboardCode remapped_keycode = ui::VKEY_UNKNOWN; 862 unsigned int remapped_mods = 0; 863 864 // By default the top row (F1-F12) keys are special keys for back, forward, 865 // brightness, volume, etc. However, windows for v2 apps can optionally 866 // request raw function keys for these keys. 867 bool top_row_keys_are_special_keys = !TopRowKeysAreFunctionKeys(event); 868 869 if ((xkey->state & Mod4Mask) && top_row_keys_are_special_keys) { 870 // Allow Search to avoid rewriting F1-F12. 871 static const KeyboardRemapping kFkeysToFkeys[] = { 872 { XK_F1, 0, Mod4Mask, XK_F1, ui::VKEY_F1, }, 873 { XK_F2, 0, Mod4Mask, XK_F2, ui::VKEY_F2, }, 874 { XK_F3, 0, Mod4Mask, XK_F3, ui::VKEY_F3, }, 875 { XK_F4, 0, Mod4Mask, XK_F4, ui::VKEY_F4, }, 876 { XK_F5, 0, Mod4Mask, XK_F5, ui::VKEY_F5, }, 877 { XK_F6, 0, Mod4Mask, XK_F6, ui::VKEY_F6, }, 878 { XK_F7, 0, Mod4Mask, XK_F7, ui::VKEY_F7, }, 879 { XK_F8, 0, Mod4Mask, XK_F8, ui::VKEY_F8, }, 880 { XK_F9, 0, Mod4Mask, XK_F9, ui::VKEY_F9, }, 881 { XK_F10, 0, Mod4Mask, XK_F10, ui::VKEY_F10, }, 882 { XK_F11, 0, Mod4Mask, XK_F11, ui::VKEY_F11, }, 883 { XK_F12, 0, Mod4Mask, XK_F12, ui::VKEY_F12, }, 884 }; 885 886 RewriteWithKeyboardRemappingsByKeySym(kFkeysToFkeys, 887 arraysize(kFkeysToFkeys), 888 keysym, 889 xkey->state, 890 event->flags(), 891 &remapped_native_keysym, 892 &remapped_native_mods, 893 &remapped_keycode, 894 &remapped_mods); 895 } 896 897 if (remapped_keycode == ui::VKEY_UNKNOWN) { 898 static const KeyboardRemapping kFkeysToSpecialKeys[] = { 899 { XK_F1, 0, 0, XF86XK_Back, ui::VKEY_BROWSER_BACK, 0, 0 }, 900 { XK_F2, 0, 0, XF86XK_Forward, ui::VKEY_BROWSER_FORWARD, 0, 0 }, 901 { XK_F3, 0, 0, XF86XK_Reload, ui::VKEY_BROWSER_REFRESH, 0, 0 }, 902 { XK_F4, 0, 0, XF86XK_LaunchB, ui::VKEY_MEDIA_LAUNCH_APP2, 0, 0 }, 903 { XK_F5, 0, 0, XF86XK_LaunchA, ui::VKEY_MEDIA_LAUNCH_APP1, 0, 0 }, 904 { XK_F6, 0, 0, XF86XK_MonBrightnessDown, ui::VKEY_BRIGHTNESS_DOWN, 0, 0 }, 905 { XK_F7, 0, 0, XF86XK_MonBrightnessUp, ui::VKEY_BRIGHTNESS_UP, 0, 0 }, 906 { XK_F8, 0, 0, XF86XK_AudioMute, ui::VKEY_VOLUME_MUTE, 0, 0 }, 907 { XK_F9, 0, 0, XF86XK_AudioLowerVolume, ui::VKEY_VOLUME_DOWN, 0, 0 }, 908 { XK_F10, 0, 0, XF86XK_AudioRaiseVolume, ui::VKEY_VOLUME_UP, 0, 0 }, 909 }; 910 911 if (top_row_keys_are_special_keys) { 912 // Rewrite the F1-F12 keys on a Chromebook keyboard to special keys. 913 RewriteWithKeyboardRemappingsByKeySym(kFkeysToSpecialKeys, 914 arraysize(kFkeysToSpecialKeys), 915 keysym, 916 xkey->state, 917 event->flags(), 918 &remapped_native_keysym, 919 &remapped_native_mods, 920 &remapped_keycode, 921 &remapped_mods); 922 } else if (xkey->state & Mod4Mask) { 923 // Use Search + F1-F12 for the special keys. 924 RewriteWithKeyboardRemappingsByKeySym(kFkeysToSpecialKeys, 925 arraysize(kFkeysToSpecialKeys), 926 keysym, 927 xkey->state & !Mod4Mask, 928 event->flags(), 929 &remapped_native_keysym, 930 &remapped_native_mods, 931 &remapped_keycode, 932 &remapped_mods); 933 } 934 } 935 936 if (remapped_keycode == ui::VKEY_UNKNOWN && xkey->state & Mod4Mask) { 937 // Remap Search+<number> to F<number>. 938 // We check the keycode here instead of the keysym, as these keys have 939 // different keysyms when modifiers are pressed, such as shift. 940 941 // TODO(danakj): On some i18n keyboards, these choices will be bad and we 942 // should make layout-specific choices here. For eg. on a french keyboard 943 // "-" and "6" are the same key, so F11 will not be accessible. 944 static const KeyboardRemapping kNumberKeysToFkeys[] = { 945 { XK_1, 0, Mod4Mask, XK_F1, ui::VKEY_F1, 0, 0 }, 946 { XK_2, 0, Mod4Mask, XK_F2, ui::VKEY_F2, 0, 0 }, 947 { XK_3, 0, Mod4Mask, XK_F3, ui::VKEY_F3, 0, 0 }, 948 { XK_4, 0, Mod4Mask, XK_F4, ui::VKEY_F4, 0, 0 }, 949 { XK_5, 0, Mod4Mask, XK_F5, ui::VKEY_F5, 0, 0 }, 950 { XK_6, 0, Mod4Mask, XK_F6, ui::VKEY_F6, 0, 0 }, 951 { XK_7, 0, Mod4Mask, XK_F7, ui::VKEY_F7, 0, 0 }, 952 { XK_8, 0, Mod4Mask, XK_F8, ui::VKEY_F8, 0, 0 }, 953 { XK_9, 0, Mod4Mask, XK_F9, ui::VKEY_F9, 0, 0 }, 954 { XK_0, 0, Mod4Mask, XK_F10, ui::VKEY_F10, 0, 0 }, 955 { XK_minus, 0, Mod4Mask, XK_F11, ui::VKEY_F11, 0, 0 }, 956 { XK_equal, 0, Mod4Mask, XK_F12, ui::VKEY_F12, 0, 0 } 957 }; 958 959 RewriteWithKeyboardRemappingsByKeyCode(kNumberKeysToFkeys, 960 arraysize(kNumberKeysToFkeys), 961 xkey->keycode, 962 xkey->state, 963 event->flags(), 964 &remapped_native_keysym, 965 &remapped_native_mods, 966 &remapped_keycode, 967 &remapped_mods); 968 } 969 970 if (remapped_keycode == ui::VKEY_UNKNOWN) 971 return false; 972 973 OverwriteEvent(event, 974 NativeKeySymToNativeKeycode(remapped_native_keysym), 975 remapped_native_mods, 976 remapped_keycode, 977 remapped_mods); 978 return true; 979 #else 980 // TODO(danakj): Support Ash on other platforms if needed. 981 return false; 982 #endif 983 } 984 985 void EventRewriter::RewriteLocatedEvent(ui::LocatedEvent* event) { 986 #if defined(OS_CHROMEOS) 987 if (event->flags() & ui::EF_IS_SYNTHESIZED) 988 return; 989 990 XEvent* xevent = event->native_event(); 991 if (!xevent || xevent->type != GenericEvent) 992 return; 993 994 XIDeviceEvent* xievent = static_cast<XIDeviceEvent*>(xevent->xcookie.data); 995 if (xievent->evtype != XI_ButtonPress && xievent->evtype != XI_ButtonRelease) 996 return; 997 998 // First, remap modifier masks. 999 int remapped_flags = 0; 1000 unsigned int remapped_native_modifiers = 0U; 1001 GetRemappedModifierMasks(event->flags(), xievent->mods.effective, 1002 &remapped_flags, &remapped_native_modifiers); 1003 xievent->mods.effective = remapped_native_modifiers; 1004 1005 // Then, remap Alt+Button1 to Button3. 1006 if ((xievent->mods.effective & Mod1Mask) && xievent->detail == 1) { 1007 xievent->mods.effective &= ~Mod1Mask; 1008 xievent->detail = 3; 1009 if (xievent->evtype == XI_ButtonRelease) { 1010 // On the release clear the left button from the existing state and the 1011 // mods, and set the right button. 1012 XISetMask(xievent->buttons.mask, 3); 1013 XIClearMask(xievent->buttons.mask, 1); 1014 xievent->mods.effective &= ~Button1Mask; 1015 } 1016 } 1017 1018 const int mouse_event_flags = event->flags() & 1019 (ui::EF_IS_DOUBLE_CLICK | ui::EF_IS_TRIPLE_CLICK | ui::EF_IS_NON_CLIENT | 1020 ui::EF_IS_SYNTHESIZED | ui::EF_FROM_TOUCH); 1021 event->set_flags(mouse_event_flags | ui::EventFlagsFromNative(xevent)); 1022 #else 1023 // TODO(yusukes): Support Ash on other platforms if needed. 1024 #endif 1025 } 1026 1027 void EventRewriter::OverwriteEvent(ui::KeyEvent* event, 1028 unsigned int new_native_keycode, 1029 unsigned int new_native_state, 1030 ui::KeyboardCode new_keycode, 1031 int new_flags) { 1032 #if defined(OS_CHROMEOS) 1033 XEvent* xev = event->native_event(); 1034 XKeyEvent* xkey = &(xev->xkey); 1035 xkey->keycode = new_native_keycode; 1036 xkey->state = new_native_state; 1037 event->set_key_code(new_keycode); 1038 event->set_character(ui::GetCharacterFromKeyCode(event->key_code(), 1039 new_flags)); 1040 event->set_flags(new_flags); 1041 event->NormalizeFlags(); 1042 #else 1043 // TODO(yusukes): Support Ash on other platforms if needed. 1044 #endif 1045 } 1046 1047 EventRewriter::DeviceType EventRewriter::DeviceAddedInternal( 1048 int device_id, 1049 const std::string& device_name) { 1050 const DeviceType type = EventRewriter::GetDeviceType(device_name); 1051 if (type == kDeviceAppleKeyboard) { 1052 VLOG(1) << "Apple keyboard '" << device_name << "' connected: " 1053 << "id=" << device_id; 1054 } 1055 // Always overwrite the existing device_id since the X server may reuse a 1056 // device id for an unattached device. 1057 device_id_to_type_[device_id] = type; 1058 return type; 1059 } 1060
