Ozone keyboard layout

ui/events/event.cc

Index: ui/events/event.cc
diff --git a/ui/events/event.cc b/ui/events/event.cc
index e93a0aedf618c3810be06c34b6b253f258c29be3..e306a0d78eaa0d14dd55b84b2b4a1ddc462a93b4 100644
--- a/ui/events/event.cc
+++ b/ui/events/event.cc
@@ -17,6 +17,7 @@
 #include "base/strings/stringprintf.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/keycodes/dom3/dom_code.h"
+#include "ui/events/keycodes/dom3/dom_key.h"
 #include "ui/events/keycodes/dom4/keycode_converter.h"
 #include "ui/events/keycodes/keyboard_code_conversion.h"
 #include "ui/gfx/geometry/safe_integer_conversions.h"
@@ -28,7 +29,8 @@
 #if defined(USE_X11)
 #include "ui/events/keycodes/keyboard_code_conversion_x.h"
 #elif defined(USE_OZONE)
-#include "ui/events/keycodes/keyboard_code_conversion.h"
+#include "ui/events/ozone/layout/keyboard_layout_engine.h"
+#include "ui/events/ozone/layout/keyboard_layout_engine_manager.h"
 #endif
 
 namespace {
@@ -628,6 +630,7 @@ KeyEvent::KeyEvent(const base::NativeEvent& native_event)
             EventFlagsFromNative(native_event)),
       key_code_(KeyboardCodeFromNative(native_event)),
       code_(CodeFromNative(native_event)),
+      key_(DomKey::NONE),
       is_char_(IsCharFromNative(native_event)),
       platform_keycode_(PlatformKeycodeFromNative(native_event)),
       character_(0) {

[Wez, 2014/12/02 05:45:07]

Does Blink allow delegated constructors yet?

[kpschoedel, 2014/12/02 16:45:45]

Don't know about Blink, but they're allowed here. As above, I'd like to remove
the two following constructors later, but don't want the churn now.

@@ -650,6 +653,7 @@ KeyEvent::KeyEvent(EventType type,
     : Event(type, EventTimeForNow(), flags),
       key_code_(key_code),
       code_(DomCode::NONE),
+      key_(DomKey::NONE),
       is_char_(false),
       platform_keycode_(0),
       character_() {
@@ -662,15 +666,32 @@ KeyEvent::KeyEvent(EventType type,
     : Event(type, EventTimeForNow(), flags),
       key_code_(key_code),
       code_(code),
+      key_(DomKey::NONE),
       is_char_(false),
       platform_keycode_(0),
       character_(0) {
 }
 
+KeyEvent::KeyEvent(EventType type,
+                   KeyboardCode key_code,
+                   DomCode code,
+                   int flags,
+                   DomKey key,
+                   base::char16 character)
+    : Event(type, EventTimeForNow(), flags),
+      key_code_(key_code),
+      code_(code),
+      key_(key),
+      is_char_(false),
+      platform_keycode_(0),
+      character_(character) {
+}
+
 KeyEvent::KeyEvent(base::char16 character, KeyboardCode key_code, int flags)
     : Event(ET_KEY_PRESSED, EventTimeForNow(), flags),
       key_code_(key_code),
       code_(DomCode::NONE),
+      key_(DomKey::CHARACTER),
       is_char_(true),
       platform_keycode_(0),
       character_(character) {
@@ -680,6 +701,7 @@ KeyEvent::KeyEvent(const KeyEvent& rhs)
     : Event(rhs),
       key_code_(rhs.key_code_),
       code_(rhs.code_),
+      key_(rhs.key_),
       is_char_(rhs.is_char_),
       platform_keycode_(rhs.platform_keycode_),
       character_(rhs.character_) {
@@ -692,6 +714,7 @@ KeyEvent& KeyEvent::operator=(const KeyEvent& rhs) {
     Event::operator=(rhs);
     key_code_ = rhs.key_code_;
     code_ = rhs.code_;
+    key_ = rhs.key_;
     is_char_ = rhs.is_char_;
     platform_keycode_ = rhs.platform_keycode_;
     character_ = rhs.character_;
@@ -708,48 +731,54 @@ void KeyEvent::SetExtendedKeyEventData(scoped_ptr<ExtendedKeyEventData> data) {
   extended_key_event_data_ = data.Pass();
 }
 
-base::char16 KeyEvent::GetCharacter() const {
-  if (is_char_ || character_)
-    return character_;
-
-  // TODO(kpschoedel): streamline these cases after settling Ozone
-  // positional coding.
+void KeyEvent::ApplyLayout() const {
 #if defined(OS_WIN)
   // Native Windows character events always have is_char_ == true,
   // so this is a synthetic or native keystroke event.
-  character_ = GetCharacterFromKeyCode(key_code_, flags());
-  return character_;
+  // Therefore, perform only the fallback action.
+  GetInterpretationFromKeyCode(key_code_, flags(), &key_, &character_);

[Wez, 2014/12/02 05:45:07]

Is "interpretation" a term we're using elsewhere? I'd suggest "meaning" if not,
since in principle that's what the |key| field represents.

[kpschoedel, 2014/12/02 16:45:45]

Works for me.

 #elif defined(USE_X11)
-  if (!native_event()) {
-    character_ = GetCharacterFromKeyCode(key_code_, flags());
-    return character_;
-  }
-
-  DCHECK(native_event()->type == KeyPress ||
-         native_event()->type == KeyRelease ||
-         (native_event()->type == GenericEvent &&
-          (native_event()->xgeneric.evtype == XI_KeyPress ||
-           native_event()->xgeneric.evtype == XI_KeyRelease)));
-
   // When a control key is held, prefer ASCII characters to non ASCII
   // characters in order to use it for shortcut keys.  GetCharacterFromKeyCode
   // returns 'a' for VKEY_A even if the key is actually bound to 'à' in X11.
   // GetCharacterFromXEvent returns 'à' in that case.
-  return IsControlDown() ?
+  character_ = (IsControlDown() || !native_event()) ?
       GetCharacterFromKeyCode(key_code_, flags()) :
       GetCharacterFromXEvent(native_event());
+  // TODO(kpschoedel): set key_ field for X11.
+#elif defined(USE_OZONE)
+  KeyboardCode key_code;
+  if (!KeyboardLayoutEngineManager::GetKeyboardLayoutEngine()->Lookup(
+      code_, flags(), &key_, &character_, &key_code)) {
+    GetInterpretationFromKeyCode(key_code_, flags(), &key_, &character_);
+  }
 #else
   if (native_event()) {
     DCHECK(EventTypeFromNative(native_event()) == ET_KEY_PRESSED ||
            EventTypeFromNative(native_event()) == ET_KEY_RELEASED);
   }
-
-  return GetCharacterFromKeyCode(key_code_, flags());
+  // TODO(kpschoedel): revise to use DOM code_ instead of Windows key_code_
+  GetInterpretationFromKeyCode(key_code_, flags(), &key_, &character_);
 #endif
 }
 
+DomKey KeyEvent::GetDomKey() const {
+  // Determination of character_ and key_ may be done lazily.
+  if (key_ == DomKey::NONE)
+    ApplyLayout();
+  return key_;
+}
+
+base::char16 KeyEvent::GetCharacter() const {
+  // Determination of character_ and key_ may be done lazily.
+  if (key_ == DomKey::NONE)
+    ApplyLayout();
+  return character_;
+}
+
 base::char16 KeyEvent::GetText() const {
   if ((flags() & EF_CONTROL_DOWN) != 0) {
+    // TODO(kpschoedel): revise to use DOM code_ instead of Windows key_code_
     return GetControlCharacterForKeycode(key_code_,
                                          (flags() & EF_SHIFT_DOWN) != 0);
   }