248 lines
8.2 KiB
C++
248 lines
8.2 KiB
C++
//
|
|
// Most of this code has been taken from the wonderful XDOTOOL: https://github.com/jordansissel/xdotool/blob/master/COPYRIGHT
|
|
// and modified to use XSendEvent instead of XTestFakeKeyEvent.
|
|
|
|
#include <locale.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "fast_xdo.h"
|
|
|
|
extern "C" { // Needed to avoid C++ compiler name mangling
|
|
#include <xdo.h>
|
|
}
|
|
|
|
void fast_init_xkeyevent(const xdo_t *xdo, XKeyEvent *xk) {
|
|
xk->display = xdo->xdpy;
|
|
xk->subwindow = None;
|
|
xk->time = CurrentTime;
|
|
xk->same_screen = True;
|
|
|
|
/* Should we set these at all? */
|
|
xk->x = xk->y = xk->x_root = xk->y_root = 1;
|
|
}
|
|
|
|
void fast_send_key(const xdo_t *xdo, Window window, charcodemap_t *key,
|
|
int modstate, int is_press, useconds_t delay) {
|
|
/* Properly ensure the modstate is set by finding a key
|
|
* that activates each bit in the modifier state */
|
|
int mask = modstate | key->modmask;
|
|
int use_xtest = 0;
|
|
|
|
/* Since key events have 'state' (shift, etc) in the event, we don't
|
|
* need to worry about key press ordering. */
|
|
XKeyEvent xk;
|
|
fast_init_xkeyevent(xdo, &xk);
|
|
xk.window = window;
|
|
xk.keycode = key->code;
|
|
xk.state = mask | (key->group << 13);
|
|
xk.type = (is_press ? KeyPress : KeyRelease);
|
|
XSendEvent(xdo->xdpy, xk.window, True, KeyPressMask, (XEvent *)&xk);
|
|
|
|
/* Skipping the usleep if delay is 0 is much faster than calling usleep(0) */
|
|
XFlush(xdo->xdpy);
|
|
if (delay > 0) {
|
|
usleep(delay);
|
|
}
|
|
}
|
|
|
|
int fast_send_keysequence_window_list_do(const xdo_t *xdo, Window window, charcodemap_t *keys,
|
|
int nkeys, int pressed, int *modifier, useconds_t delay) {
|
|
int i = 0;
|
|
int modstate = 0;
|
|
int keymapchanged = 0;
|
|
|
|
/* Find an unused keycode in case we need to bind unmapped keysyms */
|
|
KeySym *keysyms = NULL;
|
|
int keysyms_per_keycode = 0;
|
|
int scratch_keycode = 0; /* Scratch space for temporary keycode bindings */
|
|
keysyms = XGetKeyboardMapping(xdo->xdpy, xdo->keycode_low,
|
|
xdo->keycode_high - xdo->keycode_low,
|
|
&keysyms_per_keycode);
|
|
|
|
/* Find a keycode that is unused for scratchspace */
|
|
for (i = xdo->keycode_low; i <= xdo->keycode_high; i++) {
|
|
int j = 0;
|
|
int key_is_empty = 1;
|
|
for (j = 0; j < keysyms_per_keycode; j++) {
|
|
/*char *symname;*/
|
|
int symindex = (i - xdo->keycode_low) * keysyms_per_keycode + j;
|
|
/*symname = XKeysymToString(keysyms[symindex]);*/
|
|
if (keysyms[symindex] != 0) {
|
|
key_is_empty = 0;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
if (key_is_empty) {
|
|
scratch_keycode = i;
|
|
break;
|
|
}
|
|
}
|
|
XFree(keysyms);
|
|
|
|
/* Allow passing NULL for modifier in case we don't care about knowing
|
|
* the modifier map state after we finish */
|
|
if (modifier == NULL)
|
|
modifier = &modstate;
|
|
|
|
for (i = 0; i < nkeys; i++) {
|
|
if (keys[i].needs_binding == 1) {
|
|
KeySym keysym_list[] = { keys[i].symbol };
|
|
//_xdo_debug(xdo, "Mapping sym %lu to %d", keys[i].symbol, scratch_keycode);
|
|
XChangeKeyboardMapping(xdo->xdpy, scratch_keycode, 1, keysym_list, 1);
|
|
XSync(xdo->xdpy, False);
|
|
/* override the code in our current key to use the scratch_keycode */
|
|
keys[i].code = scratch_keycode;
|
|
keymapchanged = 1;
|
|
}
|
|
|
|
//fprintf(stderr, "keyseqlist_do: Sending %lc %s (%d, mods %x)\n",
|
|
//keys[i].key, (pressed ? "down" : "up"), keys[i].code, *modifier);
|
|
fast_send_key(xdo, window, &(keys[i]), *modifier, pressed, delay);
|
|
|
|
if (keys[i].needs_binding == 1) {
|
|
/* If we needed to make a new keymapping for this keystroke, we
|
|
* should sync with the server now, after the keypress, so that
|
|
* the next mapping or removal doesn't conflict. */
|
|
XSync(xdo->xdpy, False);
|
|
}
|
|
|
|
if (pressed) {
|
|
*modifier |= keys[i].modmask;
|
|
} else {
|
|
*modifier &= ~(keys[i].modmask);
|
|
}
|
|
}
|
|
|
|
|
|
if (keymapchanged) {
|
|
KeySym keysym_list[] = { 0 };
|
|
//printf(xdo, "Reverting scratch keycode (sym %lu to %d)",
|
|
// keys[i].symbol, scratch_keycode);
|
|
XChangeKeyboardMapping(xdo->xdpy, scratch_keycode, 1, keysym_list, 1);
|
|
}
|
|
|
|
/* Necessary? */
|
|
XFlush(xdo->xdpy);
|
|
return XDO_SUCCESS;
|
|
}
|
|
|
|
KeySym fast_keysym_from_char(const xdo_t *xdo, wchar_t key) {
|
|
int i = 0;
|
|
int len = xdo->charcodes_len;
|
|
|
|
//printf("Finding symbol for key '%c'\n", key);
|
|
for (i = 0; i < len; i++) {
|
|
//printf(" => %c vs %c (%d)\n",
|
|
//key, xdo->charcodes[i].key, (xdo->charcodes[i].key == key));
|
|
if (xdo->charcodes[i].key == key) {
|
|
//printf(" => MATCH to symbol: %lu\n", xdo->charcodes[i].symbol);
|
|
return xdo->charcodes[i].symbol;
|
|
}
|
|
}
|
|
|
|
if (key >= 0x100) key += 0x01000000;
|
|
if (XKeysymToString(key)) return key;
|
|
return NoSymbol;
|
|
}
|
|
|
|
void fast_charcodemap_from_keysym(const xdo_t *xdo, charcodemap_t *key, KeySym keysym) {
|
|
int i = 0;
|
|
int len = xdo->charcodes_len;
|
|
|
|
key->code = 0;
|
|
key->symbol = keysym;
|
|
key->group = 0;
|
|
key->modmask = 0;
|
|
key->needs_binding = 1;
|
|
|
|
for (i = 0; i < len; i++) {
|
|
if (xdo->charcodes[i].symbol == keysym) {
|
|
key->code = xdo->charcodes[i].code;
|
|
key->group = xdo->charcodes[i].group;
|
|
key->modmask = xdo->charcodes[i].modmask;
|
|
key->needs_binding = 0;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void fast_charcodemap_from_char(const xdo_t *xdo, charcodemap_t *key) {
|
|
KeySym keysym = fast_keysym_from_char(xdo, key->key);
|
|
fast_charcodemap_from_keysym(xdo, key, keysym);
|
|
}
|
|
|
|
/* XXX: Return proper code if errors found */
|
|
int fast_enter_text_window(const xdo_t *xdo, Window window, const char *string, useconds_t delay) {
|
|
|
|
/* Since we're doing down/up, the delay should be based on the number
|
|
* of keys pressed (including shift). Since up/down is two calls,
|
|
* divide by two. */
|
|
delay /= 2;
|
|
|
|
/* XXX: Add error handling */
|
|
//int nkeys = strlen(string);
|
|
//charcodemap_t *keys = calloc(nkeys, sizeof(charcodemap_t));
|
|
charcodemap_t key;
|
|
//int modifier = 0;
|
|
setlocale(LC_CTYPE,"");
|
|
mbstate_t ps = { 0 };
|
|
ssize_t len;
|
|
while ( (len = mbsrtowcs(&key.key, &string, 1, &ps)) ) {
|
|
if (len == -1) {
|
|
fprintf(stderr, "Invalid multi-byte sequence encountered\n");
|
|
return XDO_ERROR;
|
|
}
|
|
fast_charcodemap_from_char(xdo, &key);
|
|
if (key.code == 0 && key.symbol == NoSymbol) {
|
|
fprintf(stderr, "I don't what key produces '%lc', skipping.\n",
|
|
key.key);
|
|
continue;
|
|
} else {
|
|
//printf("Found key for %c\n", key.key);
|
|
//printf("code: %d\n", key.code);
|
|
//printf("sym: %s\n", XKeysymToString(key.symbol));
|
|
}
|
|
|
|
//printf(stderr,
|
|
//"Key '%c' maps to code %d / sym %lu in group %d / mods %d (%s)\n",
|
|
//key.key, key.code, key.symbol, key.group, key.modmask,
|
|
//(key.needs_binding == 1) ? "needs binding" : "ok");
|
|
|
|
//_xdo_send_key(xdo, window, keycode, modstate, True, delay);
|
|
//_xdo_send_key(xdo, window, keycode, modstate, False, delay);
|
|
fast_send_keysequence_window_list_do(xdo, window, &key, 1, True, NULL, delay / 2);
|
|
key.needs_binding = 0;
|
|
fast_send_keysequence_window_list_do(xdo, window, &key, 1, False, NULL, delay / 2);
|
|
|
|
/* XXX: Flush here or at the end? or never? */
|
|
//XFlush(xdo->xdpy);
|
|
} /* walk string generating a keysequence */
|
|
|
|
//free(keys);
|
|
return XDO_SUCCESS;
|
|
}
|
|
|
|
void fast_send_event(const xdo_t *xdo, Window window, int keycode, int pressed) {
|
|
XKeyEvent xk;
|
|
xk.display = xdo->xdpy;
|
|
xk.window = window;
|
|
xk.root = XDefaultRootWindow(xdo->xdpy);
|
|
xk.subwindow = None;
|
|
xk.time = CurrentTime;
|
|
xk.x = 1;
|
|
xk.y = 1;
|
|
xk.x_root = 1;
|
|
xk.y_root = 1;
|
|
xk.same_screen = True;
|
|
xk.keycode = keycode;
|
|
xk.state = 0;
|
|
xk.type = (pressed ? KeyPress : KeyRelease);
|
|
|
|
XEvent event;
|
|
event.xkey =xk;
|
|
|
|
XSendEvent(xdo->xdpy, window, True, 0, &event);
|
|
}
|