Ozone keyboard layout

ui/events/event.cc

 // 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.
 
 #include "ui/events/event.h"
 
 #if defined(USE_X11)
 #include <X11/extensions/XInput2.h>
 #include <X11/Xlib.h>
 #include <X11/keysym.h>
 #endif
 
 #include <cmath>
 #include <cstring>
 
 #include "base/metrics/histogram.h"
 #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"
 #include "ui/gfx/point3_f.h"
 #include "ui/gfx/point_conversions.h"
 #include "ui/gfx/transform.h"
 #include "ui/gfx/transform_util.h"
 
 #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/ozone/public/keyboard_layouts.h"
+#include "ui/ozone/public/ozone_platform.h"

[kpschoedel, 2014/11/20 16:18:38]

Will need +ui/ozone dependency.

[sadrul, 2014/11/21 21:25:25]

//ui/ozone has deps on //ui/events/, so we can't currently do this.

[kpschoedel, 2014/11/21 21:43:33]

Argh. OK, this needs a rethink. Layout is fortunately orthogonal to the rest of
the Ozone platform, so I susppose it doesn't have to be there.

[spang, 2014/11/21 21:58:52]

Can we really say it is orthogonal?

I think we should follow a model where ui::KeyEvent is just data. Thta way,
there wouldn't be anything in the key event class that uses the layout.

If we put the smarts into KeyEvent, a dependency cycle is basically unavoidable.

 #endif
-
 namespace {
 
 std::string EventTypeName(ui::EventType type) {
 #define RETURN_IF_TYPE(t) if (type == ui::t)  return #t
 #define CASE_TYPE(t) case ui::t:  return #t
   switch (type) {
     CASE_TYPE(ET_UNKNOWN);
     CASE_TYPE(ET_MOUSE_PRESSED);
     CASE_TYPE(ET_MOUSE_DRAGGED);
     CASE_TYPE(ET_MOUSE_RELEASED);
@@ skipping 614 matching lines @@
 KeyEvent::KeyEvent(EventType type,
                    KeyboardCode key_code,
                    DomCode code,
                    int flags)
     : Event(type, EventTimeForNow(), flags),
       key_code_(key_code),
       code_(code),
       is_char_(false),
       platform_keycode_(0),
       character_(0) {
+#if defined(USE_OZONE)
+  // TODO(kpschoedel): Change after keyboard_code_conversion_ozone.
+  if (key_code_ == VKEY_UNKNOWN) {
+    DomKey todo_dom_key = DomKey::NONE;
+    OzonePlatform::GetInstance()->GetKeyboardLayouts()->Lookup(code_,
+                                                               this->flags(),
+                                                               &todo_dom_key,
+                                                               &character_,
+                                                               &key_code_);
+  }
+#endif

[kpschoedel, 2014/11/20 16:18:38]

Should the Ozone event source instead be responsible for providing a correct
key_code_ in all cases?

We would probably then want another constructor (which would also be used for
hypothetical platforms that don't do layout, e.g. caca and possibly future
embedded Brillage that uses key events for control buttons but not actual
keyboards), like:

 KeyEvent(EventType type,
           KeyboardCode key_code,
           DomCode dom_code,
           EventFlags flags,
           DomKey dom_key,
           base::char16 character)

In the general case determining the Windows VKEY requires calling the layout
function, possibly several times — see keyboard_code_conversion_x.cc for gory
details.

[sadrul, 2014/11/21 21:25:25]

I think so, yeah.

[kpschoedel, 2014/11/21 21:43:33]

In that case, I think we'll want the extended constructor since correctly
determining the Windows key_code in the general case requires calling into the
key layout, possibly multiple times (see keyboard_code_conversion_x.cc), so the
caller will typically have the key/character as well:

 }
 
 KeyEvent::KeyEvent(base::char16 character, KeyboardCode key_code, int flags)
     : Event(ET_KEY_PRESSED, EventTimeForNow(), flags),
       key_code_(key_code),
       code_(DomCode::NONE),
       is_char_(true),
       platform_keycode_(0),
       character_(character) {
 }
@@ skipping 28 matching lines @@
 
 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.

[kpschoedel, 2014/11/20 16:18:38]

I have a refactoring of GetCharacter() in the upcoming DomKey CL. Since
character and DomKey depend on layout, I plan a common layout function called
from GetDomKey(), GetCharacter() and variants. Today GetCharacter() is a lazy
evaluation of KeyEvent::character_, and I plan the same for KeyEvent::dom_key_,
as some uses of key events only use physical keys and never actually require
layout.

 #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_;
 #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() ?
       GetCharacterFromKeyCode(key_code_, flags()) :
       GetCharacterFromXEvent(native_event());
+#elif defined(USE_OZONE)
+  DomKey todo_dom_key = DomKey::NONE;
+  KeyboardCode dummy_key_code = VKEY_UNKNOWN;
+  if (OzonePlatform::GetInstance()->GetKeyboardLayouts()->Lookup(
+          code_,
+          flags(),
+          &todo_dom_key,
+          &character_,
+          &dummy_key_code)) {
+    return character_;
+  }
+  return GetCharacterFromKeyCode(key_code_, flags());
 #else
   if (native_event()) {
     DCHECK(EventTypeFromNative(native_event()) == ET_KEY_PRESSED ||
            EventTypeFromNative(native_event()) == ET_KEY_RELEASED);
   }
 
   return GetCharacterFromKeyCode(key_code_, flags());
 #endif
 }
 
@@ skipping 232 matching lines @@
                    gfx::PointF(x, y),
                    time_stamp,
                    flags | EF_FROM_TOUCH),
       details_(details) {
 }
 
 GestureEvent::~GestureEvent() {
 }
 
 }  // namespace ui