client/X11/keyboard_x11.c

 
#include <string.h>
 
#include <X11/X.h>
#include <X11/Xatom.h>
#include <X11/Xlib.h>
 
#include "xf_debug.h"
#include "keyboard_x11.h"
#include "xkb_layout_ids.h"
#include "xf_utils.h"
 
static BOOL parse_xkb_rule_names(char* xkb_rule, unsigned long num_bytes, char** layout,
                                 char** variant)
{
  /* Sample output for "Canadian Multilingual Standard"
   *
   * _XKB_RULES_NAMES_BACKUP(STRING) = "xorg", "pc105", "ca", "multi", "magic"
   *
   *  Format: "rules", "model", "layout", "variant", "options"
   *
   * Where "xorg" is the set of rules
   * "pc105" the keyboard model
   * "ca" the keyboard layout(s) (can also be something like 'us,uk')
   * "multi" the keyboard layout variant(s)  (in the examples, “,winkeys” - which means first
   *         layout uses some “default” variant and second uses “winkeys” variant)
   * "magic" - configuration option (in the examples,
   * “eurosign:e,lv3:ralt_switch,grp:rctrl_toggle”
   *         - three options)
   */
  for (size_t i = 0, index = 0; i < num_bytes; i++, index++)
  {
    char* ptr = xkb_rule + i;
    i += strnlen(ptr, num_bytes - i);
 
    switch (index)
    {
      case 0: // rules
        break;
      case 1: // model
        break;
      case 2: // layout
      {
        /* If multiple languages are present we just take the first one */
        char* delimiter = strchr(ptr, ',');
        if (delimiter)
          *delimiter = '\0';
        *layout = ptr;
        break;
      }
      case 3: // variant
      {
        /* If multiple variants are present we just take the first one */
        char* delimiter = strchr(ptr, ',');
        if (delimiter)
          *delimiter = '\0';
        *variant = ptr;
      }
      break;
      case 4: // option
        break;
      default:
        break;
    }
  }
  return TRUE;
}
 
static DWORD kbd_layout_id_from_x_property(wLog* log, Display* display, Window root,
                                           char* property_name)
{
  char* layout = NULL;
  char* variant = NULL;
  char* rule = NULL;
  Atom type = None;
  int item_size = 0;
  unsigned long items = 0;
  unsigned long unread_items = 0;
  DWORD layout_id = 0;
 
  Atom property = XInternAtom(display, property_name, False);
  if (property == None)
    return 0;
 
  if (LogDynAndXGetWindowProperty(log, display, root, property, 0, 1024, False, XA_STRING, &type,
                                  &item_size, &items, &unread_items,
                                  (unsigned char**)&rule) != Success)
    return 0;
 
  if (type != XA_STRING || item_size != 8 || unread_items != 0)
  {
    XFree(rule);
    return 0;
  }
 
  parse_xkb_rule_names(rule, items, &layout, &variant);
 
  DEBUG_X11("%s layout: %s, variant: %s", property_name, layout, variant);
  layout_id = xf_find_keyboard_layout_in_xorg_rules(layout, variant);
 
  XFree(rule);
 
  return layout_id;
}
 
int xf_detect_keyboard_layout_from_xkb(wLog* log, DWORD* keyboardLayoutId)
{
  Display* display = XOpenDisplay(NULL);
 
  if (!display)
    return 0;
 
  Window root = DefaultRootWindow(display);
  if (!root)
    return 0;
 
  /* We start by looking for _XKB_RULES_NAMES_BACKUP which appears to be used by libxklavier */
  DWORD id = kbd_layout_id_from_x_property(log, display, root, "_XKB_RULES_NAMES_BACKUP");
 
  if (0 == id)
    id = kbd_layout_id_from_x_property(log, display, root, "_XKB_RULES_NAMES");
 
  if (0 != id)
    *keyboardLayoutId = id;
 
  LogDynAndXCloseDisplay(log, display);
  return (int)id;
}