[mirror_qemu.git] / qemu-keymap.c

/*
 * QEMU keymap utility
 *
 * Copyright Red Hat, Inc. 2017
 *
 * Authors:
 *     Gerd Hoffmann <kraxel@redhat.com>
 *
 * This work is licensed under the terms of the GNU GPL, version 2 or later.
 * See the COPYING file in the top-level directory.
 */
#include "qemu/osdep.h"
#include "qemu/notify.h"
#include "ui/input.h"

#include <xkbcommon/xkbcommon.h>

struct xkb_rule_names names = {
    .rules   = NULL,
    .model   = "pc105",
    .layout  = "us",
    .variant = NULL,
    .options = NULL,
};

static xkb_mod_mask_t shift;
static xkb_mod_mask_t ctrl;
static xkb_mod_mask_t altgr;
static xkb_mod_mask_t numlock;

static FILE *outfile;

/* ------------------------------------------------------------------------ */

static uint32_t qcode_to_number(uint32_t qcode)
{
    KeyValue keyvalue;
    uint32_t number;

    keyvalue.type = KEY_VALUE_KIND_QCODE;
    keyvalue.u.qcode.data = qcode;
    number = qemu_input_key_value_to_number(&keyvalue);
    assert(number != 0);
    return number;
}

static void print_sym(xkb_keysym_t sym, uint32_t qcode, const char *mod)
{
    char name[64];

    if (sym == XKB_KEY_NoSymbol) {
        return;
    }
    xkb_keysym_get_name(sym, name, sizeof(name));

    /* TODO: make ui/keymap.c parser accept QKeyCode names */
    fprintf(outfile, "%s 0x%02x%s\n", name, qcode_to_number(qcode), mod);
}

static void walk_map(struct xkb_keymap *map, xkb_keycode_t code, void *data)
{
    struct xkb_state *state = data;
    xkb_keysym_t kbase, knumlock, kshift, kaltgr, kaltgrshift;
    uint32_t evdev, qcode;
    char name[64];

    fprintf(outfile, "\n");

    /*
     * map xkb keycode -> QKeyCode
     *
     * xkb keycode is linux evdev shifted by 8
     */
    evdev = code - 8;
    qcode = qemu_input_linux_to_qcode(evdev);
    if (qcode == Q_KEY_CODE_UNMAPPED) {
        xkb_state_update_mask(state,  0, 0, 0,  0, 0, 0);
        kbase = xkb_state_key_get_one_sym(state, code);
        xkb_keysym_get_name(kbase, name, sizeof(name));
        fprintf(outfile, "# evdev %d (0x%x): no evdev -> QKeyCode mapping"
                " (xkb keysym %s)\n", evdev, evdev, name);
        return;
    }
    fprintf(outfile, "# evdev %d (0x%x), QKeyCode \"%s\", number 0x%x\n",
            evdev, evdev,
            QKeyCode_str(qcode),
            qcode_to_number(qcode));

    /*
     * check which modifier states generate which keysyms
     */
    xkb_state_update_mask(state,  0, 0, 0,  0, 0, 0);
    kbase = xkb_state_key_get_one_sym(state, code);
    print_sym(kbase, qcode, "");

    xkb_state_update_mask(state,  0, 0, numlock,  0, 0, 0);
    knumlock = xkb_state_key_get_one_sym(state, code);
    if (kbase != knumlock) {
        print_sym(knumlock, qcode, " numlock");
    }

    xkb_state_update_mask(state,  shift, 0, 0,  0, 0, 0);
    kshift = xkb_state_key_get_one_sym(state, code);
    if (kbase != kshift && knumlock != kshift) {
        print_sym(kshift, qcode, " shift");
    }

    xkb_state_update_mask(state,  altgr, 0, 0,  0, 0, 0);
    kaltgr = xkb_state_key_get_one_sym(state, code);
    if (kbase != kaltgr) {
        print_sym(kaltgr, qcode, " altgr");
    }

    xkb_state_update_mask(state,  altgr | shift, 0, 0,  0, 0, 0);
    kaltgrshift = xkb_state_key_get_one_sym(state, code);
    if (kshift != kaltgrshift && kaltgr != kaltgrshift) {
        print_sym(kaltgrshift, qcode, " shift altgr");
    }
    return;
}

static void usage(FILE *out)
{
    fprintf(out,
            "\n"
            "This tool generates qemu reverse keymaps from xkb keymaps,\n"
            "which can be used with the qemu \"-k\" command line switch.\n"
            "\n"
            "usage: qemu-keymap <options>\n"
            "options:\n"
            "    -h             print this text\n"
            "    -f <file>      set output file          (default: stdout)\n"
            "    -m <model>     set kbd model            (default: %s)\n"
            "    -l <layout>    set kbd layout           (default: %s)\n"
            "    -v <variant>   set kbd variant          (default: %s)\n"
            "    -o <options>   set kbd options          (default: %s)\n"
            "\n",
            names.model, names.layout,
            names.variant ?: "-",
            names.options ?: "-");
}

int main(int argc, char *argv[])
{
    struct xkb_context *ctx;
    struct xkb_keymap *map;
    struct xkb_state *state;
    xkb_mod_index_t mod, mods;
    int rc;

    for (;;) {
        rc = getopt(argc, argv, "hm:l:v:o:f:");
        if (rc == -1) {
            break;
        }
        switch (rc) {
        case 'm':
            names.model = optarg;
            break;
        case 'l':
            names.layout = optarg;
            break;
        case 'v':
            names.variant = optarg;
            break;
        case 'o':
            names.options = optarg;
            break;
        case 'f':
            outfile = fopen(optarg, "w");
            if (outfile == NULL) {
                fprintf(stderr, "open %s: %s\n", optarg, strerror(errno));
                exit(1);
            }
            break;
        case 'h':
            usage(stdout);
            exit(0);
        default:
            usage(stderr);
            exit(1);
        }
    }

    if (outfile == NULL) {
        outfile = stdout;
    }

    fprintf(outfile,
            "# SPDX-License-Identifier: GPL-2.0-or-later\n"
            "#\n"
            "# generated by qemu-keymap\n"
            "#    model   : %s\n"
            "#    layout  : %s\n"
            "#    variant : %s\n"
            "#    options : %s\n"
            "\n",
            names.model, names.layout,
            names.variant ?: "-",
            names.options ?: "-");

    ctx = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
    map = xkb_keymap_new_from_names(ctx, &names, XKB_KEYMAP_COMPILE_NO_FLAGS);
    if (!map) {
        /* libxkbcommon prints error */
        exit(1);
    }

    fprintf(outfile, "# name: \"%s\"\n\n",
            xkb_keymap_layout_get_name(map, 0));
    fprintf(outfile, "# modifiers\n");
    mods = xkb_keymap_num_mods(map);
    for (mod = 0; mod < mods; mod++) {
        fprintf(outfile, "#    %2d: %s\n",
                mod, xkb_keymap_mod_get_name(map, mod));
    }

    mod = xkb_keymap_mod_get_index(map, "Shift");
    shift = (1 << mod);
    mod = xkb_keymap_mod_get_index(map, "Control");
    ctrl = (1 << mod);
    mod = xkb_keymap_mod_get_index(map, "AltGr");
    altgr = (1 << mod);
    mod = xkb_keymap_mod_get_index(map, "NumLock");
    numlock = (1 << mod);

    state = xkb_state_new(map);
    xkb_keymap_key_for_each(map, walk_map, state);

    /* add quirks */
    fprintf(outfile,
            "\n"
            "#\n"
            "# quirks section start\n"
            "#\n"
            "# Sometimes multiple keysyms map to the same keycodes.\n"
            "# The keycode -> keysym lookup finds only one of the\n"
            "# keysyms.  So append them here.\n"
            "#\n"
            "\n");
    print_sym(XKB_KEY_Print,            Q_KEY_CODE_SYSRQ,      "");
    print_sym(XKB_KEY_Sys_Req,          Q_KEY_CODE_SYSRQ,      "");
    print_sym(XKB_KEY_Execute,          Q_KEY_CODE_SYSRQ,      "");

    print_sym(XKB_KEY_KP_Decimal,       Q_KEY_CODE_KP_DECIMAL, " numlock");
    print_sym(XKB_KEY_KP_Separator,     Q_KEY_CODE_KP_DECIMAL, " numlock");

    print_sym(XKB_KEY_Alt_R,            Q_KEY_CODE_ALT_R,      "");
    print_sym(XKB_KEY_ISO_Level3_Shift, Q_KEY_CODE_ALT_R,      "");
    print_sym(XKB_KEY_Mode_switch,      Q_KEY_CODE_ALT_R,      "");

    fprintf(outfile,
            "\n"
            "# quirks section end\n");

    exit(0);
}
Commit	Line	Data
6a021536 GH	1	/*
	2	* QEMU keymap utility
	3	*
	4	* Copyright Red Hat, Inc. 2017
	5	*
	6	* Authors:
	7	* Gerd Hoffmann <kraxel@redhat.com>
	8	*
	9	* This work is licensed under the terms of the GNU GPL, version 2 or later.
	10	* See the COPYING file in the top-level directory.
	11	*/
	12	#include "qemu/osdep.h"
6a021536 GH	13	#include "qemu/notify.h"
	14	#include "ui/input.h"
	15
	16	#include <xkbcommon/xkbcommon.h>
	17
	18	struct xkb_rule_names names = {
	19	.rules = NULL,
	20	.model = "pc105",
	21	.layout = "us",
	22	.variant = NULL,
	23	.options = NULL,
	24	};
	25
	26	static xkb_mod_mask_t shift;
	27	static xkb_mod_mask_t ctrl;
	28	static xkb_mod_mask_t altgr;
	29	static xkb_mod_mask_t numlock;
	30
	31	static FILE *outfile;
	32
	33	/* ------------------------------------------------------------------------ */
	34
	35	static uint32_t qcode_to_number(uint32_t qcode)
	36	{
	37	KeyValue keyvalue;
	38	uint32_t number;
	39
	40	keyvalue.type = KEY_VALUE_KIND_QCODE;
	41	keyvalue.u.qcode.data = qcode;
	42	number = qemu_input_key_value_to_number(&keyvalue);
	43	assert(number != 0);
	44	return number;
	45	}
	46
	47	static void print_sym(xkb_keysym_t sym, uint32_t qcode, const char *mod)
	48	{
	49	char name[64];
	50
	51	if (sym == XKB_KEY_NoSymbol) {
	52	return;
	53	}
	54	xkb_keysym_get_name(sym, name, sizeof(name));
	55
	56	/* TODO: make ui/keymap.c parser accept QKeyCode names */
	57	fprintf(outfile, "%s 0x%02x%s\n", name, qcode_to_number(qcode), mod);
	58	}
	59
	60	static void walk_map(struct xkb_keymap map, xkb_keycode_t code, void data)
	61	{
	62	struct xkb_state *state = data;
	63	xkb_keysym_t kbase, knumlock, kshift, kaltgr, kaltgrshift;
	64	uint32_t evdev, qcode;
	65	char name[64];
	66
	67	fprintf(outfile, "\n");
	68
	69	/*
	70	* map xkb keycode -> QKeyCode
	71	*
	72	* xkb keycode is linux evdev shifted by 8
	73	*/
	74	evdev = code - 8;
	75	qcode = qemu_input_linux_to_qcode(evdev);
	76	if (qcode == Q_KEY_CODE_UNMAPPED) {
77	xkb_state_update_mask(state, 0, 0, 0, 0, 0, 0);
78	kbase = xkb_state_key_get_one_sym(state, code);
79	xkb_keysym_get_name(kbase, name, sizeof(name));
80	fprintf(outfile, "# evdev %d (0x%x): no evdev -> QKeyCode mapping"
81	" (xkb keysym %s)\n", evdev, evdev, name);
82	return;
83	}
84	fprintf(outfile, "# evdev %d (0x%x), QKeyCode \"%s\", number 0x%x\n",
85	evdev, evdev,
c809d1d2	86	QKeyCode_str(qcode),
6a021536 GH	87	qcode_to_number(qcode));
	88
	89	/*
	90	* check which modifier states generate which keysyms
	91	*/
	92	xkb_state_update_mask(state, 0, 0, 0, 0, 0, 0);
	93	kbase = xkb_state_key_get_one_sym(state, code);
	94	print_sym(kbase, qcode, "");
	95
	96	xkb_state_update_mask(state, 0, 0, numlock, 0, 0, 0);
	97	knumlock = xkb_state_key_get_one_sym(state, code);
	98	if (kbase != knumlock) {
	99	print_sym(knumlock, qcode, " numlock");
	100	}
	101
	102	xkb_state_update_mask(state, shift, 0, 0, 0, 0, 0);
	103	kshift = xkb_state_key_get_one_sym(state, code);
	104	if (kbase != kshift && knumlock != kshift) {
	105	print_sym(kshift, qcode, " shift");
	106	}
	107
	108	xkb_state_update_mask(state, altgr, 0, 0, 0, 0, 0);
	109	kaltgr = xkb_state_key_get_one_sym(state, code);
	110	if (kbase != kaltgr) {
	111	print_sym(kaltgr, qcode, " altgr");
	112	}
	113
	114	xkb_state_update_mask(state, altgr \| shift, 0, 0, 0, 0, 0);
	115	kaltgrshift = xkb_state_key_get_one_sym(state, code);
	116	if (kshift != kaltgrshift && kaltgr != kaltgrshift) {
	117	print_sym(kaltgrshift, qcode, " shift altgr");
	118	}
	119	return;
	120	}
	121
	122	static void usage(FILE *out)
	123	{
	124	fprintf(out,
	125	"\n"
	126	"This tool generates qemu reverse keymaps from xkb keymaps,\n"
	127	"which can be used with the qemu \"-k\" command line switch.\n"
	128	"\n"
	129	"usage: qemu-keymap <options>\n"
	130	"options:\n"
	131	" -h print this text\n"
	132	" -f <file> set output file (default: stdout)\n"
	133	" -m <model> set kbd model (default: %s)\n"
	134	" -l <layout> set kbd layout (default: %s)\n"
	135	" -v <variant> set kbd variant (default: %s)\n"
	136	" -o <options> set kbd options (default: %s)\n"
	137	"\n",
	138	names.model, names.layout,
	139	names.variant ?: "-",
	140	names.options ?: "-");
	141	}
	142
	143	int main(int argc, char *argv[])
	144	{
	145	struct xkb_context *ctx;
	146	struct xkb_keymap *map;
	147	struct xkb_state *state;
	148	xkb_mod_index_t mod, mods;
	149	int rc;
	150
151	for (;;) {
152	rc = getopt(argc, argv, "hm:l:v:o:f:");
153	if (rc == -1) {
154	break;
155	}
156	switch (rc) {
157	case 'm':
158	names.model = optarg;
159	break;
160	case 'l':
161	names.layout = optarg;
162	break;
163	case 'v':
164	names.variant = optarg;
165	break;
166	case 'o':
167	names.options = optarg;
168	break;
169	case 'f':
170	outfile = fopen(optarg, "w");
171	if (outfile == NULL) {
172	fprintf(stderr, "open %s: %s\n", optarg, strerror(errno));
173	exit(1);
174	}
175	break;
176	case 'h':
177	usage(stdout);
178	exit(0);
179	default:
180	usage(stderr);
181	exit(1);
182	}
183	}
184
185	if (outfile == NULL) {
186	outfile = stdout;
187	}
188
189	fprintf(outfile,
4455922f	190	"# SPDX-License-Identifier: GPL-2.0-or-later\n"
6a021536 GH	191	"#\n"
	192	"# generated by qemu-keymap\n"
	193	"# model : %s\n"
	194	"# layout : %s\n"
	195	"# variant : %s\n"
	196	"# options : %s\n"
	197	"\n",
	198	names.model, names.layout,
	199	names.variant ?: "-",
	200	names.options ?: "-");
	201
	202	ctx = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
	203	map = xkb_keymap_new_from_names(ctx, &names, XKB_KEYMAP_COMPILE_NO_FLAGS);
	204	if (!map) {
	205	/* libxkbcommon prints error */
	206	exit(1);
	207	}
	208
	209	fprintf(outfile, "# name: \"%s\"\n\n",
	210	xkb_keymap_layout_get_name(map, 0));
	211	fprintf(outfile, "# modifiers\n");
	212	mods = xkb_keymap_num_mods(map);
	213	for (mod = 0; mod < mods; mod++) {
	214	fprintf(outfile, "# %2d: %s\n",
	215	mod, xkb_keymap_mod_get_name(map, mod));
	216	}
	217
	218	mod = xkb_keymap_mod_get_index(map, "Shift");
	219	shift = (1 << mod);
	220	mod = xkb_keymap_mod_get_index(map, "Control");
	221	ctrl = (1 << mod);
	222	mod = xkb_keymap_mod_get_index(map, "AltGr");
	223	altgr = (1 << mod);
	224	mod = xkb_keymap_mod_get_index(map, "NumLock");
	225	numlock = (1 << mod);
	226
	227	state = xkb_state_new(map);
	228	xkb_keymap_key_for_each(map, walk_map, state);
	229
	230	/* add quirks */
	231	fprintf(outfile,
	232	"\n"
	233	"#\n"
	234	"# quirks section start\n"
	235	"#\n"
	236	"# Sometimes multiple keysyms map to the same keycodes.\n"
	237	"# The keycode -> keysym lookup finds only one of the\n"
	238	"# keysyms. So append them here.\n"
	239	"#\n"
	240	"\n");
	241	print_sym(XKB_KEY_Print, Q_KEY_CODE_SYSRQ, "");
	242	print_sym(XKB_KEY_Sys_Req, Q_KEY_CODE_SYSRQ, "");
	243	print_sym(XKB_KEY_Execute, Q_KEY_CODE_SYSRQ, "");
	244
	245	print_sym(XKB_KEY_KP_Decimal, Q_KEY_CODE_KP_DECIMAL, " numlock");
	246	print_sym(XKB_KEY_KP_Separator, Q_KEY_CODE_KP_DECIMAL, " numlock");
	247
	248	print_sym(XKB_KEY_Alt_R, Q_KEY_CODE_ALT_R, "");
	249	print_sym(XKB_KEY_ISO_Level3_Shift, Q_KEY_CODE_ALT_R, "");
	250	print_sym(XKB_KEY_Mode_switch, Q_KEY_CODE_ALT_R, "");
	251
	252	fprintf(outfile,
	253	"\n"
	254	"# quirks section end\n");
255
256	exit(0);
257	}