xkb_keyboard_layout_engine.cc | Explore in Territory

// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/351564777): Remove this and convert code to safer constructs.
#pragma allow_unsafe_buffers
#endif

#include "ui/events/ozone/layout/xkb/xkb_keyboard_layout_engine.h"

#include <stddef.h>
#include <xkbcommon/xkbcommon-names.h>

#include <algorithm>
#include <string_view>
#include <utility>

#include "base/containers/span.h"
#include "base/functional/bind.h"
#include "base/functional/callback_forward.h"
#include "base/functional/callback_helpers.h"
#include "base/location.h"
#include "base/logging.h"
#include "base/memory/free_deleter.h"
#include "base/memory/raw_ptr_exclusion.h"
#include "base/strings/string_util.h"
#include "base/task/single_thread_task_runner.h"
#include "base/task/task_runner.h"
#include "base/task/thread_pool.h"
#include "build/build_config.h"
#include "build/chromeos_buildflags.h"
#include "ui/events/event_constants.h"
#include "ui/events/keycodes/dom/dom_code.h"
#include "ui/events/keycodes/dom/dom_key.h"
#include "ui/events/keycodes/dom/keycode_converter.h"
#include "ui/events/keycodes/keyboard_code_conversion.h"
#include "ui/events/keycodes/keyboard_code_conversion_xkb.h"

namespace ui {

namespace {

LoadKeymapCallback;

KeyboardCode AlphanumericKeyboardCode(xkb_keysym_t xkb_keysym,
                                      char16_t character) { … }

// These tables map layout-dependent printable characters/codes
// to legacy Windows-based VKEY values.
//
// VKEYs are determined by the character produced from a DomCode without
// any modifiers, plus zero or more of the DomCode itself, the character
// produced with the Shift modifier, and the character produced with the
// AltGr modifier.

// A table of one or more PrintableSubEntry cases applies when the VKEY is
// not determined by the unmodified character value alone. Each such table
// corresponds to one unmodified character value. For an entry to match,
// the dom_code must match, and, if test_X is set, then the character for
// the key plus modifier X must also match.
struct PrintableSubEntry { … };

// The two designated Unicode "not-a-character" values are used as sentinels.
const char16_t kNone = …;
const char16_t kAny = …;

// U+0021 exclamation mark
const PrintableSubEntry kU0021[] = …;

// U+0022 quote
const PrintableSubEntry kU0022[] = …;

// U+0023 number sign
const PrintableSubEntry kU0023[] = …;  // ~, NoSymbol

// U+0024 dollar sign
const PrintableSubEntry kU0024[] = …;

// U+0027 apostrophe
const PrintableSubEntry kU0027[] = …;      // quote

// U+0028 left parenthesis
const PrintableSubEntry kU0028[] = …;

// U+0029 right parenthesis
const PrintableSubEntry kU0029[] = …;

// U+002A *
const PrintableSubEntry kU002A[] = …;

// U+002B plus sign
const PrintableSubEntry kU002B[] = …;  // ?

// U+002C comma
const PrintableSubEntry kU002C[] = …;

// U+002D hyphen-minus
const PrintableSubEntry kU002D[] = …;  // _

// U+002E full stop
const PrintableSubEntry kU002E[] = …;

// U+002F /
const PrintableSubEntry kU002F[] = …;  // ?

// U+003A colon
const PrintableSubEntry kU003A[] = …;

// U+003B semicolon
const PrintableSubEntry kU003B[] = …;
// U+003D =
const PrintableSubEntry kU003D[] = …;  // %, NoSymbol

// U+003F ?
const PrintableSubEntry kU003F[] = …;

// U+0040 @
const PrintableSubEntry kU0040[] = …;

// U+005B left square bracket
const PrintableSubEntry kU005B[] = …;

// U+005C backslash
const PrintableSubEntry kU005C[] = …;  // |, N cedilla

// U+005D right square bracket
const PrintableSubEntry kU005D[] = …;

// U+005F _
const PrintableSubEntry kU005F[] = …;

// U+0060 grave accent
const PrintableSubEntry kU0060[] = …;  // ~

// U+00A7 section
const PrintableSubEntry kU00A7[] = …;  // one half

// U+00AB left-pointing double angle quote
const PrintableSubEntry kU00AB[] = …;

// U+00B0 degree
const PrintableSubEntry kU00B0[] = …;

// U+00BA masculine ordinal indicator
const PrintableSubEntry kU00BA[] = …;

// U+00E0 a grave
const PrintableSubEntry kU00E0[] = …;  // a diaeresis

// U+00E1 a acute
const PrintableSubEntry kU00E1[] = …;

// U+00E2 a circumflex
const PrintableSubEntry kU00E2[] = …;

// U+00E4 a diaeresis
const PrintableSubEntry kU00E4[] = …;  // A dia.

// U+00E6 ae
const PrintableSubEntry kU00E6[] = …;

// U+00E7 c cedilla
const PrintableSubEntry kU00E7[] = …;  // C ced., NoSy

// U+00E8 e grave
const PrintableSubEntry kU00E8[] = …;

// U+00E9 e acute
const PrintableSubEntry kU00E9[] = …;  // o diaeresis

// U+00ED i acute
const PrintableSubEntry kU00ED[] = …;

// U+00F0 eth
const PrintableSubEntry kU00F0[] = …;

// U+00F3 o acute
const PrintableSubEntry kU00F3[] = …;

// U+00F4 o circumflex
const PrintableSubEntry kU00F4[] = …;

// U+00F6 o diaeresis
const PrintableSubEntry kU00F6[] = …;  // O diaresis

// U+00F8 o stroke
const PrintableSubEntry kU00F8[] = …;

// U+00F9 u grave
const PrintableSubEntry kU00F9[] = …;

// U+00FA u acute
const PrintableSubEntry kU00FA[] = …;

// U+00FC u diaeresis
const PrintableSubEntry kU00FC[] = …;  // U diaresis

// U+0103 a breve
const PrintableSubEntry kU0103[] = …;

// U+0105 a ogonek
const PrintableSubEntry kU0105[] = …;

// U+010D c caron
const PrintableSubEntry kU010D[] = …;

// U+0111 d stroke
const PrintableSubEntry kU0111[] = …;

// U+0117 e dot above
const PrintableSubEntry kU0117[] = …;

// U+0119 e ogonek
const PrintableSubEntry kU0119[] = …;  // E ogonek

// U+012F i ogonek
const PrintableSubEntry kU012F[] = …;  // Iogonek

// U+0142 l stroke
const PrintableSubEntry kU0142[] = …;

// U+015F s cedilla
const PrintableSubEntry kU015F[] = …;

// U+0161 s caron
const PrintableSubEntry kU0161[] = …;

// U+016B u macron
const PrintableSubEntry kU016B[] = …;

// U+0173 u ogonek
const PrintableSubEntry kU0173[] = …;  // U ogonek

// U+017C z dot above
const PrintableSubEntry kU017C[] = …;

// U+017E z caron
const PrintableSubEntry kU017E[] = …;

// Table mapping unshifted characters to PrintableSubEntry tables.
struct PrintableMultiEntry { … };

// Entries are ordered by character value.
const PrintableMultiEntry kMultiMap[] = …;

// Table mapping unshifted characters to VKEY values.
struct PrintableSimpleEntry { … };

// Entries are ordered by character value.
const PrintableSimpleEntry kSimpleMap[] = …;

#if BUILDFLAG(IS_CHROMEOS_ASH)
void LoadKeymap(const std::string& layout_name,
                scoped_refptr<base::SingleThreadTaskRunner> reply_runner,
                LoadKeymapCallback reply_callback) {
  std::string layout_id;
  std::string layout_variant;
  XkbKeyboardLayoutEngine::ParseLayoutName(layout_name, &layout_id,
                                           &layout_variant);
  xkb_rule_names names = {.rules = NULL,
                          .model = "pc101",
                          .layout = layout_id.c_str(),
                          .variant = layout_variant.c_str(),
                          .options = ""};
  std::unique_ptr<xkb_context, XkbContextDeleter> context;
  context.reset(xkb_context_new(XKB_CONTEXT_NO_DEFAULT_INCLUDES));
  xkb_context_include_path_append(context.get(), "/usr/share/X11/xkb");
  std::unique_ptr<xkb_keymap, XkbKeymapDeleter> keymap;
  keymap.reset(xkb_keymap_new_from_names(context.get(), &names,
                                         XKB_KEYMAP_COMPILE_NO_FLAGS));
  if (keymap) {
    std::unique_ptr<char, base::FreeDeleter> keymap_str(
        xkb_keymap_get_as_string(keymap.get(), XKB_KEYMAP_FORMAT_TEXT_V1));
    reply_runner->PostTask(
        FROM_HERE, base::BindOnce(std::move(reply_callback), layout_name,
                                  std::move(keymap_str)));
  } else {
    LOG(FATAL) << "Keymap file failed to load: " << layout_name;
  }
}
#endif

bool IsControlCharacter(uint32_t character) { … }

}  // anonymous namespace

XkbKeyCodeConverter::XkbKeyCodeConverter() { … }

XkbKeyCodeConverter::~XkbKeyCodeConverter() { … }

XkbKeyboardLayoutEngine::XkbKeyboardLayoutEngine(
    const XkbKeyCodeConverter& converter)
    : … { … }

XkbKeyboardLayoutEngine::~XkbKeyboardLayoutEngine() { … }

std::string_view XkbKeyboardLayoutEngine::GetLayoutName() const { … }

bool XkbKeyboardLayoutEngine::CanSetCurrentLayout() const { … }

void XkbKeyboardLayoutEngine::SetCurrentLayoutByName(
    const std::string& layout_name,
    base::OnceCallback<void(bool)> callback) { … }

void XkbKeyboardLayoutEngine::OnKeymapLoaded(
    base::OnceCallback<void(bool)> callback,
    const std::string& layout_name,
    std::unique_ptr<char, base::FreeDeleter> keymap_str) { … }

bool XkbKeyboardLayoutEngine::UsesISOLevel5Shift() const { … }

bool XkbKeyboardLayoutEngine::UsesAltGr() const { … }

bool XkbKeyboardLayoutEngine::Lookup(DomCode dom_code,
                                     int flags,
                                     DomKey* dom_key,
                                     KeyboardCode* key_code) const { … }

void XkbKeyboardLayoutEngine::SetInitCallbackForTest(
    base::OnceClosure closure) { … }

bool XkbKeyboardLayoutEngine::SetCurrentLayoutFromBuffer(
    const char* keymap_string,
    size_t size) { … }

void XkbKeyboardLayoutEngine::SetKeymap(xkb_keymap* keymap) { … }

xkb_mod_mask_t XkbKeyboardLayoutEngine::EventFlagsToXkbFlags(
    int ui_flags) const { … }

int XkbKeyboardLayoutEngine::UpdateModifiers(uint32_t depressed,
                                             uint32_t latched,
                                             uint32_t locked,
                                             uint32_t group) { … }

DomCode XkbKeyboardLayoutEngine::GetDomCodeByKeysym(
    uint32_t keysym,
    const std::optional<std::vector<std::string_view>>& modifiers) const { … }

bool XkbKeyboardLayoutEngine::XkbLookup(xkb_keycode_t xkb_keycode,
                                        xkb_mod_mask_t xkb_flags,
                                        xkb_keysym_t* xkb_keysym,
                                        uint32_t* character) const { … }

KeyboardCode XkbKeyboardLayoutEngine::DifficultKeyboardCode(
    DomCode dom_code,
    int ui_flags,
    xkb_keycode_t xkb_keycode,
    xkb_mod_mask_t xkb_flags,
    xkb_keysym_t xkb_keysym,
    char16_t character) const { … }

char16_t XkbKeyboardLayoutEngine::XkbSubCharacter(xkb_keycode_t xkb_keycode,
                                                  xkb_mod_mask_t base_flags,
                                                  char16_t base_character,
                                                  xkb_mod_mask_t flags) const { … }

void XkbKeyboardLayoutEngine::ParseLayoutName(const std::string& layout_name,
                                              std::string* layout_id,
                                              std::string* layout_variant) { … }

}  // namespace ui
chromium/ui/events/ozone/layout/xkb/xkb_keyboard_layout_engine.cc
