@vscodium/native-keymap 3.3.7-258412

package/src/keyboard_x.cc

@@ -0,0 +1,407 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+#include "keymapping.h"
+#include "string_conversion.h"
+#include "common.h"
+
+#include <X11/XKBlib.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/extensions/XKBrules.h>
+
+#include "../deps/chromium/macros.h"
+#include "../deps/chromium/x/keysym_to_unicode.h"
+
+typedef struct _XDisplay XDisplay;
+
+namespace {
+
+class KeyModifierMaskToXModifierMask {
+ public:
+  static KeyModifierMaskToXModifierMask& GetInstance() {
+    static KeyModifierMaskToXModifierMask instance;
+    return instance;
+  }
+
+  void Initialize(Display* display) {
+    alt_modifier_ = 0;
+    meta_modifier_ = 0;
+    num_lock_modifier_ = 0;
+    mode_switch_modifier_ = 0;
+    level3_modifier_ = 0;  // AltGr is often mapped to the level3 modifier
+    level5_modifier_ = 0;  // AltGr is mapped to the level5 modifier in the Neo layout family
+    effective_group_index_ = 0;
+
+    if (!display) {
+      return;
+    }
+
+    // See https://www.x.org/releases/X11R7.6/doc/libX11/specs/XKB/xkblib.html#determining_keyboard_state
+    XkbStateRec xkb_state;
+    XkbGetState(display, XkbUseCoreKbd, &xkb_state);
+    effective_group_index_ = xkb_state.group;
+
+    XModifierKeymap* mod_map = XGetModifierMapping(display);
+    int max_mod_keys = mod_map->max_keypermod;
+    for (int mod_index = 0; mod_index <= 8; ++mod_index) {
+      for (int key_index = 0; key_index < max_mod_keys; ++key_index) {
+        int key = mod_map->modifiermap[mod_index * max_mod_keys + key_index];
+        if (!key) {
+          continue;
+        }
+
+        int keysym = XkbKeycodeToKeysym(display, key, 0, 0);
+        if (!keysym) {
+          continue;
+        }
+
+        if (keysym == XK_Alt_L || keysym == XK_Alt_R) {
+          alt_modifier_ = 1 << mod_index;
+        }
+        if (keysym == XK_Mode_switch) {
+          mode_switch_modifier_ = 1 << mod_index;
+        }
+        if (keysym == XK_Meta_L || keysym == XK_Super_L || keysym == XK_Meta_R || keysym == XK_Super_R) {
+          meta_modifier_ = 1 << mod_index;
+        }
+        if (keysym == XK_Num_Lock) {
+          num_lock_modifier_ = 1 << mod_index;
+        }
+        if (keysym == XK_ISO_Level3_Shift) {
+          level3_modifier_ = 1 << mod_index;
+        }
+        if (keysym == XK_ISO_Level5_Shift) {
+          level5_modifier_ = 1 << mod_index;
+        }
+      }
+    }
+
+    XFreeModifiermap(mod_map);
+  }
+
+  int XStateFromKeyMod(int keyMod) {
+    int x_modifier = 0;
+
+    // Ctrl + Alt => AltGr
+    if (keyMod & kControlKeyModifierMask && keyMod & kAltKeyModifierMask) {
+      x_modifier |= mode_switch_modifier_;//alt_r_modifier;
+    } else if (keyMod & kControlKeyModifierMask) {
+      x_modifier |= ControlMask;
+    } else if (keyMod & kAltKeyModifierMask) {
+      x_modifier |= alt_modifier_;
+    }
+
+    if (keyMod & kShiftKeyModifierMask) {
+      x_modifier |= ShiftMask;
+    }
+
+    if (keyMod & kMetaKeyModifierMask) {
+      x_modifier |= meta_modifier_;
+    }
+
+    if (keyMod & kNumLockKeyModifierMask) {
+      x_modifier |= num_lock_modifier_;
+    }
+
+    if (keyMod & kLevel3KeyModifierMask) {
+      x_modifier |= level3_modifier_;
+    }
+
+    if (keyMod & kLevel5KeyModifierMask) {
+      x_modifier |= level5_modifier_;
+    }
+
+    // See https://www.x.org/releases/X11R7.6/doc/libX11/specs/XKB/xkblib.html#xkb_state_to_core_protocol_state_transformation
+    x_modifier |= (effective_group_index_ << 13);
+
+    return x_modifier;
+  }
+
+ private:
+  KeyModifierMaskToXModifierMask() {
+    Initialize(NULL);
+  }
+
+  int alt_modifier_;
+  int meta_modifier_;
+  int num_lock_modifier_;
+  int mode_switch_modifier_;
+  int level3_modifier_;
+  int level5_modifier_;
+  int effective_group_index_;
+
+  KeyModifierMaskToXModifierMask(const KeyModifierMaskToXModifierMask&) = delete;
+  KeyModifierMaskToXModifierMask& operator=(const KeyModifierMaskToXModifierMask&) = delete;
+};
+
+std::string GetStrFromXEvent(const XEvent* xev) {
+  const XKeyEvent* xkey = &xev->xkey;
+  KeySym keysym = XK_VoidSymbol;
+  XLookupString(const_cast<XKeyEvent*>(xkey), NULL, 0, &keysym, NULL);
+  uint16_t character = ui::GetUnicodeCharacterFromXKeySym(keysym);
+
+  if (!character)
+    return std::string();
+
+  wchar_t value = character;
+
+  return vscode_keyboard::UTF16toUTF8(&value, 1);
+}
+
+} // namespace
+
+
+namespace vscode_keyboard {
+
+#define DOM_CODE(usb, evdev, xkb, win, mac, code, id) {usb, xkb, code}
+#define DOM_CODE_DECLARATION const KeycodeMapEntry usb_keycode_map[] =
+#include "../deps/chromium/dom_code_data.inc"
+#undef DOM_CODE
+#undef DOM_CODE_DECLARATION
+
+napi_value GetKeyMapImpl(napi_env env, napi_callback_info info) {
+
+  napi_value result;
+  NAPI_CALL(env, napi_create_object(env, &result));
+
+  Display *display;
+  if (!(display = XOpenDisplay(""))) {
+    return result;
+  }
+
+  XEvent event;
+  memset(&event, 0, sizeof(XEvent));
+  XKeyEvent* key_event = &event.xkey;
+  key_event->display = display;
+  key_event->type = KeyPress;
+
+  KeyModifierMaskToXModifierMask *mask_provider = &KeyModifierMaskToXModifierMask::GetInstance();
+  mask_provider->Initialize(display);
+
+  size_t cnt = sizeof(usb_keycode_map) / sizeof(usb_keycode_map[0]);
+
+  for (size_t i = 0; i < cnt; ++i) {
+    const char *code = usb_keycode_map[i].code;
+    int native_keycode = usb_keycode_map[i].native_keycode;
+
+    if (!code || native_keycode <= 0) {
+      continue;
+    }
+
+    napi_value entry;
+    NAPI_CALL(env, napi_create_object(env, &entry));
+
+    key_event->keycode = native_keycode;
+    {
+      key_event->state = mask_provider->XStateFromKeyMod(0);
+      std::string value = GetStrFromXEvent(&event);
+      NAPI_CALL(env, napi_set_named_property_string_utf8(env, entry, "value", value.c_str()));
+    }
+
+    {
+      key_event->state = mask_provider->XStateFromKeyMod(kShiftKeyModifierMask);
+      std::string with_shift = GetStrFromXEvent(&event);
+      NAPI_CALL(env, napi_set_named_property_string_utf8(env, entry, "withShift", with_shift.c_str()));
+    }
+
+    {
+      key_event->state = mask_provider->XStateFromKeyMod(kLevel3KeyModifierMask);
+      std::string with_alt_gr = GetStrFromXEvent(&event);
+      NAPI_CALL(env, napi_set_named_property_string_utf8(env, entry, "withAltGr", with_alt_gr.c_str()));
+    }
+
+    {
+      key_event->state = mask_provider->XStateFromKeyMod(kShiftKeyModifierMask | kLevel3KeyModifierMask);
+      std::string with_shift_alt_gr = GetStrFromXEvent(&event);
+      NAPI_CALL(env, napi_set_named_property_string_utf8(env, entry, "withShiftAltGr", with_shift_alt_gr.c_str()));
+    }
+
+    {
+      // level 5 is important for the Neo layout family
+      key_event->state = mask_provider->XStateFromKeyMod(kLevel5KeyModifierMask);
+      std::string with_level5 = GetStrFromXEvent(&event);
+      NAPI_CALL(env, napi_set_named_property_string_utf8(env, entry, "withLevel5", with_level5.c_str()));
+    }
+
+    {
+      // level3 + level5 is Level 6 in terms of the Neo layout family. (Shift + level5 has no special meaning.)
+      key_event->state = mask_provider->XStateFromKeyMod(kLevel3KeyModifierMask | kLevel5KeyModifierMask);
+      std::string with_level3_level5 = GetStrFromXEvent(&event);
+      NAPI_CALL(env, napi_set_named_property_string_utf8(env, entry, "withLevel3Level5", with_level3_level5.c_str()));
+    }
+
+    NAPI_CALL(env, napi_set_named_property(env, result, code, entry));
+  }
+
+  XFlush(display);
+  XCloseDisplay(display);
+
+  return result;
+}
+
+napi_value GetCurrentKeyboardLayoutImpl(napi_env env, napi_callback_info info) {
+
+  napi_value result;
+  NAPI_CALL(env, napi_get_null(env, &result));
+
+  Display *display;
+  if (!(display = XOpenDisplay(""))) {
+    return result;
+  }
+
+  // See https://www.x.org/releases/X11R7.6/doc/libX11/specs/XKB/xkblib.html#determining_keyboard_state
+  XkbStateRec xkb_state;
+  XkbGetState(display, XkbUseCoreKbd, &xkb_state);
+  int effective_group_index = xkb_state.group;
+
+  XkbRF_VarDefsRec vdr;
+  char *tmp = NULL;
+  int res = XkbRF_GetNamesProp(display, &tmp, &vdr);
+  if (res) {
+    NAPI_CALL(env, napi_create_object(env, &result));
+
+    NAPI_CALL(env, napi_set_named_property_string_utf8(env, result, "model", vdr.model ? vdr.model : ""));
+    NAPI_CALL(env, napi_set_named_property_int32(env, result, "group", effective_group_index));
+    NAPI_CALL(env, napi_set_named_property_string_utf8(env, result, "layout", vdr.layout ? vdr.layout : ""));
+    NAPI_CALL(env, napi_set_named_property_string_utf8(env, result, "variant", vdr.variant ? vdr.variant : ""));
+    NAPI_CALL(env, napi_set_named_property_string_utf8(env, result, "options", vdr.options ? vdr.options : ""));
+    NAPI_CALL(env, napi_set_named_property_string_utf8(env, result, "rules", tmp ? tmp : ""));
+  }
+
+  XFlush(display);
+  XCloseDisplay(display);
+  return result;
+}
+
+typedef struct {
+  int effective_group_index;
+  std::string layout;
+  std::string variant;
+} KbState;
+
+bool KbStatesEqual(KbState *a, KbState *b) {
+  return (
+    a->effective_group_index == b->effective_group_index
+    && a->layout == b->layout
+    && a->variant == b->variant
+  );
+}
+
+void ReadKbState(Display *display, KbState *dst) {
+  // See https://www.x.org/releases/X11R7.6/doc/libX11/specs/XKB/xkblib.html#determining_keyboard_state
+  // Get effective group index
+  XkbStateRec xkb_state;
+  XkbGetState(display, XkbUseCoreKbd, &xkb_state);
+  dst->effective_group_index = xkb_state.group;
+
+  XkbRF_VarDefsRec vdr;
+  char *tmp = NULL;
+  int res = XkbRF_GetNamesProp(display, &tmp, &vdr);
+  if (res) {
+    dst->layout = (vdr.layout ? vdr.layout : "");
+    dst->variant = (vdr.variant ? vdr.variant : "");
+  } else {
+    dst->layout = "";
+    dst->variant = "";
+  }
+}
+
+static void FlushAndCloseDisplay(void *arg) {
+  Display *display = static_cast<Display*>(arg);
+  XFlush(display);
+  XCloseDisplay(display);
+}
+
+void* ListenToXEvents(void *arg) {
+  NotificationCallbackData *data = static_cast<NotificationCallbackData*>(arg);
+
+  Display *display;
+  if (!(display = XOpenDisplay(""))) {
+    return NULL;
+  }
+
+  pthread_cleanup_push(FlushAndCloseDisplay, display);
+
+  int xkblib_major = XkbMajorVersion;
+  int xkblib_minor = XkbMinorVersion;
+  if (!XkbLibraryVersion(&xkblib_major, &xkblib_minor)) {
+    return NULL;
+  }
+
+  int opcode = 0;
+  int xkb_base_event_code = 0;
+  int xkb_base_error_code = 0;
+  if (!XkbQueryExtension(display, &opcode, &xkb_base_event_code, &xkb_base_error_code, &xkblib_major, &xkblib_minor)) {
+    return NULL;
+  }
+
+  // See https://www.x.org/releases/X11R7.6/doc/libX11/specs/XKB/xkblib.html#xkb_event_types
+  // Listen only to the `XkbStateNotify` event
+  XkbSelectEvents(display, XkbUseCoreKbd, XkbAllEventsMask, XkbStateNotifyMask);
+
+  KbState last_state;
+  ReadKbState(display, &last_state);
+
+  XkbEvent event;
+  KbState current_state;
+  fd_set in_fds;
+  struct timeval tv;
+  int x11_fd = ConnectionNumber(display);
+
+  while (true) {
+    // See https://stackoverflow.com/a/8592969 which explains
+    // the technique of waiting for an XEvent with a timeout
+
+    // Create a File Description Set containing x11_fd
+    FD_ZERO(&in_fds);
+    FD_SET(x11_fd, &in_fds);
+
+    // Set the timer to 1s.
+    tv.tv_usec = 0;
+    tv.tv_sec = 1;
+
+    // Wait for X Event or the timer
+    select(x11_fd + 1, &in_fds, NULL, NULL, &tv);
+
+    // Handle pending XEvents
+    while (XPending(display)) {
+
+      XNextEvent(display, &event.core);
+
+      if (event.type == xkb_base_event_code && event.any.xkb_type == XkbStateNotify) {
+        ReadKbState(display, &current_state);
+        // printf("current state: %d | %s | %s\n", current_state.effective_group_index, current_state.layout.c_str(), current_state.variant.c_str());
+        if (!KbStatesEqual(&last_state, &current_state)) {
+          last_state.effective_group_index = current_state.effective_group_index;
+          last_state.layout = current_state.layout;
+          last_state.variant = current_state.variant;
+
+          InvokeNotificationCallback(data);
+        }
+      }
+    }
+  }
+
+  pthread_cleanup_pop(1);
+
+  return NULL;
+}
+
+void RegisterKeyboardLayoutChangeListenerImpl(NotificationCallbackData *data) {
+  pthread_create(&data->tid, NULL, &ListenToXEvents, data);
+}
+
+void DisposeKeyboardLayoutChangeListenerImpl(NotificationCallbackData *data) {
+  pthread_cancel(data->tid);
+  void *res;
+  pthread_join(data->tid, &res);
+}
+
+napi_value IsISOKeyboardImpl(napi_env env, napi_callback_info info) {
+  return napi_fetch_undefined(env);
+}
+
+} // namespace vscode_keyboard

package/src/keymapping.cc

@@ -0,0 +1,147 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+#define NODE_API_EXPERIMENTAL_NOGC_ENV_OPT_OUT
+#include <node.h>
+#include <map>
+
+#include "keymapping.h"
+#include "common.h"
+
+namespace vscode_keyboard {
+
+napi_status napi_set_named_property_string_utf8(napi_env env, napi_value object, const char *utf8_name, const char *value) {
+  napi_value _value;
+  NAPI_CALL_RETURN_STATUS(env, napi_create_string_utf8(env, value, NAPI_AUTO_LENGTH, &_value));
+  NAPI_CALL_RETURN_STATUS(env, napi_set_named_property(env, object, utf8_name, _value));
+  return napi_ok;
+}
+
+napi_status napi_set_named_property_int32(napi_env env, napi_value object, const char *utf8_name, int value) {
+  napi_value _value;
+  NAPI_CALL_RETURN_STATUS(env, napi_create_int32(env, value, &_value));
+  NAPI_CALL_RETURN_STATUS(env, napi_set_named_property(env, object, utf8_name, _value));
+  return napi_ok;
+}
+
+napi_value napi_fetch_null(napi_env env) {
+  napi_value result;
+  NAPI_CALL(env, napi_get_null(env, &result));
+  return result;
+}
+
+napi_value napi_fetch_undefined(napi_env env) {
+  napi_value result;
+  NAPI_CALL(env, napi_get_undefined(env, &result));
+  return result;
+}
+
+napi_value napi_fetch_boolean(napi_env env, bool value) {
+  napi_value result;
+  NAPI_CALL(env, napi_get_boolean(env, value, &result));
+  return result;
+}
+
+void InvokeNotificationCallback(NotificationCallbackData *data) {
+  if (data->tsfn == NULL) {
+    // This indicates we are in the shutdown phase and the thread safe function has been finalized
+    return;
+  }
+
+  // No need to call napi_acquire_threadsafe_function because
+  // the refcount is set to 1 in the main thread.
+  napi_call_threadsafe_function(data->tsfn, NULL, napi_tsfn_blocking);
+}
+
+static void NotifyJS(napi_env env, napi_value func, void* context, void* data) {
+  // env may be NULL if nodejs is shutting down
+  if (env != NULL) {
+    napi_value global;
+    NAPI_CALL_RETURN_VOID(env, napi_get_global(env, &global));
+
+    std::vector<napi_value> argv;
+    NAPI_CALL_RETURN_VOID(env, napi_call_function(env, global, func, argv.size(), argv.data(), NULL));
+  }
+}
+
+static void FinalizeThreadsafeFunction(napi_env env, void* raw_data, void* hint) {
+  NotificationCallbackData *data;
+  napi_get_instance_data(env, (void**)&data);
+  data->tsfn = NULL;
+}
+
+static void EnvCleanupHook(void *raw_data) {
+  NotificationCallbackData* data = static_cast<NotificationCallbackData*>(raw_data);
+  DisposeKeyboardLayoutChangeListenerImpl(data);
+}
+
+napi_value OnDidChangeKeyboardLayoutImpl(napi_env env, napi_callback_info info) {
+  size_t argc = 2;
+  napi_value args[2];
+  NotificationCallbackData *data;
+  NAPI_CALL(env, napi_get_instance_data(env, (void**)&data));
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  NAPI_ASSERT(env, argc == 1, "Wrong number of arguments. Expects a single argument.");
+
+  napi_valuetype valuetype0;
+  NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
+  NAPI_ASSERT(env, valuetype0 == napi_function, "Wrong type of arguments. Expects a function as first argument.");
+
+  napi_value func = args[0];
+
+  napi_value resource_name;
+  NAPI_CALL(env, napi_create_string_utf8(env, "onDidChangeKeyboardLayoutCallback", NAPI_AUTO_LENGTH, &resource_name));
+
+  // Convert the callback retrieved from JavaScript into a thread-safe function
+  napi_threadsafe_function tsfn;
+  NAPI_CALL(env, napi_create_threadsafe_function(env, func, NULL, resource_name, 0, 1, NULL,
+                                                 FinalizeThreadsafeFunction, NULL, NotifyJS,
+                                                 &tsfn));
+  data->tsfn = tsfn;
+
+  RegisterKeyboardLayoutChangeListenerImpl(data);
+
+  napi_add_env_cleanup_hook(env, EnvCleanupHook, data);
+
+  return napi_fetch_undefined(env);
+}
+
+void DeleteInstanceData(napi_env env, void *raw_data, void *hint) {
+  NotificationCallbackData *data = static_cast<NotificationCallbackData*>(raw_data);
+  delete data;
+}
+
+napi_value Init(napi_env env, napi_value exports) {
+  NotificationCallbackData *data = new NotificationCallbackData();
+  NAPI_CALL(env, napi_set_instance_data(env, data, DeleteInstanceData, NULL));
+
+  {
+    napi_value get_key_map_fn;
+    NAPI_CALL(env, napi_create_function(env, NULL, 0, GetKeyMapImpl, NULL, &get_key_map_fn));
+    NAPI_CALL(env, napi_set_named_property(env, exports, "getKeyMap", get_key_map_fn));
+  }
+  {
+    napi_value get_current_keyboard_layout_fn;
+    NAPI_CALL(env, napi_create_function(env, NULL, 0, GetCurrentKeyboardLayoutImpl, NULL, &get_current_keyboard_layout_fn));
+    NAPI_CALL(env, napi_set_named_property(env, exports, "getCurrentKeyboardLayout", get_current_keyboard_layout_fn));
+  }
+  {
+    napi_value on_did_change_keyboard_layout_fn;
+    NAPI_CALL(env, napi_create_function(env, NULL, 0, OnDidChangeKeyboardLayoutImpl, NULL, &on_did_change_keyboard_layout_fn));
+    NAPI_CALL(env, napi_set_named_property(env, exports, "onDidChangeKeyboardLayout", on_did_change_keyboard_layout_fn));
+  }
+  {
+    napi_value is_iso_keyboard_fn;
+    NAPI_CALL(env, napi_create_function(env, NULL, 0, IsISOKeyboardImpl, NULL, &is_iso_keyboard_fn));
+    NAPI_CALL(env, napi_set_named_property(env, exports, "isISOKeyboard", is_iso_keyboard_fn));
+  }
+
+  return exports;
+}
+
+NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)
+
+} // namespace vscode_keyboard

package/src/keymapping.h

@@ -0,0 +1,65 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+#ifndef KEYMAPPING_H_
+#define KEYMAPPING_H_
+
+#include <node_api.h>
+
+#include <string>
+#include <vector>
+#include "../deps/chromium/keyboard_codes.h"
+
+#if defined(__unix__)
+#include <pthread.h>
+#endif
+
+namespace vscode_keyboard {
+
+// This structure is used to define the keycode mapping table.
+// It is defined here because the unittests need access to it.
+typedef struct {
+  // USB keycode:
+  //  Upper 16-bits: USB Usage Page.
+  //  Lower 16-bits: USB Usage Id: Assigned ID within this usage page.
+  uint32_t usb_keycode;
+
+  // Contains one of the following:
+  //  On Linux: XKB scancode
+  //  On Windows: Windows OEM scancode
+  //  On Mac: Mac keycode
+  int native_keycode;
+
+  // The UIEvents (aka: DOM4Events) |code| value as defined in:
+  // http://www.w3.org/TR/DOM-Level-3-Events-code/
+  const char* code;
+} KeycodeMapEntry;
+
+typedef struct {
+#if defined(_WIN32)
+  void* listener;
+#endif
+#if defined(__unix__)
+  pthread_t tid;
+#endif
+  volatile napi_threadsafe_function tsfn;
+} NotificationCallbackData;
+
+napi_value GetKeyMapImpl(napi_env env, napi_callback_info info);
+napi_value GetCurrentKeyboardLayoutImpl(napi_env env, napi_callback_info info);
+void RegisterKeyboardLayoutChangeListenerImpl(NotificationCallbackData *data);
+void DisposeKeyboardLayoutChangeListenerImpl(NotificationCallbackData *data);
+napi_value IsISOKeyboardImpl(napi_env env, napi_callback_info info);
+
+void InvokeNotificationCallback(NotificationCallbackData *data);
+napi_status napi_set_named_property_string_utf8(napi_env env, napi_value object, const char *utf8_name, const char *value);
+napi_status napi_set_named_property_int32(napi_env env, napi_value object, const char *utf8_name, int value);
+napi_value napi_fetch_null(napi_env env);
+napi_value napi_fetch_undefined(napi_env env);
+napi_value napi_fetch_boolean(napi_env env, bool value);
+
+}  // namespace vscode_keyboard
+
+#endif  // KEYMAPPING_H_

package/src/string_conversion.cc

@@ -0,0 +1,67 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+#include "string_conversion.h"
+
+namespace vscode_keyboard {
+
+wchar_t conversion_buffer[10];
+
+std::string UTF16toUTF8(const wchar_t * in, int length) {
+  if (length < 10) {
+    for (int i = 0; i < length; ++i) {
+      conversion_buffer[i] = in[i];
+    }
+    conversion_buffer[length] = 0;
+    return UTF16to8(conversion_buffer);
+  }
+
+  wchar_t *t = new wchar_t[length + 1];
+  for (int i = 0; i < length; ++i) {
+    t[i] = in[i];
+  }
+  t[length] = 0;
+  std::string result = UTF16to8(t);
+  delete []t;
+
+  return result;
+}
+
+// http://stackoverflow.com/a/148766
+std::string UTF16to8(const wchar_t * in) {
+  std::string out;
+  unsigned int codepoint = 0;
+  for (;  *in != 0;  ++in) {
+    if (*in >= 0xd800 && *in <= 0xdbff) {
+      codepoint = ((*in - 0xd800) << 10) + 0x10000;
+    } else {
+      if (*in >= 0xdc00 && *in <= 0xdfff) {
+        codepoint |= *in - 0xdc00;
+      } else {
+        codepoint = *in;
+      }
+
+      if (codepoint <= 0x7f) {
+        out.append(1, static_cast<char>(codepoint));
+      } else if (codepoint <= 0x7ff) {
+        out.append(1, static_cast<char>(0xc0 | ((codepoint >> 6) & 0x1f)));
+        out.append(1, static_cast<char>(0x80 | (codepoint & 0x3f)));
+      } else if (codepoint <= 0xffff) {
+        out.append(1, static_cast<char>(0xe0 | ((codepoint >> 12) & 0x0f)));
+        out.append(1, static_cast<char>(0x80 | ((codepoint >> 6) & 0x3f)));
+        out.append(1, static_cast<char>(0x80 | (codepoint & 0x3f)));
+      } else {
+        out.append(1, static_cast<char>(0xf0 | ((codepoint >> 18) & 0x07)));
+        out.append(1, static_cast<char>(0x80 | ((codepoint >> 12) & 0x3f)));
+        out.append(1, static_cast<char>(0x80 | ((codepoint >> 6) & 0x3f)));
+        out.append(1, static_cast<char>(0x80 | (codepoint & 0x3f)));
+      }
+      codepoint = 0;
+    }
+  }
+  return out;
+}
+
+}  // namespace vscode_keyboard

package/src/string_conversion.h

@@ -0,0 +1,18 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+#ifndef STRING_CONVERSION_H_
+#define STRING_CONVERSION_H_
+
+#include <string>
+
+namespace vscode_keyboard {
+
+std::string UTF16to8(const wchar_t * in);
+std::string UTF16toUTF8(const wchar_t * in, int length);
+
+}  // namespace vscode_keyboard
+
+#endif  // STRING_CONVERSION_H_