summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--chrome/browser/chromeos/chrome_browser_main_chromeos.cc10
-rw-r--r--chrome/browser/chromeos/input_method/mock_xkeyboard.cc2
-rw-r--r--chrome/browser/chromeos/system_key_event_listener.cc7
-rw-r--r--chrome/browser/ui/views/ash/key_rewriter.cc155
-rw-r--r--chrome/browser/ui/views/ash/key_rewriter.h32
-rw-r--r--chrome/browser/ui/views/ash/key_rewriter_unittest.cc302
-rw-r--r--ui/base/keycodes/keyboard_code_conversion_x.cc1
7 files changed, 477 insertions, 32 deletions
diff --git a/chrome/browser/chromeos/chrome_browser_main_chromeos.cc b/chrome/browser/chromeos/chrome_browser_main_chromeos.cc
index 41829ac..dfb30fa 100644
--- a/chrome/browser/chromeos/chrome_browser_main_chromeos.cc
+++ b/chrome/browser/chromeos/chrome_browser_main_chromeos.cc
@@ -278,15 +278,9 @@ void ChromeBrowserMainPartsChromeos::PostMainMessageLoopStart() {
chromeos::input_method::InputMethodManager::Initialize();
if (base::chromeos::IsRunningOnChromeOS()) {
- // Enable Num Lock on X start up for http://crosbug.com/p/5795 and
- // http://crosbug.com/p/6245. We don't do this for Chromium OS since many
- // netbooks do not work as intended when Num Lock is on (e.g. On a netbook
- // with a small keyboard, u, i, o, p, ... keys might be repurposed as
- // cursor keys when Num Lock is on).
-#if defined(GOOGLE_CHROME_BUILD)
+ // Disable Num Lock on X start up for http://crosbug.com/29169.
chromeos::input_method::InputMethodManager::GetInstance()->
- GetXKeyboard()->SetNumLockEnabled(true);
-#endif
+ GetXKeyboard()->SetNumLockEnabled(false);
}
ChromeBrowserMainPartsLinux::PostMainMessageLoopStart();
diff --git a/chrome/browser/chromeos/input_method/mock_xkeyboard.cc b/chrome/browser/chromeos/input_method/mock_xkeyboard.cc
index 1434e801..0792d892 100644
--- a/chrome/browser/chromeos/input_method/mock_xkeyboard.cc
+++ b/chrome/browser/chromeos/input_method/mock_xkeyboard.cc
@@ -10,7 +10,7 @@ namespace input_method {
MockXKeyboard::MockXKeyboard()
: set_current_keyboard_layout_by_name_count_(0),
caps_lock_is_enabled_(false),
- num_lock_is_enabled_(true) {
+ num_lock_is_enabled_(false) {
}
bool MockXKeyboard::SetCurrentKeyboardLayoutByName(
diff --git a/chrome/browser/chromeos/system_key_event_listener.cc b/chrome/browser/chromeos/system_key_event_listener.cc
index 7ff74bf..65e7150 100644
--- a/chrome/browser/chromeos/system_key_event_listener.cc
+++ b/chrome/browser/chromeos/system_key_event_listener.cc
@@ -131,8 +131,11 @@ bool SystemKeyEventListener::ProcessedXEvent(XEvent* xevent) {
enabled = (xkey_event->state.locked_mods) & num_lock_mask_;
if (num_lock_is_on_ != enabled) {
num_lock_is_on_ = enabled;
- new_num_lock_state =
- enabled ? input_method::kEnableLock : input_method::kDisableLock;
+ if (num_lock_is_on_) {
+ // TODO(yusukes,adlr): Let the user know that num lock is unsupported.
+ }
+ // Force turning off Num Lock. crosbug.com/29169
+ new_num_lock_state = input_method::kDisableLock;
}
// Propagate the keyboard LED change to _ALL_ keyboards
diff --git a/chrome/browser/ui/views/ash/key_rewriter.cc b/chrome/browser/ui/views/ash/key_rewriter.cc
index b587239..15a1e6d 100644
--- a/chrome/browser/ui/views/ash/key_rewriter.cc
+++ b/chrome/browser/ui/views/ash/key_rewriter.cc
@@ -12,7 +12,6 @@
#include "ui/aura/event.h"
#include "ui/aura/root_window.h"
#include "ui/base/keycodes/keyboard_code_conversion.h"
-#include "ui/base/keycodes/keyboard_codes.h"
#if defined(OS_CHROMEOS)
#include <X11/extensions/XInput2.h>
@@ -87,6 +86,10 @@ void KeyRewriter::RewriteCommandToControlForTesting(aura::KeyEvent* event) {
RewriteCommandToControl(event);
}
+void KeyRewriter::RewriteNumPadKeysForTesting(aura::KeyEvent* event) {
+ RewriteNumPadKeys(event);
+}
+
ash::KeyRewriterDelegate::Action KeyRewriter::RewriteOrFilterKeyEvent(
aura::KeyEvent* event) {
const ash::KeyRewriterDelegate::Action kActionRewrite =
@@ -96,7 +99,11 @@ ash::KeyRewriterDelegate::Action KeyRewriter::RewriteOrFilterKeyEvent(
return kActionRewrite;
}
- RewriteCommandToControl(event);
+ if (RewriteCommandToControl(event))
+ return kActionRewrite;
+ if (RewriteNumPadKeys(event))
+ return kActionRewrite;
+
// TODO(yusukes): Implement crbug.com/115112 (Search/Ctrl/Alt remapping) and
// crosbug.com/27167 (allow sending function keys) here.
@@ -157,26 +164,39 @@ void KeyRewriter::DeviceKeyPressedOrReleased(int device_id) {
}
void KeyRewriter::RefreshKeycodes() {
- control_l_xkeycode_ = XKeysymToKeycode(ui::GetXDisplay(), XK_Control_L);
- control_r_xkeycode_ = XKeysymToKeycode(ui::GetXDisplay(), XK_Control_R);
+ Display* display = ui::GetXDisplay();
+ control_l_xkeycode_ = XKeysymToKeycode(display, XK_Control_L);
+ control_r_xkeycode_ = XKeysymToKeycode(display, XK_Control_R);
+ kp_0_xkeycode_ = XKeysymToKeycode(display, XK_KP_0);
+ kp_1_xkeycode_ = XKeysymToKeycode(display, XK_KP_1);
+ kp_2_xkeycode_ = XKeysymToKeycode(display, XK_KP_2);
+ kp_3_xkeycode_ = XKeysymToKeycode(display, XK_KP_3);
+ kp_4_xkeycode_ = XKeysymToKeycode(display, XK_KP_4);
+ kp_5_xkeycode_ = XKeysymToKeycode(display, XK_KP_5);
+ kp_6_xkeycode_ = XKeysymToKeycode(display, XK_KP_6);
+ kp_7_xkeycode_ = XKeysymToKeycode(display, XK_KP_7);
+ kp_8_xkeycode_ = XKeysymToKeycode(display, XK_KP_8);
+ kp_9_xkeycode_ = XKeysymToKeycode(display, XK_KP_9);
+ kp_decimal_xkeycode_ = XKeysymToKeycode(display, XK_KP_Decimal);
}
#endif
-void KeyRewriter::RewriteCommandToControl(aura::KeyEvent* event) {
+bool KeyRewriter::RewriteCommandToControl(aura::KeyEvent* event) {
+ bool rewritten = false;
if (last_device_id_ == kBadDeviceId)
- return;
+ return rewritten;
// Check which device generated |event|.
std::map<int, DeviceType>::const_iterator iter =
device_id_to_type_.find(last_device_id_);
if (iter == device_id_to_type_.end()) {
LOG(ERROR) << "Device ID " << last_device_id_ << " is unknown.";
- return;
+ return rewritten;
}
const DeviceType type = iter->second;
if (type != kDeviceAppleKeyboard)
- return;
+ return rewritten;
#if defined(OS_CHROMEOS)
XEvent* xev = event->native_event();
@@ -190,21 +210,19 @@ void KeyRewriter::RewriteCommandToControl(aura::KeyEvent* event) {
event->set_flags(event->flags() | ui::EF_CONTROL_DOWN);
}
- KeySym keysym = XLookupKeysym(xkey, 0);
+ const KeySym keysym = XLookupKeysym(xkey, 0);
switch (keysym) {
case XK_Super_L:
// left Command -> left Control
- xkey->keycode = control_l_xkeycode_;
- event->set_key_code(ui::VKEY_LCONTROL);
- event->set_character(ui::GetCharacterFromKeyCode(event->key_code(),
- event->flags()));
+ Rewrite(event, control_l_xkeycode_, xkey->state,
+ ui::VKEY_LCONTROL, event->flags());
+ rewritten = true;
break;
case XK_Super_R:
// right Command -> right Control
- xkey->keycode = control_r_xkeycode_;
- event->set_key_code(ui::VKEY_RCONTROL);
- event->set_character(ui::GetCharacterFromKeyCode(event->key_code(),
- event->flags()));
+ Rewrite(event, control_r_xkeycode_, xkey->state,
+ ui::VKEY_RCONTROL, event->flags());
+ rewritten = true;
break;
default:
break;
@@ -214,7 +232,108 @@ void KeyRewriter::RewriteCommandToControl(aura::KeyEvent* event) {
DCHECK_NE(ui::VKEY_RWIN, ui::KeyboardCodeFromXKeyEvent(xev));
#else
// TODO(yusukes): Support Ash on other platforms if needed.
- NOTIMPLEMENTED();
+#endif
+ return rewritten;
+}
+
+bool KeyRewriter::RewriteNumPadKeys(aura::KeyEvent* event) {
+ bool rewritten = false;
+#if defined(OS_CHROMEOS)
+ XEvent* xev = event->native_event();
+ XKeyEvent* xkey = &(xev->xkey);
+
+ const KeySym keysym = XLookupKeysym(xkey, 0);
+ switch (keysym) {
+ case XK_KP_Insert:
+ Rewrite(event, kp_0_xkeycode_, xkey->state | Mod2Mask,
+ ui::VKEY_NUMPAD0, event->flags());
+ rewritten = true;
+ break;
+ case XK_KP_Delete:
+ Rewrite(event, kp_decimal_xkeycode_, xkey->state | Mod2Mask,
+ ui::VKEY_DECIMAL, event->flags());
+ rewritten = true;
+ break;
+ case XK_KP_End:
+ Rewrite(event, kp_1_xkeycode_, xkey->state | Mod2Mask,
+ ui::VKEY_NUMPAD1, event->flags());
+ rewritten = true;
+ break;
+ case XK_KP_Down:
+ Rewrite(event, kp_2_xkeycode_, xkey->state | Mod2Mask,
+ ui::VKEY_NUMPAD2, event->flags());
+ rewritten = true;
+ break;
+ case XK_KP_Next:
+ Rewrite(event, kp_3_xkeycode_, xkey->state | Mod2Mask,
+ ui::VKEY_NUMPAD3, event->flags());
+ rewritten = true;
+ break;
+ case XK_KP_Left:
+ Rewrite(event, kp_4_xkeycode_, xkey->state | Mod2Mask,
+ ui::VKEY_NUMPAD4, event->flags());
+ rewritten = true;
+ break;
+ case XK_KP_Begin:
+ Rewrite(event, kp_5_xkeycode_, xkey->state | Mod2Mask,
+ ui::VKEY_NUMPAD5, event->flags());
+ rewritten = true;
+ break;
+ case XK_KP_Right:
+ Rewrite(event, kp_6_xkeycode_, xkey->state | Mod2Mask,
+ ui::VKEY_NUMPAD6, event->flags());
+ rewritten = true;
+ break;
+ case XK_KP_Home:
+ Rewrite(event, kp_7_xkeycode_, xkey->state | Mod2Mask,
+ ui::VKEY_NUMPAD7, event->flags());
+ rewritten = true;
+ break;
+ case XK_KP_Up:
+ Rewrite(event, kp_8_xkeycode_, xkey->state | Mod2Mask,
+ ui::VKEY_NUMPAD8, event->flags());
+ rewritten = true;
+ break;
+ case XK_KP_Prior:
+ Rewrite(event, kp_9_xkeycode_, xkey->state | Mod2Mask,
+ ui::VKEY_NUMPAD9, event->flags());
+ rewritten = true;
+ break;
+ case XK_KP_Divide:
+ case XK_KP_Multiply:
+ case XK_KP_Subtract:
+ case XK_KP_Add:
+ case XK_KP_Enter:
+ // Add Mod2Mask for consistency.
+ Rewrite(event, xkey->keycode, xkey->state | Mod2Mask,
+ event->key_code(), event->flags());
+ rewritten = true;
+ break;
+ default:
+ break;
+ }
+#else
+ // TODO(yusukes): Support Ash on other platforms if needed.
+#endif
+ return rewritten;
+}
+
+void KeyRewriter::Rewrite(aura::KeyEvent* event,
+ unsigned int new_native_keycode,
+ unsigned int new_native_state,
+ ui::KeyboardCode new_keycode,
+ int new_flags) {
+#if defined(OS_CHROMEOS)
+ XEvent* xev = event->native_event();
+ XKeyEvent* xkey = &(xev->xkey);
+ xkey->keycode = new_native_keycode;
+ xkey->state = new_native_state;
+ event->set_key_code(new_keycode);
+ event->set_character(ui::GetCharacterFromKeyCode(event->key_code(),
+ new_flags));
+ event->set_flags(new_flags);
+#else
+ // TODO(yusukes): Support Ash on other platforms if needed.
#endif
}
diff --git a/chrome/browser/ui/views/ash/key_rewriter.h b/chrome/browser/ui/views/ash/key_rewriter.h
index c615ba9..728daef8 100644
--- a/chrome/browser/ui/views/ash/key_rewriter.h
+++ b/chrome/browser/ui/views/ash/key_rewriter.h
@@ -13,6 +13,7 @@
#include "base/basictypes.h"
#include "base/compiler_specific.h"
#include "ui/aura/root_window_observer.h"
+#include "ui/base/keycodes/keyboard_codes.h"
#if defined(OS_CHROMEOS)
#include "chrome/browser/chromeos/device_hierarchy_observer.h"
@@ -42,6 +43,8 @@ class KeyRewriter : public ash::KeyRewriterDelegate,
const std::string& device_name);
// Calls RewriteCommandToControl.
void RewriteCommandToControlForTesting(aura::KeyEvent* event);
+ // Calls RewriteNumPadKeys.
+ void RewriteNumPadKeysForTesting(aura::KeyEvent* event);
const std::map<int, DeviceType>& device_id_to_type_for_testing() const {
return device_id_to_type_;
@@ -68,13 +71,25 @@ class KeyRewriter : public ash::KeyRewriterDelegate,
virtual void DeviceRemoved(int device_id) OVERRIDE;
virtual void DeviceKeyPressedOrReleased(int device_id) OVERRIDE;
- // Updates |*_keycode_| in response to a keyboard map change.
+ // Updates |*_xkeycode_| in response to a keyboard map change.
void RefreshKeycodes();
#endif
// Rewrites Comment-L/R key presses on an Apple keyboard to Control-L/R. Only
- // OS_CHROMEOS implementation is available at this point.
- void RewriteCommandToControl(aura::KeyEvent* event);
+ // OS_CHROMEOS implementation is available at this point. Returns true when
+ // |event| is rewritten.
+ bool RewriteCommandToControl(aura::KeyEvent* event);
+
+ // Rewrites a NumPad key press/release without Num Lock to a corresponding key
+ // press/release with the lock. Returns true when |event| is rewritten.
+ bool RewriteNumPadKeys(aura::KeyEvent* event);
+
+ // Overwrites |event| with the keycodes and flags.
+ void Rewrite(aura::KeyEvent* event,
+ unsigned int new_native_keycode,
+ unsigned int new_native_state,
+ ui::KeyboardCode new_keycode,
+ int new_flags);
// Checks the type of the |device_name|, and inserts a new entry to
// |device_id_to_type_|.
@@ -87,6 +102,17 @@ class KeyRewriter : public ash::KeyRewriterDelegate,
// X keycodes corresponding to various keysyms.
unsigned int control_l_xkeycode_;
unsigned int control_r_xkeycode_;
+ unsigned int kp_0_xkeycode_;
+ unsigned int kp_1_xkeycode_;
+ unsigned int kp_2_xkeycode_;
+ unsigned int kp_3_xkeycode_;
+ unsigned int kp_4_xkeycode_;
+ unsigned int kp_5_xkeycode_;
+ unsigned int kp_6_xkeycode_;
+ unsigned int kp_7_xkeycode_;
+ unsigned int kp_8_xkeycode_;
+ unsigned int kp_9_xkeycode_;
+ unsigned int kp_decimal_xkeycode_;
#endif
DISALLOW_COPY_AND_ASSIGN(KeyRewriter);
diff --git a/chrome/browser/ui/views/ash/key_rewriter_unittest.cc b/chrome/browser/ui/views/ash/key_rewriter_unittest.cc
index 6d9eb4b..fae6902 100644
--- a/chrome/browser/ui/views/ash/key_rewriter_unittest.cc
+++ b/chrome/browser/ui/views/ash/key_rewriter_unittest.cc
@@ -223,4 +223,306 @@ TEST(KeyRewriterTest, TestRewriteCommandToControl) {
EXPECT_EQ(static_cast<unsigned int>(Mod1Mask), xkey.state);
}
}
+
+TEST(KeyRewriterTest, TestRewriteNumPadKeys) {
+ XEvent xev;
+ Display* display = ui::GetXDisplay();
+
+ const unsigned int kKeycodeNumPad0 = XKeysymToKeycode(display, XK_KP_0);
+ const unsigned int kKeycodeNumPadDecimal =
+ XKeysymToKeycode(display, XK_KP_Decimal);
+ const unsigned int kKeycodeNumPad1 = XKeysymToKeycode(display, XK_KP_1);
+ const unsigned int kKeycodeNumPad2 = XKeysymToKeycode(display, XK_KP_2);
+ const unsigned int kKeycodeNumPad3 = XKeysymToKeycode(display, XK_KP_3);
+ const unsigned int kKeycodeNumPad4 = XKeysymToKeycode(display, XK_KP_4);
+ const unsigned int kKeycodeNumPad5 = XKeysymToKeycode(display, XK_KP_5);
+ const unsigned int kKeycodeNumPad6 = XKeysymToKeycode(display, XK_KP_6);
+ const unsigned int kKeycodeNumPad7 = XKeysymToKeycode(display, XK_KP_7);
+ const unsigned int kKeycodeNumPad8 = XKeysymToKeycode(display, XK_KP_8);
+ const unsigned int kKeycodeNumPad9 = XKeysymToKeycode(display, XK_KP_9);
+
+ const unsigned int kKeycodeNumPadInsert =
+ XKeysymToKeycode(display, XK_KP_Insert);
+ const unsigned int kKeycodeNumPadDelete =
+ XKeysymToKeycode(display, XK_KP_Delete);
+ const unsigned int kKeycodeNumPadEnd = XKeysymToKeycode(display, XK_KP_End);
+ const unsigned int kKeycodeNumPadDown = XKeysymToKeycode(display, XK_KP_Down);
+ const unsigned int kKeycodeNumPadNext = XKeysymToKeycode(display, XK_KP_Next);
+ const unsigned int kKeycodeNumPadLeft = XKeysymToKeycode(display, XK_KP_Left);
+ const unsigned int kKeycodeNumPadBegin =
+ XKeysymToKeycode(display, XK_KP_Begin);
+ const unsigned int kKeycodeNumPadRight =
+ XKeysymToKeycode(display, XK_KP_Right);
+ const unsigned int kKeycodeNumPadHome = XKeysymToKeycode(display, XK_KP_Home);
+ const unsigned int kKeycodeNumPadUp = XKeysymToKeycode(display, XK_KP_Up);
+ const unsigned int kKeycodeNumPadPrior =
+ XKeysymToKeycode(display, XK_KP_Prior);
+
+ KeyRewriter rewriter;
+ {
+ // XK_KP_Insert (= NumPad 0 without Num Lock), no modifier.
+ InitXKeyEvent(ui::VKEY_INSERT, 0, kKeycodeNumPadInsert, 0, &xev);
+ aura::KeyEvent keyevent(&xev, false /* is_char */);
+ rewriter.RewriteNumPadKeysForTesting(&keyevent);
+ EXPECT_EQ(ui::VKEY_NUMPAD0, keyevent.key_code());
+ EXPECT_EQ(0, keyevent.flags());
+ const XKeyEvent& xkey = keyevent.native_event()->xkey;
+ EXPECT_EQ(kKeycodeNumPad0, xkey.keycode);
+ // Mod2Mask means Num Lock.
+ EXPECT_EQ(static_cast<unsigned int>(Mod2Mask), xkey.state);
+ }
+ {
+ // XK_KP_Insert (= NumPad 0 without Num Lock), Alt modifier.
+ InitXKeyEvent(ui::VKEY_INSERT, ui::EF_ALT_DOWN,
+ kKeycodeNumPadInsert, Mod1Mask, &xev);
+ aura::KeyEvent keyevent(&xev, false /* is_char */);
+ rewriter.RewriteNumPadKeysForTesting(&keyevent);
+ EXPECT_EQ(ui::VKEY_NUMPAD0, keyevent.key_code());
+ EXPECT_EQ(ui::EF_ALT_DOWN, keyevent.flags());
+ const XKeyEvent& xkey = keyevent.native_event()->xkey;
+ EXPECT_EQ(kKeycodeNumPad0, xkey.keycode);
+ EXPECT_EQ(static_cast<unsigned int>(Mod1Mask | Mod2Mask), xkey.state);
+ }
+ {
+ // XK_KP_Delete (= NumPad . without Num Lock), Alt modifier.
+ InitXKeyEvent(ui::VKEY_DELETE, ui::EF_ALT_DOWN,
+ kKeycodeNumPadDelete, Mod1Mask, &xev);
+ aura::KeyEvent keyevent(&xev, false /* is_char */);
+ rewriter.RewriteNumPadKeysForTesting(&keyevent);
+ EXPECT_EQ(ui::VKEY_DECIMAL, keyevent.key_code());
+ EXPECT_EQ(ui::EF_ALT_DOWN, keyevent.flags());
+ const XKeyEvent& xkey = keyevent.native_event()->xkey;
+ EXPECT_EQ(kKeycodeNumPadDecimal, xkey.keycode);
+ EXPECT_EQ(static_cast<unsigned int>(Mod1Mask | Mod2Mask), xkey.state);
+ }
+ {
+ // XK_KP_End (= NumPad 1 without Num Lock), Alt modifier.
+ InitXKeyEvent(ui::VKEY_END, ui::EF_ALT_DOWN,
+ kKeycodeNumPadEnd, Mod1Mask, &xev);
+ aura::KeyEvent keyevent(&xev, false /* is_char */);
+ rewriter.RewriteNumPadKeysForTesting(&keyevent);
+ EXPECT_EQ(ui::VKEY_NUMPAD1, keyevent.key_code());
+ EXPECT_EQ(ui::EF_ALT_DOWN, keyevent.flags());
+ const XKeyEvent& xkey = keyevent.native_event()->xkey;
+ EXPECT_EQ(kKeycodeNumPad1, xkey.keycode);
+ EXPECT_EQ(static_cast<unsigned int>(Mod1Mask | Mod2Mask), xkey.state);
+ }
+ {
+ // XK_KP_Down (= NumPad 2 without Num Lock), Alt modifier.
+ InitXKeyEvent(ui::VKEY_DOWN, ui::EF_ALT_DOWN,
+ kKeycodeNumPadDown, Mod1Mask, &xev);
+ aura::KeyEvent keyevent(&xev, false /* is_char */);
+ rewriter.RewriteNumPadKeysForTesting(&keyevent);
+ EXPECT_EQ(ui::VKEY_NUMPAD2, keyevent.key_code());
+ EXPECT_EQ(ui::EF_ALT_DOWN, keyevent.flags());
+ const XKeyEvent& xkey = keyevent.native_event()->xkey;
+ EXPECT_EQ(kKeycodeNumPad2, xkey.keycode);
+ EXPECT_EQ(static_cast<unsigned int>(Mod1Mask | Mod2Mask), xkey.state);
+ }
+ {
+ // XK_KP_Next (= NumPad 3 without Num Lock), Alt modifier.
+ InitXKeyEvent(ui::VKEY_NEXT, ui::EF_ALT_DOWN,
+ kKeycodeNumPadNext, Mod1Mask, &xev);
+ aura::KeyEvent keyevent(&xev, false /* is_char */);
+ rewriter.RewriteNumPadKeysForTesting(&keyevent);
+ EXPECT_EQ(ui::VKEY_NUMPAD3, keyevent.key_code());
+ EXPECT_EQ(ui::EF_ALT_DOWN, keyevent.flags());
+ const XKeyEvent& xkey = keyevent.native_event()->xkey;
+ EXPECT_EQ(kKeycodeNumPad3, xkey.keycode);
+ EXPECT_EQ(static_cast<unsigned int>(Mod1Mask | Mod2Mask), xkey.state);
+ }
+ {
+ // XK_KP_Left (= NumPad 4 without Num Lock), Alt modifier.
+ InitXKeyEvent(ui::VKEY_LEFT, ui::EF_ALT_DOWN,
+ kKeycodeNumPadLeft, Mod1Mask, &xev);
+ aura::KeyEvent keyevent(&xev, false /* is_char */);
+ rewriter.RewriteNumPadKeysForTesting(&keyevent);
+ EXPECT_EQ(ui::VKEY_NUMPAD4, keyevent.key_code());
+ EXPECT_EQ(ui::EF_ALT_DOWN, keyevent.flags());
+ const XKeyEvent& xkey = keyevent.native_event()->xkey;
+ EXPECT_EQ(kKeycodeNumPad4, xkey.keycode);
+ EXPECT_EQ(static_cast<unsigned int>(Mod1Mask | Mod2Mask), xkey.state);
+ }
+ {
+ // XK_KP_Begin (= NumPad 5 without Num Lock), Alt modifier.
+ InitXKeyEvent(ui::VKEY_CLEAR, ui::EF_ALT_DOWN,
+ kKeycodeNumPadBegin, Mod1Mask, &xev);
+ aura::KeyEvent keyevent(&xev, false /* is_char */);
+ rewriter.RewriteNumPadKeysForTesting(&keyevent);
+ EXPECT_EQ(ui::VKEY_NUMPAD5, keyevent.key_code());
+ EXPECT_EQ(ui::EF_ALT_DOWN, keyevent.flags());
+ const XKeyEvent& xkey = keyevent.native_event()->xkey;
+ EXPECT_EQ(kKeycodeNumPad5, xkey.keycode);
+ EXPECT_EQ(static_cast<unsigned int>(Mod1Mask | Mod2Mask), xkey.state);
+ }
+ {
+ // XK_KP_Right (= NumPad 6 without Num Lock), Alt modifier.
+ InitXKeyEvent(ui::VKEY_RIGHT, ui::EF_ALT_DOWN,
+ kKeycodeNumPadRight, Mod1Mask, &xev);
+ aura::KeyEvent keyevent(&xev, false /* is_char */);
+ rewriter.RewriteNumPadKeysForTesting(&keyevent);
+ EXPECT_EQ(ui::VKEY_NUMPAD6, keyevent.key_code());
+ EXPECT_EQ(ui::EF_ALT_DOWN, keyevent.flags());
+ const XKeyEvent& xkey = keyevent.native_event()->xkey;
+ EXPECT_EQ(kKeycodeNumPad6, xkey.keycode);
+ EXPECT_EQ(static_cast<unsigned int>(Mod1Mask | Mod2Mask), xkey.state);
+ }
+ {
+ // XK_KP_Home (= NumPad 7 without Num Lock), Alt modifier.
+ InitXKeyEvent(ui::VKEY_HOME, ui::EF_ALT_DOWN,
+ kKeycodeNumPadHome, Mod1Mask, &xev);
+ aura::KeyEvent keyevent(&xev, false /* is_char */);
+ rewriter.RewriteNumPadKeysForTesting(&keyevent);
+ EXPECT_EQ(ui::VKEY_NUMPAD7, keyevent.key_code());
+ EXPECT_EQ(ui::EF_ALT_DOWN, keyevent.flags());
+ const XKeyEvent& xkey = keyevent.native_event()->xkey;
+ EXPECT_EQ(kKeycodeNumPad7, xkey.keycode);
+ EXPECT_EQ(static_cast<unsigned int>(Mod1Mask | Mod2Mask), xkey.state);
+ }
+ {
+ // XK_KP_Up (= NumPad 8 without Num Lock), Alt modifier.
+ InitXKeyEvent(ui::VKEY_UP, ui::EF_ALT_DOWN,
+ kKeycodeNumPadUp, Mod1Mask, &xev);
+ aura::KeyEvent keyevent(&xev, false /* is_char */);
+ rewriter.RewriteNumPadKeysForTesting(&keyevent);
+ EXPECT_EQ(ui::VKEY_NUMPAD8, keyevent.key_code());
+ EXPECT_EQ(ui::EF_ALT_DOWN, keyevent.flags());
+ const XKeyEvent& xkey = keyevent.native_event()->xkey;
+ EXPECT_EQ(kKeycodeNumPad8, xkey.keycode);
+ EXPECT_EQ(static_cast<unsigned int>(Mod1Mask | Mod2Mask), xkey.state);
+ }
+ {
+ // XK_KP_Prior (= NumPad 9 without Num Lock), Alt modifier.
+ InitXKeyEvent(ui::VKEY_PRIOR, ui::EF_ALT_DOWN,
+ kKeycodeNumPadPrior, Mod1Mask, &xev);
+ aura::KeyEvent keyevent(&xev, false /* is_char */);
+ rewriter.RewriteNumPadKeysForTesting(&keyevent);
+ EXPECT_EQ(ui::VKEY_NUMPAD9, keyevent.key_code());
+ EXPECT_EQ(ui::EF_ALT_DOWN, keyevent.flags());
+ const XKeyEvent& xkey = keyevent.native_event()->xkey;
+ EXPECT_EQ(kKeycodeNumPad9, xkey.keycode);
+ EXPECT_EQ(static_cast<unsigned int>(Mod1Mask | Mod2Mask), xkey.state);
+ }
+ {
+ // XK_KP_0 (= NumPad 0 with Num Lock), Num Lock modifier.
+ InitXKeyEvent(ui::VKEY_NUMPAD0, 0, kKeycodeNumPad0, Mod2Mask, &xev);
+ aura::KeyEvent keyevent(&xev, false /* is_char */);
+ rewriter.RewriteNumPadKeysForTesting(&keyevent);
+ EXPECT_EQ(ui::VKEY_NUMPAD0, keyevent.key_code());
+ EXPECT_EQ(0, keyevent.flags());
+ const XKeyEvent& xkey = keyevent.native_event()->xkey;
+ EXPECT_EQ(kKeycodeNumPad0, xkey.keycode);
+ EXPECT_EQ(static_cast<unsigned int>(Mod2Mask), xkey.state);
+ }
+ {
+ // XK_KP_DECIMAL (= NumPad . with Num Lock), Num Lock modifier.
+ InitXKeyEvent(ui::VKEY_DECIMAL, 0, kKeycodeNumPadDecimal, Mod2Mask, &xev);
+ aura::KeyEvent keyevent(&xev, false /* is_char */);
+ rewriter.RewriteNumPadKeysForTesting(&keyevent);
+ EXPECT_EQ(ui::VKEY_DECIMAL, keyevent.key_code());
+ EXPECT_EQ(0, keyevent.flags());
+ const XKeyEvent& xkey = keyevent.native_event()->xkey;
+ EXPECT_EQ(kKeycodeNumPadDecimal, xkey.keycode);
+ EXPECT_EQ(static_cast<unsigned int>(Mod2Mask), xkey.state);
+ }
+ {
+ // XK_KP_1 (= NumPad 1 with Num Lock), Num Lock modifier.
+ InitXKeyEvent(ui::VKEY_NUMPAD1, 0, kKeycodeNumPad1, Mod2Mask, &xev);
+ aura::KeyEvent keyevent(&xev, false /* is_char */);
+ rewriter.RewriteNumPadKeysForTesting(&keyevent);
+ EXPECT_EQ(ui::VKEY_NUMPAD1, keyevent.key_code());
+ EXPECT_EQ(0, keyevent.flags());
+ const XKeyEvent& xkey = keyevent.native_event()->xkey;
+ EXPECT_EQ(kKeycodeNumPad1, xkey.keycode);
+ EXPECT_EQ(static_cast<unsigned int>(Mod2Mask), xkey.state);
+ }
+ {
+ // XK_KP_2 (= NumPad 2 with Num Lock), Num Lock modifier.
+ InitXKeyEvent(ui::VKEY_NUMPAD2, 0, kKeycodeNumPad2, Mod2Mask, &xev);
+ aura::KeyEvent keyevent(&xev, false /* is_char */);
+ rewriter.RewriteNumPadKeysForTesting(&keyevent);
+ EXPECT_EQ(ui::VKEY_NUMPAD2, keyevent.key_code());
+ EXPECT_EQ(0, keyevent.flags());
+ const XKeyEvent& xkey = keyevent.native_event()->xkey;
+ EXPECT_EQ(kKeycodeNumPad2, xkey.keycode);
+ EXPECT_EQ(static_cast<unsigned int>(Mod2Mask), xkey.state);
+ }
+ {
+ // XK_KP_3 (= NumPad 3 with Num Lock), Num Lock modifier.
+ InitXKeyEvent(ui::VKEY_NUMPAD3, 0, kKeycodeNumPad3, Mod2Mask, &xev);
+ aura::KeyEvent keyevent(&xev, false /* is_char */);
+ rewriter.RewriteNumPadKeysForTesting(&keyevent);
+ EXPECT_EQ(ui::VKEY_NUMPAD3, keyevent.key_code());
+ EXPECT_EQ(0, keyevent.flags());
+ const XKeyEvent& xkey = keyevent.native_event()->xkey;
+ EXPECT_EQ(kKeycodeNumPad3, xkey.keycode);
+ EXPECT_EQ(static_cast<unsigned int>(Mod2Mask), xkey.state);
+ }
+ {
+ // XK_KP_4 (= NumPad 4 with Num Lock), Num Lock modifier.
+ InitXKeyEvent(ui::VKEY_NUMPAD4, 0, kKeycodeNumPad4, Mod2Mask, &xev);
+ aura::KeyEvent keyevent(&xev, false /* is_char */);
+ rewriter.RewriteNumPadKeysForTesting(&keyevent);
+ EXPECT_EQ(ui::VKEY_NUMPAD4, keyevent.key_code());
+ EXPECT_EQ(0, keyevent.flags());
+ const XKeyEvent& xkey = keyevent.native_event()->xkey;
+ EXPECT_EQ(kKeycodeNumPad4, xkey.keycode);
+ EXPECT_EQ(static_cast<unsigned int>(Mod2Mask), xkey.state);
+ }
+ {
+ // XK_KP_5 (= NumPad 5 with Num Lock), Num Lock modifier.
+ InitXKeyEvent(ui::VKEY_NUMPAD5, 0, kKeycodeNumPad5, Mod2Mask, &xev);
+ aura::KeyEvent keyevent(&xev, false /* is_char */);
+ rewriter.RewriteNumPadKeysForTesting(&keyevent);
+ EXPECT_EQ(ui::VKEY_NUMPAD5, keyevent.key_code());
+ EXPECT_EQ(0, keyevent.flags());
+ const XKeyEvent& xkey = keyevent.native_event()->xkey;
+ EXPECT_EQ(kKeycodeNumPad5, xkey.keycode);
+ EXPECT_EQ(static_cast<unsigned int>(Mod2Mask), xkey.state);
+ }
+ {
+ // XK_KP_6 (= NumPad 6 with Num Lock), Num Lock modifier.
+ InitXKeyEvent(ui::VKEY_NUMPAD6, 0, kKeycodeNumPad6, Mod2Mask, &xev);
+ aura::KeyEvent keyevent(&xev, false /* is_char */);
+ rewriter.RewriteNumPadKeysForTesting(&keyevent);
+ EXPECT_EQ(ui::VKEY_NUMPAD6, keyevent.key_code());
+ EXPECT_EQ(0, keyevent.flags());
+ const XKeyEvent& xkey = keyevent.native_event()->xkey;
+ EXPECT_EQ(kKeycodeNumPad6, xkey.keycode);
+ EXPECT_EQ(static_cast<unsigned int>(Mod2Mask), xkey.state);
+ }
+ {
+ // XK_KP_7 (= NumPad 7 with Num Lock), Num Lock modifier.
+ InitXKeyEvent(ui::VKEY_NUMPAD7, 0, kKeycodeNumPad7, Mod2Mask, &xev);
+ aura::KeyEvent keyevent(&xev, false /* is_char */);
+ rewriter.RewriteNumPadKeysForTesting(&keyevent);
+ EXPECT_EQ(ui::VKEY_NUMPAD7, keyevent.key_code());
+ EXPECT_EQ(0, keyevent.flags());
+ const XKeyEvent& xkey = keyevent.native_event()->xkey;
+ EXPECT_EQ(kKeycodeNumPad7, xkey.keycode);
+ EXPECT_EQ(static_cast<unsigned int>(Mod2Mask), xkey.state);
+ }
+ {
+ // XK_KP_8 (= NumPad 8 with Num Lock), Num Lock modifier.
+ InitXKeyEvent(ui::VKEY_NUMPAD8, 0, kKeycodeNumPad8, Mod2Mask, &xev);
+ aura::KeyEvent keyevent(&xev, false /* is_char */);
+ rewriter.RewriteNumPadKeysForTesting(&keyevent);
+ EXPECT_EQ(ui::VKEY_NUMPAD8, keyevent.key_code());
+ EXPECT_EQ(0, keyevent.flags());
+ const XKeyEvent& xkey = keyevent.native_event()->xkey;
+ EXPECT_EQ(kKeycodeNumPad8, xkey.keycode);
+ EXPECT_EQ(static_cast<unsigned int>(Mod2Mask), xkey.state);
+ }
+ {
+ // XK_KP_9 (= NumPad 9 with Num Lock), Num Lock modifier.
+ InitXKeyEvent(ui::VKEY_NUMPAD9, 0, kKeycodeNumPad9, Mod2Mask, &xev);
+ aura::KeyEvent keyevent(&xev, false /* is_char */);
+ rewriter.RewriteNumPadKeysForTesting(&keyevent);
+ EXPECT_EQ(ui::VKEY_NUMPAD9, keyevent.key_code());
+ EXPECT_EQ(0, keyevent.flags());
+ const XKeyEvent& xkey = keyevent.native_event()->xkey;
+ EXPECT_EQ(kKeycodeNumPad9, xkey.keycode);
+ EXPECT_EQ(static_cast<unsigned int>(Mod2Mask), xkey.state);
+ }
+}
#endif // OS_CHROMEOS
diff --git a/ui/base/keycodes/keyboard_code_conversion_x.cc b/ui/base/keycodes/keyboard_code_conversion_x.cc
index 622ca1c..1e32090 100644
--- a/ui/base/keycodes/keyboard_code_conversion_x.cc
+++ b/ui/base/keycodes/keyboard_code_conversion_x.cc
@@ -52,6 +52,7 @@ KeyboardCode KeyboardCodeFromXKeysym(unsigned int keysym) {
case XK_ISO_Enter:
return VKEY_RETURN;
case XK_Clear:
+ case XK_KP_Begin: // NumPad 5 without Num Lock, for crosbug.com/29169.
return VKEY_CLEAR;
case XK_KP_Space:
case XK_space:
generated by cgit v1.1 at 2025-02-14 23:11:51 +0000