XkbcommonKeymap.h

/*
 *  Copyright (C) 2017-2018 Team Kodi
 *  This file is part of Kodi - https://kodi.tv
 *
 *  SPDX-License-Identifier: GPL-2.0-or-later
 *  See LICENSES/README.md for more information.
 */

#pragma once

#include "input/keyboard/XBMC_keysym.h"

#include <cstdint>
#include <memory>
#include <vector>

#include <xkbcommon/xkbcommon-compose.h>
#include <xkbcommon/xkbcommon.h>
#ifdef TARGET_WEBOS
#include <xkbcommon/xkbcommon-webos-keysyms.h>
#endif

namespace KODI
{
namespace WINDOWING
{
namespace WAYLAND
{

enum class KeyComposerState
{
  IDLE,
  COMPOSING,
  FINISHED,
  CANCELLED
};

struct KeyComposerStatus
{
  KeyComposerState state{KeyComposerState::IDLE};
  std::uint32_t keysym{0};
};

class CXkbcommonKeymap
{
public:
  struct XkbKeymapDeleter
  {
    void operator()(xkb_keymap* keymap) const;
  };
  struct XkbComposeTableDeleter
  {
    void operator()(xkb_compose_table* composeTable) const;
  };

  explicit CXkbcommonKeymap(
      std::unique_ptr<xkb_keymap, XkbKeymapDeleter> keymap,
      std::unique_ptr<xkb_compose_table, XkbComposeTableDeleter> composeTable);

  xkb_keysym_t KeysymForKeycode(xkb_keycode_t code) const;
  void UpdateMask(xkb_mod_mask_t depressed,
                  xkb_mod_mask_t latched,
                  xkb_mod_mask_t locked,
                  xkb_mod_mask_t group);
  xkb_mod_mask_t CurrentModifiers() const;
  XBMCKey XBMCKeyForKeycode(xkb_keycode_t code) const;
  XBMCMod ActiveXBMCModifiers() const;
  std::uint32_t UnicodeCodepointForKeycode(xkb_keycode_t code) const;
  bool ShouldKeycodeRepeat(xkb_keycode_t code) const;
  bool SupportsKeyComposition() const;
  KeyComposerStatus KeyComposerFeed(xkb_keycode_t code);
  void KeyComposerFlush();

  static XBMCKey XBMCKeyForKeysym(xkb_keysym_t sym);

private:
  struct XkbStateDeleter
  {
    void operator()(xkb_state* state) const;
  };
  struct XkbComposeStateDeleter
  {
    void operator()(xkb_compose_state* state) const;
  };
  static std::unique_ptr<xkb_state, XkbStateDeleter> CreateXkbStateFromKeymap(xkb_keymap* keymap);
  static std::unique_ptr<xkb_compose_state, XkbComposeStateDeleter>
  CreateXkbComposedStateStateFromTable(xkb_compose_table* composeTable);

  std::unique_ptr<xkb_keymap, XkbKeymapDeleter> m_keymap;
  std::unique_ptr<xkb_state, XkbStateDeleter> m_state;
  std::unique_ptr<xkb_compose_state, XkbComposeStateDeleter> m_composeState;

  struct ModifierMapping
  {
    xkb_mod_index_t xkb;
    XBMCMod xbmc;
    ModifierMapping(xkb_mod_index_t xkb, XBMCMod xbmc)
    : xkb{xkb}, xbmc{xbmc}
    {}
  };
  std::vector<ModifierMapping> m_modifierMappings;
};

class CXkbcommonContext
{
public:
  explicit CXkbcommonContext(xkb_context_flags flags = XKB_CONTEXT_NO_FLAGS);

  std::unique_ptr<CXkbcommonKeymap> LocalizedKeymapFromString(const std::string& keymap,
                                                              const std::string& locale);

private:
  struct XkbContextDeleter
  {
    void operator()(xkb_context* ctx) const;
  };
  std::unique_ptr<xkb_context, XkbContextDeleter> m_context;
};


}
}
}