Ozone keyboard layout

ui/events/event.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef UI_EVENTS_EVENT_H_
 #define UI_EVENTS_EVENT_H_
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/event_types.h"
 #include "base/gtest_prod_util.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/gesture_event_details.h"
 #include "ui/events/gestures/gesture_types.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/events/latency_info.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/point_conversions.h"
 
 namespace gfx {
 class Transform;
 }
 
 namespace ui {
 class EventTarget;
 enum class DomCode;
+enum class DomKey;
 
 class EVENTS_EXPORT Event {
  public:
   static scoped_ptr<Event> Clone(const Event& event);
 
   virtual ~Event();
 
   class DispatcherApi {
    public:
     explicit DispatcherApi(Event* event) : event_(event) {}
@@ skipping 537 matching lines @@
 //    ET_TRANSLATED_KEY_PRESS, or ET_TRANSLATED_KEY_RELEASE.
 // -- character_ functions as a bypass or cache for GetCharacter().
 // -- key_code_ is a VKEY_ value associated with the key. For printable
 //    characters, this may or may not be a mapped value, imitating MS Windows:
 //    if the mapped key generates a character that has an associated VKEY_
 //    code, then key_code_ is that code; if not, then key_code_ is the unmapped
 //    VKEY_ code. For example, US, Greek, Cyrillic, Japanese, etc. all use
 //    VKEY_Q for the key beside Tab, while French uses VKEY_A.
 // -- code_ is in one-to-one correspondence with a physical keyboard
 //    location, and does not vary depending on key layout.
+// -- key_, possibly in conjuction with character_, is the interpretation
+//    of the keystroke under the current key layout.
 //
 // For a character event,
 // -- is_char_ is true.
 // -- type() is ET_KEY_PRESSED.
 // -- character_ is a UTF-16 character value.
 // -- key_code_ is conflated with character_ by some code, because both
 //    arrive in the wParam field of a Windows event.
 // -- code_ is DomCode::NONE.
+// -- key_ is DomKey::CHARACTER.
 //
 class EVENTS_EXPORT KeyEvent : public Event {
  public:
   // Create a KeyEvent from a NativeEvent. For Windows this native event can
   // be either a keystroke message (WM_KEYUP/WM_KEYDOWN) or a character message
   // (WM_CHAR). Other systems have only keystroke events.
   explicit KeyEvent(const base::NativeEvent& native_event);
 
   // Create a keystroke event.
   KeyEvent(EventType type, KeyboardCode key_code, int flags);
 
+  // Create a fully defined keystroke event.
+  KeyEvent(EventType type,
+           KeyboardCode key_code,
+           DomCode code,
+           int flags,
+           DomKey key,
+           base::char16 character);
+
   // Create a character event.
   KeyEvent(base::char16 character, KeyboardCode key_code, int flags);
 
   // Used for synthetic events with code of DOM KeyboardEvent (e.g. 'KeyA')
   // See also: ui/events/keycodes/dom3/dom_values.txt
   KeyEvent(EventType type,
            KeyboardCode key_code,
            DomCode code,
            int flags);
 
@@ skipping 63 matching lines @@
   uint16 GetConflatedWindowsKeyCode() const;
 
   // Returns true for [Alt]+<num-pad digit> Unicode alt key codes used by Win.
   // TODO(msw): Additional work may be needed for analogues on other platforms.
   bool IsUnicodeKeyCode() const;
 
   // Returns the DOM .code (physical key identifier) for a keystroke event.
   DomCode code() const { return code_; };
   std::string GetCodeString() const;
 
+   // Returns the DOM .key (layout interpretation) for a keystroke event.
+   DomKey GetDomKey() const;

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

Indentation looks wrong?

It's a shame that we cannot name this consistently with the |code| members,
above (i.e. most likely to re-name those).

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

Acknowledged.

+
   // Normalizes flags_ so that it describes the state after the event.
   // (Native X11 event flags describe the state before the event.)
   void NormalizeFlags();
 
   // Returns true if the key event has already been processed by an input method
   // and there is no need to pass the key event to the input method again.
   bool IsTranslated() const;
   // Marks this key event as translated or not translated.
   void SetTranslated(bool translated);
 
  protected:
   friend class KeyEventTestApi;
 
   // This allows a subclass TranslatedKeyEvent to be a non character event.
   void set_is_char(bool is_char) { is_char_ = is_char; }
 
  private:
   // True if the key press originated from a 'right' key (VKEY_RSHIFT, etc.).
   bool IsRightSideKey() const;
 
+  // Determine key_ and character_ on a keystroke event from code_ and flags().
+  void ApplyLayout() const;
+
   KeyboardCode key_code_;
 
   // DOM KeyboardEvent |code| (e.g. DomCode::KEY_A, DomCode::SPACE).
   // http://www.w3.org/TR/DOM-Level-3-Events-code/
   //
   // This value represents the physical position in the keyboard and can be
   // converted from / to keyboard scan code like XKB.
   DomCode code_;
 
+  // DOM KeyboardEvent |key|
+  // http://www.w3.org/TR/DOM-Level-3-Events-key/
+  //
+  // This value represents the interpretation of a key. The value is
+  // DomKey::CHARACTER when the interpretation is a character.
+  // This, along with character_, may be lazily evaluated, since in some cases
+  // (e.g. native ChromeOS) we are not interested in the values until after
+  // the event has been transformed.
+  mutable DomKey key_;

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

Why does this need mutable?

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

Same as character_; the existing code mutates character_ in GetCharacter(), so
it's practical to handle key_ the same way. There's a bit of discussion in the
earlier comments — I agree on moving away from this (for character_ and key_
both) but I think it's too risky to make that the highest priority.

+
   // True if this is a character event, false if this is a keystroke event.
   bool is_char_;
 
   // The platform related keycode value. For XKB, it's keysym value.
   // For now, this is used for CharacterComposer in ChromeOS.
   uint32 platform_keycode_;
 
   // String of 'key' defined in DOM KeyboardEvent (e.g. 'a', 'â')
   // http://www.w3.org/TR/uievents/#keyboard-key-codes.
   //
@@ skipping 82 matching lines @@
 
   const GestureEventDetails& details() const { return details_; }
 
  private:
   GestureEventDetails details_;
 };
 
 }  // namespace ui
 
 #endif  // UI_EVENTS_EVENT_H_