gtk/gdk/win32/gdkkeys-win32-impl.c

/*
 * Copyright (c) 2021 Philip Zander
 * Copyright (c) 2018 Microsoft
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

/* NOTE: When compiling the 32-bit version of the library, in addition to being
 * compiled as a regular source file, this file is also included by
 * gdkkeys-win32-impl-wow64.c to generate an alternate version of the code
 * intended for running on a 64-bit kernel. Because of the way keyboard layout
 * DLLs work on Windows, we have to generate two versions and decide at runtime
 * which code path to execute. You can read more about the specifics below, in
 * the section about KBD_LONG_POINTER. */

#include "gdkkeys-win32.h"

#ifndef GDK_WIN32_COMPILE_FOR_WOW64
  #define GDK_WIN32_COMPILE_FOR_WOW64 0
#endif
 
/* This is our equivalent of the KBD_LONG_POINTER macro in Microsoft's kbd.h.
 *
 * A KBD_LONG_POINTER represents a pointer native to the *host*.
 * I.e. 32 bits on 32-bit Windows and 64 bits on 64-bit Windows.
 *
 * This is *not* the same as the the bitness of the application, since it is
 * possible to execute 32-bit binaries on either a 32-bit *or* a 64-bit host.
 * On a 64-bit host, KBD_LONG_PTR will be 64-bits, even if the application 
 * itself is 32-bit. (Whereas on a 32-bit host, it will be 32-bit.)
 *
 * For clarity, here is an overview of the bit-size of KBD_LONG_POINTER on all
 * possible host & app combinations:
 *
 *      Host  32  64
 *  App +-----------
 *  32  |     32  64
 *  64  |     -   64
 *
 * In the official MS headers, KBD_LONG_POINTER is implemented via a macro
 * which expands to the attribute `__ptr64` if the keyboard driver is 
 * compiled for a 64 bit host. Unfortunately, `__ptr64` is only 
 * supported by MSVC. We use a union here as a workaround.
 *
 * For all KBD_LONG_POINTERs, we define an alias starting with "KLP".
 * Our naming schema (inspired by the Windows headers) is thus the following:
 * - FOO:    The type FOO itself
 * - PFOO:   Regular pointer to the type FOO
 * - KLPFOO: Keyboard Long Pointer to the type FOO
 */

#if GDK_WIN32_COMPILE_FOR_WOW64
  #define DEFINE_KBD_LONG_POINTER(type)          \
    typedef union {                              \
      P##type ptr;                               \
      UINT64  _align;                            \
    } KLP##type
#else
  #define DEFINE_KBD_LONG_POINTER(type)          \
    typedef union {                              \
      P##type ptr;                               \
    } KLP##type
#endif

DEFINE_KBD_LONG_POINTER (USHORT);
DEFINE_KBD_LONG_POINTER (VOID);

/* Driver definitions
 * See
 *   https://github.com/microsoft/windows-rs/blob/0.28.0/crates/deps/sys/src/Windows/Win32/UI/Input/KeyboardAndMouse/mod.rs
 *
 * For more information on how these structures work, see also:
 *   https://github.com/microsoft/Windows-driver-samples/tree/f0adcda012820b1cd44a8b3a1953baf478029738/input/layout
 */

typedef struct
{
  BYTE                        Vk;
  BYTE                        ModBits;
} VK_TO_BIT, *PVK_TO_BIT;

DEFINE_KBD_LONG_POINTER (VK_TO_BIT);

typedef struct
{
  KLPVK_TO_BIT                pVkToBit;
  WORD                        wMaxModBits;
  BYTE                        ModNumber[1];
} MODIFIERS, *PMODIFIERS;

DEFINE_KBD_LONG_POINTER (MODIFIERS);

typedef struct
{
  BYTE                        Vsc;
  USHORT                      Vk;
} VSC_VK, *PVSC_VK;

DEFINE_KBD_LONG_POINTER (VSC_VK);

typedef struct
{
  BYTE                        Vk;
  BYTE                        Vsc;
} VK_VSC, *PVK_VSC;

DEFINE_KBD_LONG_POINTER (VK_VSC);

typedef struct
{
  BYTE                        VirtualKey;
  BYTE                        Attributes;
  WCHAR                       wch[1];
} VK_TO_WCHARS, *PVK_TO_WCHARS;

DEFINE_KBD_LONG_POINTER (VK_TO_WCHARS);

typedef struct
{
  KLPVK_TO_WCHARS             pVkToWchars;
  BYTE                        nModifications;
  BYTE                        cbSize;
} VK_TO_WCHAR_TABLE, *PVK_TO_WCHAR_TABLE;

DEFINE_KBD_LONG_POINTER (VK_TO_WCHAR_TABLE);

typedef struct
{
  DWORD                       dwBoth;
  WCHAR                       wchComposed;
  USHORT                      uFlags;
} DEADKEY, *PDEADKEY;

DEFINE_KBD_LONG_POINTER (DEADKEY);

typedef struct
{
  KLPMODIFIERS                pCharModifiers;
  KLPVK_TO_WCHAR_TABLE        pVkToWcharTable;
  KLPDEADKEY                  pDeadKey;
  KLPVOID                     pKeyNames;
  KLPVOID                     pKeyNamesExt;
  KLPVOID                     pKeyNamesDead;
  KLPUSHORT                   pusVSCtoVK;
  BYTE                        bMaxVSCtoVK;
  KLPVSC_VK                   pVSCtoVK_E0;
  KLPVSC_VK                   pVSCtoVK_E1;
  DWORD                       fLocaleFlags;
  BYTE                        nLgMaxd;
  BYTE                        cbLgEntry;
  KLPVOID                     pLigature;
} KBDTABLES, *PKBDTABLES;

DEFINE_KBD_LONG_POINTER (KBDTABLES);

/* End of declarations */

static BYTE
keystate_to_modbits (GdkWin32KeymapLayoutInfo *info,
                     const BYTE                keystate[256])
{
  PKBDTABLES tables = (PKBDTABLES) info->tables;
  PVK_TO_BIT vk_to_bit;
  BYTE       result = 0;
  int        i;

  if (tables == NULL)
    return 0;

  vk_to_bit = tables->pCharModifiers.ptr->pVkToBit.ptr;

  for (i = 0; vk_to_bit[i].Vk != 0; ++i)
    if (keystate[vk_to_bit[i].Vk] & 0x80)
      result |= vk_to_bit[i].ModBits;

  return result;
}

static BYTE
modbits_to_level (GdkWin32KeymapLayoutInfo *info,
                  BYTE                      modbits)
{
  PKBDTABLES tables = (PKBDTABLES) info->tables;
  PMODIFIERS modifiers;

  if (tables == NULL)
    return 0;

  modifiers = tables->pCharModifiers.ptr;
  if (modbits > modifiers->wMaxModBits)
    return 0;

  return modifiers->ModNumber[modbits];
}

#define POPCOUNT(b) (!!(b & 0x01) + !!(b & 0x02) + !!(b & 0x04) + !!(b & 0x08) + \
                     !!(b & 0x10) + !!(b & 0x20) + !!(b & 0x40) + !!(b & 0x80))

/*
 * vk_to_char_fuzzy:
 *
 * For a given key and modifier state, return the best-fit character and the
 * modifiers used to produce it. Note that not all modifiers need to be used,
 * because some modifier combination aren't actually mapped in the keyboard
 * layout (for example the Ctrl key typically has no effect, unless used in
 * combination with Alt). Such modifiers will not be consumed.
 *
 * 'Best-fit' means 'consume as many modifiers as possibe'.
 *
 * For example (assuming a neutral lock state):
 *
 * - a                -> 'a', consumed_mod_bits: []
 * - Shift + a        -> 'A', consumed_mod_bits: [Shift]
 * - Ctrl + a         -> 'a', consumed_mod_bits: []
 * - Ctrl + Shift + a -> 'A', consumed_mod_bits: [Shift]
 *
 * If capslock is active, the result could be:
 *
 * - a                -> 'A', consumed_mod_bits: [Shift]
 * - Shift + a        -> 'a', consumed_mod_bits: []
 * - Ctrl + a         -> 'a', consumed_mod_bits: []
 * - Ctrl + Shift + a -> 'A', consumed_mod_bits: [Shift]
 *
 * The held down modifiers are supplied in `mod_bits` as a bitmask of KBDSHIFT,
 * KBDCTRL, KBDALT etc.
 *
 * The toggled modifiers are supplied in `lock_state` as a bitmask of CAPLOK and KANALOK.
 *
 * If the key combination results in a dead key, `is_dead` will be set to TRUE,
 * otherwise it will be set to FALSE.
 */
static WCHAR
vk_to_char_fuzzy (GdkWin32KeymapLayoutInfo *info,
                  BYTE                      mod_bits,
                  BYTE                      lock_bits,
                  BYTE                     *consumed_mod_bits,
                  gboolean                 *is_dead,
                  BYTE                      vk)
{
  PKBDTABLES         tables = (PKBDTABLES) info->tables;

  PVK_TO_WCHAR_TABLE wch_tables;
  PVK_TO_WCHAR_TABLE wch_table;
  PVK_TO_WCHARS      entry;

  int                table_index;
  int                entry_index;
  int                n_levels;
  int                entry_size;

  /* Initialize with defaults */
  if (consumed_mod_bits)
    *consumed_mod_bits = 0;
  if (is_dead)
    *is_dead = FALSE;

  if (tables == NULL)
    return WCH_NONE;

  wch_tables = tables->pVkToWcharTable.ptr;

  table_index = info->vk_lookup_table[vk].table;
  entry_index = info->vk_lookup_table[vk].index;

  if (table_index == -1 || entry_index == -1)
    return WCH_NONE;

  wch_table = &wch_tables[table_index];

  n_levels = wch_table->nModifications;
  entry_size = wch_table->cbSize;

  entry = (PVK_TO_WCHARS) ((PBYTE) wch_table->pVkToWchars.ptr
                           + entry_size*entry_index);

  if (entry->VirtualKey == vk)
    {
      gboolean have_sgcaps    = FALSE;
      WCHAR    best_char      = WCH_NONE;
      BYTE     best_modifiers = 0;
      int      best_score     = -1;
      gboolean best_is_dead   = FALSE;
      int      level;

      /* Take toggled keys into account. For example, capslock normally inverts the
       * state of KBDSHIFT (with some exceptions). */

      /* Key supporting capslock */
      if ((entry->Attributes & CAPLOK) &&
          /* Ignore capslock if any modifiers other than shift are pressed.
           * E.g. on the German layout, CapsLock + AltGr + q is the same as
           * AltGr + q ('@'), but NOT the same as Shift + AltGr + q (not mapped). */
          !(mod_bits & ~KBDSHIFT) &&
          (lock_bits & CAPLOK))
        mod_bits ^= KBDSHIFT;

      /* Key supporting combination of capslock + altgr */
      if ((entry->Attributes & CAPLOKALTGR) &&
          (mod_bits & KBDALTGR) &&
          (lock_bits & CAPLOK))
        mod_bits ^= KBDSHIFT;

      /* In the Swiss German layout, CapsLock + key is different from Shift + key
       * for some keys. For such keys, the characters for active capslock are
       * in the next entry. */
      if ((entry->Attributes & SGCAPS) &&
          (lock_bits & CAPLOK))
        have_sgcaps = TRUE;

      /* I'm not totally sure how kanalok behaves, for now I assume that there
       * aren't any special cases. */
      if ((entry->Attributes & KANALOK) &&
          (lock_bits & KANALOK))
        mod_bits ^= KBDKANA;

      /* We try to find the entry with the most matching modifiers */
      for (level = 0; level < n_levels; ++level)
        {
          BYTE     candidate_modbits = info->level_to_modbits[level];
          gboolean candidate_is_dead = FALSE;
          WCHAR    c;
          int      score;

          if (candidate_modbits & ~mod_bits)
            continue;

          /* Some keys have bogus mappings for the control key, e.g.  Ctrl +
           * Backspace = Delete, Ctrl + [ = 0x1B or even  Ctrl + Shift + 6 =
           * 0x1E on a US keyboard. So we have to ignore all cases of
           * Ctrl that aren't part of AltGr.
           */
          if ((candidate_modbits & KBDCTRL) && !(candidate_modbits & KBDALT))
            continue;

          c = entry->wch[level];
          if (c == WCH_DEAD || have_sgcaps)
            {
              /* Next entry contains the undead/capslocked keys */
              PVK_TO_WCHARS next_entry;
              next_entry = (PVK_TO_WCHARS) ((PBYTE) wch_table->pVkToWchars.ptr
                                            + entry_size * (entry_index + 1));
              c = next_entry->wch[level];
              candidate_is_dead = TRUE;
            }

          if (c == WCH_DEAD || c == WCH_LGTR || c == WCH_NONE)
            continue;

          score = POPCOUNT (candidate_modbits & mod_bits);
          if (score > best_score)
            {
              best_score = score;
              best_char = c;
              best_modifiers = candidate_modbits;
              best_is_dead = candidate_is_dead;
            }
        }

      if (consumed_mod_bits)
        *consumed_mod_bits = best_modifiers;

      if (is_dead)
        *is_dead = best_is_dead;

      return best_char;
    }

  return WCH_NONE;
}

static void
init_vk_lookup_table (GdkWin32KeymapLayoutInfo *info)
{
  PKBDTABLES         tables = (PKBDTABLES) info->tables;
  PVK_TO_WCHAR_TABLE wch_tables;
  PMODIFIERS         modifiers;
  int                i, vk, table_idx;

  g_return_if_fail (tables != NULL);

  wch_tables = tables->pVkToWcharTable.ptr;

  /* Initialize empty table */
  memset (info->vk_lookup_table, -1, sizeof (info->vk_lookup_table));

  /* Initialize level -> modbits lookup table */
  memset (info->level_to_modbits, 0, sizeof(info->level_to_modbits));
  info->max_level = 0;

  modifiers = tables->pCharModifiers.ptr;
  for (i = 0; i <= modifiers->wMaxModBits; ++i)
    {
      if (modifiers->ModNumber[i] != SHFT_INVALID &&
          modifiers->ModNumber[i] != 0 /* Workaround for buggy layouts*/)
        {
          if (modifiers->ModNumber[i] > info->max_level)
              info->max_level = modifiers->ModNumber[i];
          info->level_to_modbits[modifiers->ModNumber[i]] = i;
        }
    }

  info->max_modbit_value = modifiers->wMaxModBits;

  /* For convenience, we add 256 identity-mapped entries corresponding to the VKs.
   * This allows us to return a pointer to them from the `gdk_keysym_to_key_entry`
   * function.
   */

  for (vk = 0; vk < 256; ++vk)
    {
      GdkWin32KeymapKeyEntry key_entry = {0};
      key_entry.vk       = vk;
      key_entry.mod_bits = 0;
      key_entry.next     = -1;
      g_array_append_val (info->key_entries, key_entry);
    }

  /* Special entry for ISO_Left_Tab */
  {
    GdkWin32KeymapKeyEntry key_entry = {0};
    key_entry.vk       = VK_TAB;
    key_entry.mod_bits = KBDSHIFT;
    key_entry.next     = -1;
    g_array_append_val (info->key_entries, key_entry);
  }

  /* Initialize generic vk <-> char tables */

  for (table_idx = 0; ; ++table_idx)
    {
      PVK_TO_WCHAR_TABLE wch_table = &wch_tables[table_idx];
      int entry_size;
      int n_levels;
      int entry_idx;

      if (wch_table->pVkToWchars.ptr == NULL)
        break;

      entry_size = wch_table->cbSize;
      n_levels   = wch_table->nModifications;

      for (entry_idx = 0; ; ++entry_idx)
        {
          PVK_TO_WCHARS entry;
          int           level;

          entry = (PVK_TO_WCHARS) ((PBYTE) wch_table->pVkToWchars.ptr
				   + entry_size * entry_idx);

          if (entry->VirtualKey == 0)
            break;

          /* Lookup table to find entry for a VK in O(1). */

          /* Only add the first entry, as some layouts (Swiss German) contain
           * multiple successive entries for the same VK (SGCAPS). */
          if (info->vk_lookup_table[entry->VirtualKey].table < 0)
            {
              info->vk_lookup_table[entry->VirtualKey].table = table_idx;
              info->vk_lookup_table[entry->VirtualKey].index = entry_idx;
            }

          /* Create reverse lookup entries to find a VK+modifier combinations
           * that results in a given character. */
          for (level = 0; level < n_levels; ++level)
            {
              GdkWin32KeymapKeyEntry key_entry = {0};
              WCHAR                  c         = entry->wch[level];
              int                    inserted_idx;
              gintptr                next_idx;

              key_entry.vk       = entry->VirtualKey;
              key_entry.mod_bits = info->level_to_modbits[level];

              /* There can be multiple combinations that produce the same character.
               * We store all of them in a linked list.
               * Check if we already have an entry for the character, so we can chain
               * them together. */
              if (g_hash_table_lookup_extended (info->reverse_lookup_table,
                                                GINT_TO_POINTER (c),
                                                NULL, (gpointer*)&next_idx))
                {
                  key_entry.next = next_idx;
                }
              else
                {
                  key_entry.next = -1;
                }

              /* We store the KeyEntry in an array. In the hash table we only store
               * the index. */

              g_array_append_val (info->key_entries, key_entry);
              inserted_idx = info->key_entries->len - 1;

              g_hash_table_insert (info->reverse_lookup_table,
                                   GINT_TO_POINTER (c),
                                   GINT_TO_POINTER (inserted_idx));
            }
        }
    }
}

static gboolean
load_layout_dll (const char               *dll,
                 GdkWin32KeymapLayoutInfo *info)
{
    typedef KLPKBDTABLES (*KbdLayerDescriptor)(VOID);

    HMODULE             lib;
    KbdLayerDescriptor  func;
    KLPKBDTABLES        tables;

    g_return_val_if_fail (dll != NULL, FALSE);

    lib = LoadLibraryA (dll);
    if (lib == NULL)
      goto fail1;

    func = (KbdLayerDescriptor) GetProcAddress (lib, "KbdLayerDescriptor");
    if (func == NULL)
      goto fail2;

    tables = func();

    info->lib = lib;
    info->tables = (PKBDTABLES) tables.ptr;

    return TRUE;

fail2:
    FreeLibrary (lib);
fail1:
    return FALSE;
}

#if GDK_WIN32_COMPILE_FOR_WOW64
  #define GDK_WIN32_KEYMAP_IMPL_NAME gdkwin32_keymap_impl_wow64
#else
  #define GDK_WIN32_KEYMAP_IMPL_NAME gdkwin32_keymap_impl
#endif

const GdkWin32KeymapImpl GDK_WIN32_KEYMAP_IMPL_NAME =
  {
    load_layout_dll,
    init_vk_lookup_table,
    keystate_to_modbits,
    modbits_to_level,
    vk_to_char_fuzzy
  };