tools/how-to-type.c

   1 /*
   2  * Copyright © 2020 Ran Benita <ran@unusedvar.com>
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  */
  23
  24 #include "config.h"
  25
  26 #include <stdlib.h>
  27 #include <unistd.h>
  28 #include <errno.h>
  29
  30 #include "xkbcommon/xkbcommon.h"
  31
  32 #define ARRAY_SIZE(arr) ((sizeof(arr) / sizeof(*(arr))))
  33
  34 static void
  35 usage(const char *argv0)
  36 {
  37     fprintf(stderr, "Usage: %s [-r <rules>] [-m <model>] "
  38             "[-l <layout>] [-v <variant>] [-o <options>] <unicode codepoint>\n",
  39             argv0);
  40     fprintf(stderr, "Pipe into `column -ts $'\\t'` for nicely aligned output.\n");
  41     exit(2);
  42 }
  43
  44 int
  45 main(int argc, char *argv[])
  46 {
  47     int opt;
  48     const char *rules = NULL;
  49     const char *model = NULL;
  50     const char *layout_ = NULL;
  51     const char *variant = NULL;
  52     const char *options = NULL;
  53     int err = EXIT_FAILURE;
  54     struct xkb_context *ctx = NULL;
  55     char *endp;
  56     long val;
  57     uint32_t codepoint;
  58     xkb_keysym_t keysym;
  59     int ret;
  60     char name[200];
  61     struct xkb_keymap *keymap = NULL;
  62     xkb_keycode_t min_keycode, max_keycode;
  63     xkb_mod_index_t num_mods;
  64
  65     while ((opt = getopt(argc, argv, "r:m:l:v:o:")) != -1) {
  66         switch (opt) {
  67         case 'r':
  68             rules = optarg;
  69             break;
  70         case 'm':
  71             model = optarg;
  72             break;
  73         case 'l':
  74             layout_ = optarg;
  75             break;
  76         case 'v':
  77             variant = optarg;
  78             break;
  79         case 'o':
  80             options = optarg;
  81             break;
  82         default:
  83             usage(argv[0]);
  84             exit(EXIT_INVALID_USAGE);
  85         }
  86     }
  87     if (argc - optind != 1) {
  88         usage(argv[0]);
  89         exit(EXIT_INVALID_USAGE);
  90     }
  91
  92     errno = 0;
  93     val = strtol(argv[optind], &endp, 0);
  94     if (errno != 0 || endp == argv[optind] || val < 0 || val > 0x10FFFF) {
  95         usage(argv[0]);
  96         exit(EXIT_INVALID_USAGE);
  97     }
  98     codepoint = (uint32_t) val;
  99
 100     keysym = xkb_utf32_to_keysym(codepoint);
 101     if (keysym == XKB_KEY_NoSymbol) {
 102         fprintf(stderr, "Failed to convert codepoint to keysym\n");
 103         goto err;
 104     }
 105
 106     ret = xkb_keysym_get_name(keysym, name, sizeof(name));
 107     if (ret < 0 || (size_t) ret >= sizeof(name)) {
 108         fprintf(stderr, "Failed to get name of keysym\n");
 109         goto err;
 110     }
 111
 112     ctx = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
 113     if (!ctx) {
 114         fprintf(stderr, "Failed to create XKB context\n");
 115         goto err;
 116     }
 117
 118     struct xkb_rule_names names = {
 119         .rules = rules,
 120         .model = model,
 121         .layout = layout_,
 122         .variant = variant,
 123         .options = options,
 124     };
 125     keymap = xkb_keymap_new_from_names(ctx, &names,
 126                                        XKB_KEYMAP_COMPILE_NO_FLAGS);
 127     if (!keymap) {
 128         fprintf(stderr, "Failed to create XKB keymap\n");
 129         goto err;
 130     }
 131
 132     printf("keysym: %s (%#x)\n", name, keysym);
 133     printf("KEYCODE\tKEY NAME\tLAYOUT#\tLAYOUT NAME\tLEVEL#\tMODIFIERS\n");
 134
 135     min_keycode = xkb_keymap_min_keycode(keymap);
 136     max_keycode = xkb_keymap_max_keycode(keymap);
 137     num_mods = xkb_keymap_num_mods(keymap);
 138     for (xkb_keycode_t keycode = min_keycode; keycode <= max_keycode; keycode++) {
 139         const char *key_name;
 140         xkb_layout_index_t num_layouts;
 141
 142         key_name = xkb_keymap_key_get_name(keymap, keycode);
 143         if (!key_name) {
 144             continue;
 145         }
 146
 147         num_layouts = xkb_keymap_num_layouts_for_key(keymap, keycode);
 148         for (xkb_layout_index_t layout = 0; layout < num_layouts; layout++) {
 149             const char *layout_name;
 150             xkb_level_index_t num_levels;
 151
 152             layout_name = xkb_keymap_layout_get_name(keymap, layout);
 153             if (!layout_name) {
 154                 layout_name = "?";
 155             }
 156
 157             num_levels = xkb_keymap_num_levels_for_key(keymap, keycode, layout);
 158             for (xkb_level_index_t level = 0; level < num_levels; level++) {
 159                 int num_syms;
 160                 const xkb_keysym_t *syms;
 161                 size_t num_masks;
 162                 xkb_mod_mask_t masks[100];
 163
 164                 num_syms = xkb_keymap_key_get_syms_by_level(
 165                     keymap, keycode, layout, level, &syms
 166                 );
 167                 if (num_syms != 1) {
 168                     continue;
 169                 }
 170                 if (syms[0] != keysym) {
 171                     continue;
 172                 }
 173
 174                 num_masks = xkb_keymap_key_get_mods_for_level(
 175                     keymap, keycode, layout, level, masks, ARRAY_SIZE(masks)
 176                 );
 177                 for (size_t i = 0; i < num_masks; i++) {
 178                     xkb_mod_mask_t mask = masks[i];
 179
 180                     printf("%u\t%s\t%u\t%s\t%u\t[ ",
 181                            keycode, key_name, layout + 1, layout_name, level + 1);
 182                     for (xkb_mod_index_t mod = 0; mod < num_mods; mod++) {
 183                         if ((mask & (1 << mod)) == 0) {
 184                             continue;
 185                         }
 186                         printf("%s ", xkb_keymap_mod_get_name(keymap, mod));
 187                     }
 188                     printf("]\n");
 189                 }
 190             }
 191         }
 192     }
 193
 194     err = EXIT_SUCCESS;
 195 err:
 196     xkb_keymap_unref(keymap);
 197     xkb_context_unref(ctx);
 198     return err;
 199 }