// replacement for XKeycodeToKeysym, which is deprecated
static int x_keycode_to_keysym(struct _FTR *f, int keycode)
{
int nothing;
KeySym *t = XGetKeyboardMapping(f->display, keycode, 1, ¬hing);
int r = t[0];
XFree(t);
return r;
}
static void xkeymap_store_keymaps(struct _xkeymap *p, int group)
{
int min_keycode, max_keycode, keysyms_per_keycode;
KeySym *keymap;
XDisplayKeycodes (main_window->display, &min_keycode, &max_keycode);
keymap = XGetKeyboardMapping (main_window->display, min_keycode, max_keycode - min_keycode + 1, &keysyms_per_keycode);
p->min_keycode = min_keycode;
p->max_keycode = max_keycode;
if (p->total_key_arrays < group)
p->total_key_arrays = group;
p->alphabet = xnrealloc(p->alphabet, (group + 1) * sizeof(struct _xkeymap_alpha));
p->alphabet[group] = xnmalloc((max_keycode + 1) * sizeof(struct _xkeymap_alpha));
for (int i = min_keycode; i <= max_keycode; i++)
{
int j;
p->alphabet[group][i].lower_sym = xnmalloc(1);
p->alphabet[group][i].lower_sym[0] = NULLSYM;
p->alphabet[group][i].upper_sym = xnmalloc(1);
p->alphabet[group][i].upper_sym[0] = NULLSYM;
for (j = group*2; j <= group*2 + 1; j++)
{
KeySym ks = keymap[j];
int groups[4] = {0x00000000, 0x00002000, 0x00004000, 0x00006000};
if (ks != NoSymbol)
{
XEvent event = create_basic_event();
event.xkey.keycode = i;
event.xkey.state = groups[group];
if (j == group*2 + 1)
event.xkey.state |= ShiftMask;
int nbytes;
char str[256+1];
nbytes = XLookupString ((XKeyEvent *) &event, str, 256, &ks, NULL);
if (nbytes > 0)
{
if (j == group*2)
{
p->alphabet[group][i].lower_sym = xnmalloc(nbytes+1);
strncpy(p->alphabet[group][i].lower_sym, str, nbytes+1);
p->alphabet[group][i].lower_sym[nbytes] = NULLSYM;
}
else
{
p->alphabet[group][i].upper_sym = xnmalloc(nbytes+1);
strncpy(p->alphabet[group][i].upper_sym, str, nbytes+1);
p->alphabet[group][i].upper_sym[nbytes] = NULLSYM;
}
}
}
}
keymap += keysyms_per_keycode;
}
}
void
PrintKeyTable(Bool exprs, FILE *fp)
{
int i;
int min_keycode, max_keycode, keysyms_per_keycode;
KeySym *keymap, *origkeymap;
XDisplayKeycodes (dpy, &min_keycode, &max_keycode);
origkeymap = XGetKeyboardMapping (dpy, min_keycode,
(max_keycode - min_keycode + 1),
&keysyms_per_keycode);
if (!origkeymap) {
fprintf (stderr, "%s: unable to get keyboard mapping table.\n",
ProgramName);
return;
}
if (!exprs) {
fprintf (fp,
"There are %d KeySyms per KeyCode; KeyCodes range from %d to %d.\n\n",
keysyms_per_keycode, min_keycode, max_keycode);
fprintf (fp, " KeyCode\tKeysym (Keysym)\t...\n");
fprintf (fp, " Value \tValue (Name) \t...\n\n");
}
keymap = origkeymap;
for (i = min_keycode; i <= max_keycode; i++) {
int j, max;
if (exprs)
fprintf(fp, "keycode %3d =", i);
else
fprintf(fp, " %3d \t", i);
max = keysyms_per_keycode - 1;
while ((max >= 0) && (keymap[max] == NoSymbol))
max--;
for (j = 0; j <= max; j++) {
register KeySym ks = keymap[j];
const char *s;
if (ks != NoSymbol)
s = XKeysymToString (ks);
else
s = "NoSymbol";
if (!exprs)
fprintf (fp, "0x%04x (%s)\t",
(unsigned int)ks, s ? s : "no name");
else if (s)
fprintf (fp, " %s", s);
else
fprintf (fp, " 0x%04x", (unsigned int)ks);
}
keymap += keysyms_per_keycode;
fprintf (fp, "\n");
}
XFree ((char *) origkeymap);
return;
}
void sendChar(char c) {
KeySym ks, sks, *kss, ksl, ksu;
KeyCode kc, skc;
int Delay = 10;
int syms;
#ifdef DEBUG
int i;
#endif
sks=XK_Shift_L;
ks=XStringToKeysym(chartbl[0][(unsigned char)c]);
if ( ( kc = XKeysymToKeycode ( RemoteDpy, ks ) ) == 0 )
{
std::cerr << "No keycode on remote display found for char: " << c << std::endl;
return;
}
if ( ( skc = XKeysymToKeycode ( RemoteDpy, sks ) ) == 0 )
{
std::cerr << "No keycode on remote display found for XK_Shift_L!" << std::endl;
return;
}
kss=XGetKeyboardMapping(RemoteDpy, kc, 1, &syms);
if (!kss)
{
std::cerr << "XGetKeyboardMapping failed on the remote display (keycode: " << kc << ")" << std::endl;
return;
}
for (; syms && (!kss[syms-1]); syms--);
if (!syms)
{
std::cerr << "XGetKeyboardMapping failed on the remote display (no syms) (keycode: " << kc << ")" << std::endl;
XFree(kss);
return;
}
XConvertCase(ks,&ksl,&ksu);
#ifdef DEBUG
std::cout << "kss: ";
for (i=0; i<syms; i++) std::cout << kss[i] << " ";
std::cout << "(" << ks << " l: " << ksl << " h: " << ksu << ")" << std::endl;
#endif
if (ks==kss[0] && (ks==ksl && ks==ksu)) sks=NoSymbol;
if (ks==ksl && ks!=ksu) sks=NoSymbol;
if (sks!=NoSymbol) XTestFakeKeyEvent ( RemoteDpy, skc, True, Delay );
XTestFakeKeyEvent ( RemoteDpy, kc, True, Delay );
XFlush ( RemoteDpy );
XTestFakeKeyEvent ( RemoteDpy, kc, False, Delay );
if (sks!=NoSymbol) XTestFakeKeyEvent ( RemoteDpy, skc, False, Delay );
XFlush ( RemoteDpy );
XFree(kss);
}
void _setupkeymap(){
// FIXME: we should have an option to dump the current keymap somewhere.
uk_log("setup keymap");
if(symbol_mode==LOAD){
char *line=NULL;
size_t len=0;
int read=0;
sym_file=fopen(symbol_file,"r");
assert(sym_file);
int n_keysyms=0;
while((read=getline(&line,&len,sym_file)) != -1){
if(*line=='#') continue;
n_keysyms++;
}
unique=malloc(n_keysyms*sizeof(symbol));
assert(unique);
uk_log("we have %i keysysm in %s\n",n_keysyms,symbol_file);
fseek(sym_file,0,SEEK_SET);
while((read=getline(&line,&len,sym_file)) != -1){
if(*line=='#') continue;
char name[128];
int ks,mod,keycode;
sscanf(line,FORMAT,(char*)&name,&ks,&mod,&keycode);
// uk_log(FORMAT,name,ks,mod,keycode);
_add_unique(name,ks,mod,keycode);
}
onhaskeymap(unique,n_unique);
return;
}
int min,max,keysyms_per_keycode;
KeySym *keymap;
XModifierKeymap *modifiers;
modifiers=XGetModifierMapping(dpy);
// _setup_modifiers(modifiers);
XDisplayKeycodes(dpy,&min,&max);
keymap = XGetKeyboardMapping(dpy,min,max-min+1,&keysyms_per_keycode);
int n_keysyms=_get_keycode_count(keymap,min,max,keysyms_per_keycode);
uk_log("got %i keysyms",n_keysyms);
// _print_keycodes(keymap,min,max,keysyms_per_keycode);
unique=malloc(n_keysyms*sizeof(symbol));
_get_unique_keycodes(keymap,min,max,keysyms_per_keycode,0);
_get_unique_keycodes(keymap,min,max,keysyms_per_keycode,1);
uk_log("got %i unique",n_unique);
onhaskeymap(unique,n_unique);
}
// Private
static int init_keymaps(struct _keymap *p)
{
// Define all key codes and key symbols
XDisplayKeycodes(p->display, &(p->min_keycode), &(p->max_keycode));
p->keymap = XGetKeyboardMapping(p->display, p->min_keycode, p->max_keycode - p->min_keycode + 1, &(p->keysyms_per_keycode));
if (!p->keymap)
{
log_message(ERROR, _("Unable to get keyboard mapping table"));
return FALSE;
}
return TRUE;
}
static int xkeymap_init_keymaps(struct _xkeymap *p)
{
// Define all key codes and key symbols
int min_keycode, max_keycode, keysyms_per_keycode;
XDisplayKeycodes (main_window->display, &min_keycode, &max_keycode);
p->keymap = XGetKeyboardMapping (main_window->display, min_keycode, max_keycode - min_keycode + 1, &keysyms_per_keycode);
if (!p->keymap)
{
log_message(ERROR, "Unable to get keyboard mapping table");
return FALSE;
}
return TRUE;
}
char keyboard_handler(XEvent event, Display* display){
int keysyms_per_keycode_return;
KeySym key_symbol = XGetKeyboardMapping(display,event.xkey.keycode,1, &keysyms_per_keycode_return);
if(XLookupKeysym(&event.xkey, 0)== XK_1){
printf("ci sono\n");
int pid = fork();
if(pid==0) {
if(execlp(DEFAULT_TERMINAL, DEFAULT_TERMINAL, "-ut", 0)==-1){
printf("%s", strerror(errno));
}
}
}
int ascii_key = key_symbol - XK_A + 'A';
}
void UBKeyboardPalette::onActivated(bool activated)
{
if (activated)
{
if (storage)
{
qDebug() << "Keybard already activated....";
return;
}
Display *display = XOpenDisplay(0);
if(display == NULL)
return;
XDisplayKeycodes(display, &this->min_keycodes, &this->max_keycodes);
KeySym* keySyms = XGetKeyboardMapping(display, min_keycodes,
max_keycodes - min_keycodes, &byte_per_code);
storage = keySyms;
XCloseDisplay(display);
onLocaleChanged(locales[nCurrentLocale]);
}
else
{
Display *display = XOpenDisplay(0);
if(display == NULL)
{
qDebug() << "Keybard not activated....";
return;
}
KeySym* keySyms = (KeySym*)storage;
if (keySyms!=NULL)
{
qDebug() << "Default key table restored.....";
XChangeKeyboardMapping(display, min_keycodes, byte_per_code,
keySyms, max_keycodes - min_keycodes);
XFree(keySyms);
storage = NULL;
}
XCloseDisplay(display);
}
}
void PressKey(wchar key, _XDisplay *dpy = NULL) {
bool local = false;
if (!dpy) {
if (!(dpy = XOpenDisplay(NULL)))
return;
local = true;
}
wchar k = key;
if (key > 0x00ff)
key = key | 0x01000000;
bool shift = false;
KeyCode code = XKeysymToKeycode(dpy, key);
if (code != 0) {
if (XkbKeycodeToKeysym(dpy, code, 0, 0) != key) {
if (XkbKeycodeToKeysym(dpy, code, 1, 0) == key)
shift = true;
else
code = 0;
}
} else {
int firstKeycode, maxKeycode;
int keysymsPerKeycode;
XDisplayKeycodes(dpy, &firstKeycode, &maxKeycode);
KeySym *keysyms = XGetKeyboardMapping(dpy, firstKeycode, maxKeycode - firstKeycode + 1, &keysymsPerKeycode);
int indx = (maxKeycode - firstKeycode - 1)*keysymsPerKeycode;
keysyms[indx] = key;
XChangeKeyboardMapping(dpy, firstKeycode, keysymsPerKeycode, keysyms, maxKeycode-firstKeycode);
XSync(dpy, False);
code = maxKeycode-1;
if (XkbKeycodeToKeysym(dpy, code, 0, 0) != key) {
if (XkbKeycodeToKeysym(dpy, code, 1, 0) == key)
shift = true;
}
}
if (code != 0) {
if (shift)
XTestFakeKeyEvent(dpy, XKeysymToKeycode(dpy, XK_Shift_L), True, CurrentTime);
XTestFakeKeyEvent(dpy, code, True, CurrentTime);
XTestFakeKeyEvent(dpy, code, False, CurrentTime);
if (shift)
XTestFakeKeyEvent(dpy, XKeysymToKeycode(dpy, XK_Shift_L), False, CurrentTime);
}
if (local) {
XFlush(dpy);
XCloseDisplay(dpy);
}
}
Bool NestedClientGetKeyboardMappings(NestedClientPrivatePtr pPriv, KeySymsPtr keySyms, CARD8 *modmap, XkbControlsPtr ctrls) {
XModifierKeymap *modifier_keymap;
KeySym *keymap;
int mapWidth;
int min_keycode, max_keycode;
int i, j;
XkbDescPtr xkb;
XDisplayKeycodes(pPriv->display, &min_keycode, &max_keycode);
keymap = XGetKeyboardMapping(pPriv->display,
min_keycode,
max_keycode - min_keycode + 1,
&mapWidth);
memset(modmap, 0, sizeof(CARD8) * MAP_LENGTH);
modifier_keymap = XGetModifierMapping(pPriv->display);
for (j = 0; j < 8; j++)
for(i = 0; i < modifier_keymap->max_keypermod; i++) {
CARD8 keycode;
if ((keycode = modifier_keymap->modifiermap[j * modifier_keymap->max_keypermod + i]))
modmap[keycode] |= 1<<j;
}
XFreeModifiermap(modifier_keymap);
keySyms->minKeyCode = min_keycode;
keySyms->maxKeyCode = max_keycode;
keySyms->mapWidth = mapWidth;
keySyms->map = keymap;
xkb = XkbGetKeyboard(pPriv->display, XkbGBN_AllComponentsMask, XkbUseCoreKbd);
if (xkb == NULL || xkb->geom == NULL) {
xf86DrvMsg(pPriv->scrnIndex, X_ERROR, "Couldn't get XKB keyboard.\n");
free(keymap);
return FALSE;
}
if(XkbGetControls(pPriv->display, XkbAllControlsMask, xkb) != Success) {
xf86DrvMsg(pPriv->scrnIndex, X_ERROR, "Couldn't get XKB keyboard controls.\n");
free(keymap);
return FALSE;
}
memcpy(ctrls, xkb->ctrls, sizeof(XkbControlsRec));
XkbFreeKeyboard(xkb, 0, False);
return TRUE;
}
void UModifier::mapKeys(UDisp* d) {
static bool mods_init = false;
if (mods_init) return;
mods_init = true;
Display* sysdisp = ((UDispX11*)d)->getSysDisp();
_MetaDown = Mod1Mask; // valeur qui peut varier suivant les plateformes
_AltDown = Mod2Mask; // idem
_ModeSwitch = 0; // cf a la fin
_MetaDown = _AltDown = _ModeSwitch = 0;
XModifierKeymap* modmap = XGetModifierMapping(sysdisp);
if (!modmap) return;
// 8 modifiers dans tous les cas de figures (definis ou pas)
for (int m = 0; m < 8; m++) {
// plusieurs keycodes par modifiers, de 0 a max_keypermod
for (int c = 0; c < modmap->max_keypermod; c++) {
KeyCode keycode = modmap->modifiermap[m * modmap->max_keypermod + c];
if (keycode != 0) {
#if 0 //deprecated
KeySym keysym = XKeycodeToKeysym(sysdisp, keycode, 0);
#else
int keysyms_per_keycode_return;
KeySym *keysym = XGetKeyboardMapping(sysdisp, keycode, 0, &keysyms_per_keycode_return);
#endif
if ((unsigned long)keysym == XK_Meta_L || (unsigned long)keysym == XK_Meta_R)
_MetaDown = (1 << m);
else if ((unsigned long)keysym == XK_Alt_L || (unsigned long)keysym == XK_Alt_R)
_AltDown = (1 << m);
else if ((unsigned long)keysym == XK_Mode_switch)
_ModeSwitch = (1 << m);
#if 1 //deprcated
XFree(keysym);
#endif
}
}
}
XFreeModifiermap(modmap);
}
void
X11KeysymEnum::process_keymap(Display* dpy)
{
int min_keycode, max_keycode;
XDisplayKeycodes(dpy, &min_keycode, &max_keycode);
int num_keycodes = max_keycode - min_keycode + 1;
int keysyms_per_keycode;
KeySym* keymap = XGetKeyboardMapping(dpy, static_cast<KeyCode>(min_keycode),
num_keycodes,
&keysyms_per_keycode);
for(int i = 0; i < num_keycodes; ++i)
{
if (keymap[i*keysyms_per_keycode] != NoSymbol)
{
KeySym keysym = keymap[i*keysyms_per_keycode];
// FIXME: Duplicate entries confuse the conversion
// std::map<KeySym, int>::iterator it = mapping.find(keysym);
// if (it != mapping.end())
// std::cout << "Duplicate keycode: " << i << std::endl;
const char* keysym_str = XKeysymToString(keysym);
if (!keysym_str)
{
log_warn("couldn't convert keysym " << keysym << " to string");
}
else
{
std::ostringstream str;
str << "XK_" << keysym_str;
add(i, str.str());
}
}
}
XFree(keymap);
}
/*
* print the contents of the map
*/
void
PrintModifierMapping(XModifierKeymap *map, FILE *fp)
{
int i, k = 0;
int min_keycode, max_keycode, keysyms_per_keycode = 0;
XDisplayKeycodes (dpy, &min_keycode, &max_keycode);
XGetKeyboardMapping (dpy, min_keycode, (max_keycode - min_keycode + 1),
&keysyms_per_keycode);
fprintf (fp,
"%s: up to %d keys per modifier, (keycodes in parentheses):\n\n",
ProgramName, map->max_keypermod);
for (i = 0; i < 8; i++) {
int j;
fprintf(fp, "%-10s", modifier_table[i].name);
for (j = 0; j < map->max_keypermod; j++) {
if (map->modifiermap[k]) {
KeySym ks;
int index = 0;
char *nm;
do {
ks = XKeycodeToKeysym(dpy, map->modifiermap[k], index);
index++;
} while ( !ks && index < keysyms_per_keycode);
nm = XKeysymToString(ks);
fprintf (fp, "%s %s (0x%0x)", (j > 0 ? "," : ""),
(nm ? nm : "BadKey"), map->modifiermap[k]);
}
k++;
}
fprintf(fp, "\n");
}
fprintf (fp, "\n");
return;
}
static int
read_config (Display *disp)
{
int ks_per_kk;
int first_kk, last_kk;
KeySym* syms;
XDisplayKeycodes (disp, &first_kk, &last_kk);
syms = XGetKeyboardMapping (disp, first_kk, last_kk - first_kk, &ks_per_kk);
DB_conf_item_t *item = deadbeef->conf_find ("hotkeys.", NULL);
while (item) {
if (command_count == MAX_COMMAND_COUNT)
{
fprintf (stderr, "hotkeys: maximum number (%d) of commands exceeded\n", MAX_COMMAND_COUNT);
break;
}
command_t *cmd_entry = &commands[ command_count ];
cmd_entry->modifier = 0;
cmd_entry->keycode = 0;
size_t l = strlen (item->value);
char param[l+1];
memcpy (param, item->value, l+1);
char* colon = strchr (param, ':');
if (!colon)
{
fprintf (stderr, "hotkeys: bad config option %s %s\n", item->key, item->value);
continue;
}
char* command = colon+1;
*colon = 0;
int done = 0;
char* p;
char* space = param - 1;
do {
p = space+1;
space = strchr (p, ' ');
if (space)
*space = 0;
else
done = 1;
if (0 == strcasecmp (p, "Ctrl"))
cmd_entry->modifier |= ControlMask;
else if (0 == strcasecmp (p, "Alt"))
cmd_entry->modifier |= Mod1Mask;
else if (0 == strcasecmp (p, "Shift"))
cmd_entry->modifier |= ShiftMask;
else if (0 == strcasecmp (p, "Super")) {
cmd_entry->modifier |= Mod4Mask;
}
else {
if (p[0] == '0' && p[1] == 'x') {
// parse hex keycode
int r = sscanf (p, "0x%x", &cmd_entry->keycode);
if (!r) {
cmd_entry->keycode = 0;
}
}
else {
// lookup name table
cmd_entry->keycode = get_keycode (disp, p, syms, first_kk, last_kk, ks_per_kk);
}
if (!cmd_entry->keycode)
{
trace ("hotkeys: got 0 from get_keycode while adding hotkey: %s %s\n", item->key, item->value);
break;
}
}
} while (!done);
if (done) {
if (cmd_entry->keycode == 0) {
trace ("hotkeys: Key not found while parsing %s %s\n", item->key, item->value);
}
else {
command = trim (command);
cmd_entry->action = get_action (command);
if (!cmd_entry->action)
{
trace ("hotkeys: Unknown command <%s> while parsing %s %s\n", command, item->key, item->value);
}
else {
command_count++;
}
}
}
item = deadbeef->conf_find ("hotkeys.", item);
}
XFree (syms);
int i;
// need to grab it here to prevent gdk_x_error from being called while we're
// doing it on other thread
for (i = 0; i < command_count; i++) {
for (int f = 0; f < 16; f++) {
uint32_t flags = 0;
if (f & 1) {
flags |= LockMask;
}
if (f & 2) {
flags |= Mod2Mask;
}
if (f & 4) {
flags |= Mod3Mask;
}
if (f & 8) {
flags |= Mod5Mask;
}
XGrabKey (disp, commands[i].keycode, commands[i].modifier | flags, DefaultRootWindow (disp), False, GrabModeAsync, GrabModeAsync);
}
}
return 0;
}
/*
* Gibt die Tastaturtabelle in einer QStringList zurück
*/
QStringList QvkShowkeyGetkey::PrintKeyTable()
{
bool exprs = false;
QString line;
QStringList stringList;
if (! ( display = XOpenDisplay( NULL ) ) )
{
qDebug() << "Can't open display NULL" << '\n';
return stringList;
}
int i;
int min_keycode, max_keycode, keysyms_per_keycode;
KeySym *keymap, *origkeymap;
XDisplayKeycodes (display, &min_keycode, &max_keycode);
origkeymap = XGetKeyboardMapping( display, min_keycode, (max_keycode - min_keycode + 1), &keysyms_per_keycode );
if (!origkeymap)
{
qDebug() << "unable to get keyboard mapping table.";
return stringList;
}
keymap = origkeymap;
for (i = min_keycode; i <= max_keycode; i++) {
int j, max;
line = "";
line.append( QString::number( i ) );
max = keysyms_per_keycode - 1;
while ((max >= 0) && (keymap[max] == NoSymbol))
max--;
for (j = 0; j <= max; j++)
{
register KeySym ks = keymap[j];
const char *s;
if (ks != NoSymbol)
s = XKeysymToString (ks);
else
s = "NoSymbol";
if (!exprs)
{
line.append( " " ); // Delemiter
line.append( "0x" ); // Identifier
QString hexStr = QString::number( (unsigned int)ks, 16 ); // convert to hex
line.append( hexStr );
line.append( " " ); // Delemiter
line.append( "" ).append( s ).append( "" );
}
else
if (s)
fprintf (stdout, " %s", s);
else
fprintf (stdout, " 0x%04x", (unsigned int)ks);
}
keymap += keysyms_per_keycode;
stringList << line;
}
XFree ((char *) origkeymap);
return stringList;
}
static int
read_config (Display *disp) {
int ks_per_kk;
int first_kk, last_kk;
Atom* syms;
XDisplayKeycodes (disp, &first_kk, &last_kk);
syms = XGetKeyboardMapping (disp, first_kk, last_kk - first_kk, &ks_per_kk);
#else
#define ShiftMask (1<<0)
#define LockMask (1<<1)
#define ControlMask (1<<2)
#define Mod1Mask (1<<3)
#define Mod2Mask (1<<4)
#define Mod3Mask (1<<5)
#define Mod4Mask (1<<6)
#define Mod5Mask (1<<7)
int ks_per_kk = -1;
int first_kk = -1, last_kk = -1;
int* syms = NULL;
static int
read_config (void) {
#endif
DB_conf_item_t *item = deadbeef->conf_find ("hotkey.", NULL);
while (item) {
if (command_count == MAX_COMMAND_COUNT)
{
fprintf (stderr, "hotkeys: maximum number (%d) of commands exceeded\n", MAX_COMMAND_COUNT);
break;
}
command_t *cmd_entry = &commands[ command_count ];
memset (cmd_entry, 0, sizeof (command_t));
char token[MAX_TOKEN];
char keycombo[MAX_TOKEN];
const char *script = item->value;
if ((script = gettoken (script, keycombo)) == 0) {
trace ("hotkeys: unexpected eol (keycombo)\n");
goto out;
}
if ((script = gettoken (script, token)) == 0) {
trace ("hotkeys: unexpected eol (ctx)\n");
goto out;
}
cmd_entry->ctx = atoi (token);
if (cmd_entry->ctx < 0 || cmd_entry->ctx >= DDB_ACTION_CTX_COUNT) {
trace ("hotkeys: invalid ctx %d\n", cmd_entry->ctx);
goto out;
}
if ((script = gettoken (script, token)) == 0) {
trace ("hotkeys: unexpected eol (isglobal)\n");
goto out;
}
cmd_entry->isglobal = atoi (token);
if ((script = gettoken (script, token)) == 0) {
trace ("hotkeys: unexpected eol (action)\n");
goto out;
}
cmd_entry->action = find_action_by_name (token);
if (!cmd_entry->action) {
trace ("hotkeys: action not found %s\n", token);
goto out;
}
// parse key combo
int done = 0;
char* p;
char* space = keycombo;
do {
p = space;
space = strchr (p, ' ');
if (space) {
*space = 0;
space++;
}
else
done = 1;
if (0 == strcasecmp (p, "Ctrl"))
cmd_entry->modifier |= ControlMask;
else if (0 == strcasecmp (p, "Alt"))
cmd_entry->modifier |= Mod1Mask;
else if (0 == strcasecmp (p, "Shift"))
cmd_entry->modifier |= ShiftMask;
else if (0 == strcasecmp (p, "Super")) {
cmd_entry->modifier |= Mod4Mask;
}
else {
if (p[0] == '0' && p[1] == 'x') {
// parse hex keycode
int r = sscanf (p, "0x%x", &cmd_entry->keycode);
if (!r) {
cmd_entry->keycode = 0;
}
}
else {
// lookup name table
cmd_entry->keycode = get_keycode (p);
#ifndef NO_XLIB_H
cmd_entry->x11_keycode = get_x11_keycode (p, syms, first_kk, last_kk, ks_per_kk);
trace ("%s: kc=%d, xkc=%d\n", p, cmd_entry->keycode, cmd_entry->x11_keycode);
#endif
}
if (!cmd_entry->keycode)
{
trace ("hotkeys: got 0 from get_keycode while adding hotkey: %s %s\n", item->key, item->value);
break;
}
}
} while (!done);
if (done) {
if (cmd_entry->keycode == 0) {
trace ("hotkeys: Key not found while parsing %s %s\n", item->key, item->value);
}
else {
command_count++;
}
}
out:
item = deadbeef->conf_find ("hotkey.", item);
}
#ifndef NO_XLIB_H
XFree (syms);
int i;
// need to grab it here to prevent gdk_x_error from being called while we're
// doing it on other thread
for (i = 0; i < command_count; i++) {
if (!commands[i].isglobal) {
continue;
}
for (int f = 0; f < 16; f++) {
uint32_t flags = 0;
if (f & 1) {
flags |= LockMask;
}
if (f & 2) {
flags |= Mod2Mask;
}
if (f & 4) {
flags |= Mod3Mask;
}
if (f & 8) {
flags |= Mod5Mask;
}
trace ("XGrabKey %d %x\n", commands[i].keycode, commands[i].modifier | flags);
XGrabKey (disp, commands[i].x11_keycode, commands[i].modifier | flags, DefaultRootWindow (disp), False, GrabModeAsync, GrabModeAsync);
}
}
#endif
return 0;
}
static inline uint16_t
_x11key_to_nekey(int code)
{
KeySym *ks = NULL;
if (code < 8 || code > 255)
return NE_KEY_UNRECOGNIZED;
ks = XGetKeyboardMapping(x_display, code, 1, (int *)&ks);
code = ks[0];
XFree(ks);
switch (code) {
case XK_0: return NE_KEY_0;
case XK_1: return NE_KEY_1;
case XK_2: return NE_KEY_2;
case XK_3: return NE_KEY_3;
case XK_4: return NE_KEY_4;
case XK_5: return NE_KEY_5;
case XK_6: return NE_KEY_6;
case XK_7: return NE_KEY_7;
case XK_8: return NE_KEY_8;
case XK_9: return NE_KEY_9;
case XK_a: return NE_KEY_A;
case XK_b: return NE_KEY_B;
case XK_c: return NE_KEY_C;
case XK_d: return NE_KEY_D;
case XK_e: return NE_KEY_E;
case XK_f: return NE_KEY_F;
case XK_g: return NE_KEY_G;
case XK_h: return NE_KEY_H;
case XK_i: return NE_KEY_I;
case XK_j: return NE_KEY_J;
case XK_k: return NE_KEY_K;
case XK_l: return NE_KEY_L;
case XK_m: return NE_KEY_M;
case XK_n: return NE_KEY_N;
case XK_o: return NE_KEY_O;
case XK_p: return NE_KEY_P;
case XK_q: return NE_KEY_Q;
case XK_r: return NE_KEY_R;
case XK_s: return NE_KEY_S;
case XK_t: return NE_KEY_T;
case XK_u: return NE_KEY_U;
case XK_v: return NE_KEY_V;
case XK_w: return NE_KEY_W;
case XK_x: return NE_KEY_X;
case XK_y: return NE_KEY_Y;
case XK_z: return NE_KEY_Z;
case XK_Up: return NE_KEY_UP;
case XK_Down: return NE_KEY_DOWN;
case XK_Left: return NE_KEY_LEFT;
case XK_Right: return NE_KEY_RIGHT;
case XK_space: return NE_KEY_SPACE;
case XK_plus: return NE_KEY_PLUS;
case XK_minus: return NE_KEY_MINUS;
case XK_comma: return NE_KEY_COMMA;
case XK_period: return NE_KEY_PERIOD;
case XK_Scroll_Lock: return NE_KEY_SCROLL;
case XK_Shift_L: return NE_KEY_LSHIFT;
case XK_Shift_R: return NE_KEY_RSHIFT;
case XK_Alt_L: return NE_KEY_LALT;
case XK_Alt_R: return NE_KEY_RALT;
case XK_Super_L: return NE_KEY_LSUPER;
case XK_Super_R: return NE_KEY_RSUPER;
case XK_Control_L: return NE_KEY_LCTRL;
case XK_Control_R: return NE_KEY_RCTRL;
case XK_Page_Up: return NE_KEY_PGUP;
case XK_Page_Down: return NE_KEY_PGDN;
case XK_End: return NE_KEY_END;
case XK_Home: return NE_KEY_HOME;
case XK_Escape: return NE_KEY_ESCAPE;
case XK_Insert: return NE_KEY_INSERT;
case XK_Return: return NE_KEY_RETURN;
case XK_Caps_Lock: return NE_KEY_CAPS;
case XK_Delete: return NE_KEY_DELETE;
case XK_BackSpace: return NE_KEY_BKSPACE;
case XK_Tab: return NE_KEY_TAB;
case XK_Print: return NE_KEY_PRTSCRN;
case XK_Pause: return NE_KEY_PAUSE;
case XK_semicolon: return NE_KEY_SEMICOLON;
case XK_slash: return NE_KEY_SLASH;
case XK_asciitilde: return NE_KEY_TILDE;
case XK_bracketleft: return NE_KEY_LBRACKET;
case XK_bracketright: return NE_KEY_RBRACKET;
case XK_backslash: return NE_KEY_BKSLASH;
case XK_quotedbl: return NE_KEY_QUOTE;
case XK_F1: return NE_KEY_F1;
case XK_F2: return NE_KEY_F2;
case XK_F3: return NE_KEY_F3;
case XK_F4: return NE_KEY_F4;
case XK_F5: return NE_KEY_F5;
case XK_F6: return NE_KEY_F6;
case XK_F7: return NE_KEY_F7;
case XK_F8: return NE_KEY_F8;
case XK_F9: return NE_KEY_F9;
case XK_F10: return NE_KEY_F10;
case XK_F11: return NE_KEY_F11;
case XK_F12: return NE_KEY_F12;
case XK_F13: return NE_KEY_F13;
case XK_F14: return NE_KEY_F14;
case XK_F15: return NE_KEY_F15;
case XK_F16: return NE_KEY_F16;
case XK_F17: return NE_KEY_F17;
case XK_F18: return NE_KEY_F18;
case XK_F19: return NE_KEY_F19;
case XK_F20: return NE_KEY_F20;
case XK_F21: return NE_KEY_F21;
case XK_F22: return NE_KEY_F22;
case XK_F23: return NE_KEY_F23;
case XK_F24: return NE_KEY_F24;
case XK_Num_Lock: return NE_KEY_F10;
case XK_KP_0: return NE_KEY_NUM_0;
case XK_KP_1: return NE_KEY_NUM_1;
case XK_KP_2: return NE_KEY_NUM_2;
case XK_KP_3: return NE_KEY_NUM_3;
case XK_KP_4: return NE_KEY_NUM_4;
case XK_KP_5: return NE_KEY_NUM_5;
case XK_KP_6: return NE_KEY_NUM_6;
case XK_KP_7: return NE_KEY_NUM_7;
case XK_KP_8: return NE_KEY_NUM_8;
case XK_KP_9: return NE_KEY_NUM_9;
case XK_KP_Add: return NE_KEY_NUM_PLUS;
case XK_KP_Subtract: return NE_KEY_NUM_MINUS;
case XK_KP_Divide: return NE_KEY_NUM_DIVIDE;
case XK_KP_Multiply: return NE_KEY_NUM_MULT;
case XK_KP_Decimal: return NE_KEY_NUM_DECIMAL;
}
return NE_KEY_UNRECOGNIZED;
}
static void
reload_mouse_modifiers (void)
{
XModifierKeymap *modmap;
KeySym *keymap;
int keysyms_per_keycode;
int map_size;
int i;
gboolean have_meta;
gboolean have_hyper;
gboolean have_super;
int min_keycode, max_keycode;
int mod_meta, mod_super, mod_hyper;
XDisplayKeycodes (gdk_x11_display_get_xdisplay(gdk_display_get_default()),
&min_keycode,
&max_keycode);
keymap = XGetKeyboardMapping (gdk_x11_display_get_xdisplay(gdk_display_get_default()),
min_keycode,
max_keycode - min_keycode,
&keysyms_per_keycode);
modmap = XGetModifierMapping (gdk_x11_display_get_xdisplay(gdk_display_get_default()));
have_super = FALSE;
have_meta = FALSE;
have_hyper = FALSE;
/* there are 8 modifiers, and the first 3 are shift, shift lock,
* and control
*/
map_size = 8 * modmap->max_keypermod;
i = 3 * modmap->max_keypermod;
mod_meta = mod_super = mod_hyper = 0;
while (i < map_size) {
/* get the key code at this point in the map,
* see if its keysym is one we're interested in
*/
int keycode = modmap->modifiermap[i];
if (keycode >= min_keycode &&
keycode <= max_keycode) {
int j = 0;
KeySym *syms = keymap + (keycode - min_keycode) * keysyms_per_keycode;
while (j < keysyms_per_keycode) {
if (syms[j] == XK_Super_L || syms[j] == XK_Super_R)
mod_super = i / modmap->max_keypermod;
else if (syms[j] == XK_Hyper_L || syms[j] == XK_Hyper_R)
mod_hyper = i / modmap->max_keypermod;
else if ((syms[j] == XK_Meta_L || syms[j] == XK_Meta_R))
mod_meta = i / modmap->max_keypermod;
++j;
}
}
++i;
}
if ((1 << mod_meta) != Mod1Mask)
have_meta = TRUE;
if (mod_super != 0 && mod_super != mod_meta)
have_super = TRUE;
if (mod_hyper != 0 && mod_hyper != mod_meta && mod_hyper != mod_super)
have_hyper = TRUE;
XFreeModifiermap (modmap);
XFree (keymap);
i = 0;
while (i < n_mouse_modifiers) {
g_free (mouse_modifiers[i].name);
if (mouse_modifiers[i].radio)
gtk_widget_destroy (mouse_modifiers[i].radio);
++i;
}
g_free (mouse_modifiers);
mouse_modifiers = NULL;
n_mouse_modifiers = 1; /* alt */
if (have_super)
++n_mouse_modifiers;
if (have_hyper)
++n_mouse_modifiers;
if (have_meta)
++n_mouse_modifiers;
mouse_modifiers = g_new0 (MouseClickModifier, n_mouse_modifiers);
i = 0;
mouse_modifiers[i].number = i;
mouse_modifiers[i].name = g_strdup (_("_Alt"));
mouse_modifiers[i].value = "Alt";
++i;
if (have_hyper) {
mouse_modifiers[i].number = i;
mouse_modifiers[i].name = g_strdup (_("H_yper"));
mouse_modifiers[i].value = "Hyper";
++i;
}
if (have_super) {
mouse_modifiers[i].number = i;
mouse_modifiers[i].name = g_strdup (_("S_uper (or \"Windows logo\")"));
mouse_modifiers[i].value = "Super";
++i;
}
if (have_meta) {
mouse_modifiers[i].number = i;
mouse_modifiers[i].name = g_strdup (_("_Meta"));
mouse_modifiers[i].value = "Meta";
++i;
}
g_assert (i == n_mouse_modifiers);
i = 0;
while (i < n_mouse_modifiers) {
fill_radio (i == 0 ? NULL : GTK_RADIO_BUTTON (mouse_modifiers[i-1].radio), &mouse_modifiers[i]);
++i;
}
}
static bool _al_xwin_get_keyboard_mapping(void)
{
int i;
int count;
int missing = 0;
ALLEGRO_SYSTEM_XGLX *system = (void *)al_get_system_driver();
memset(used, 0, sizeof used);
memset(keycode_to_scancode, 0, sizeof keycode_to_scancode);
XDisplayKeycodes(system->x11display, &min_keycode, &max_keycode);
count = 1 + max_keycode - min_keycode;
if (keysyms) {
XFree(keysyms);
}
keysyms = XGetKeyboardMapping(system->x11display, min_keycode,
count, &sym_per_key);
ALLEGRO_INFO("%i keys, %i symbols per key.\n", count, sym_per_key);
if (sym_per_key <= 0) {
return false;
}
missing = 0;
for (i = min_keycode; i <= max_keycode; i++) {
KeySym sym = keysyms[sym_per_key * (i - min_keycode)];
KeySym sym2 = keysyms[sym_per_key * (i - min_keycode) + 1];
char *sym_str, *sym2_str;
int allegro_key = 0;
char str[1024];
sym_str = XKeysymToString(sym);
sym2_str = XKeysymToString(sym2);
snprintf(str, sizeof str, "key [%i: %s %s]", i,
sym_str ? sym_str : "NULL", sym2_str ? sym2_str : "NULL");
/* Hack for French keyboards, to correctly map ALLEGRO_KEY_0 to ALLEGRO_KEY_9. */
if (sym2 >= XK_0 && sym2 <= XK_9) {
allegro_key = find_allegro_key(sym2);
}
if (!allegro_key) {
if (sym != NoSymbol) {
allegro_key = find_allegro_key(sym);
if (allegro_key == 0) {
missing++;
ALLEGRO_DEBUG("%s defering.\n", str);
}
}
else {
/* No KeySym for this key - ignore it. */
keycode_to_scancode[i] = -1;
ALLEGRO_DEBUG("%s not assigned.\n", str);
}
}
if (allegro_key) {
bool is_double = false;
if (used[allegro_key]) {
is_double = true;
}
keycode_to_scancode[i] = allegro_key;
key_names[allegro_key] =
XKeysymToString(keysyms[sym_per_key * (i - min_keycode)]);
used[allegro_key] = 1;
ALLEGRO_DEBUG("%s%s assigned to %i.\n", str,
is_double ? " *double*" : "", allegro_key);
}
}
if (missing) {
/* The keys still not assigned are just assigned arbitrarily now. */
for (i = min_keycode; i <= max_keycode; i++) {
if (keycode_to_scancode[i] == 0) {
find_unknown_key_assignment(i);
}
}
}
if (xmodmap)
XFreeModifiermap(xmodmap);
xmodmap = XGetModifierMapping(system->x11display);
for (i = 0; i < 8; i++) {
int j;
char str[1024];
sprintf(str, "Modifier %d:", i + 1);
for (j = 0; j < xmodmap->max_keypermod; j++) {
KeyCode keycode = xmodmap->modifiermap[i * xmodmap->max_keypermod + j];
// XKeycodeToKeysym is deprecated
//KeySym sym = XKeycodeToKeysym(system->x11display, keycode, 0);
KeySym sym = XkbKeycodeToKeysym(system->x11display, keycode, 0, 0);
char *sym_str = XKeysymToString(sym);
sprintf(str + strlen(str), " %s", sym_str ? sym_str : "NULL");
}
ALLEGRO_DEBUG("%s\n", str);
}
/* The [xkeymap] section can be useful, e.g. if trying to play a
* game which has X and Y hardcoded as ALLEGRO_KEY_X and ALLEGRO_KEY_Y to mean
* left/right movement, but on the X11 keyboard X and Y are far apart.
* For normal use, a user never should have to touch [xkeymap] anymore
* though, and proper written programs will not hardcode such mappings.
*/
ALLEGRO_CONFIG *c = al_get_system_config();
char const *key;
ALLEGRO_CONFIG_ENTRY *it;
key = al_get_first_config_entry(c, "xkeymap", &it);
while (key) {
char const *val;
val = al_get_config_value(c, "xkeymap", key);
int keycode = strtol(key, NULL, 10);
int scancode = strtol(val, NULL, 10);
if (keycode > 0 && scancode > 0) {
keycode_to_scancode[keycode] = scancode;
ALLEGRO_WARN("User override: KeySym %i assigned to %i.\n",
keycode, scancode);
}
key = al_get_next_config_entry(&it);
}
return true;
}
/* x_get_keyboard_mapping:
* Generate a mapping from X11 keycodes to Allegro KEY_* codes. We have
* two goals: Every keypress should be mapped to a distinct Allegro KEY_*
* code. And we want the KEY_* codes to match the pressed
* key to some extent. To do the latter, the X11 KeySyms produced by a key
* are examined. If a match is found in the table above, the mapping is
* added to the mapping table. If no known KeySym is found for a key (or
* the same KeySym is found for more keys) - the remaining keys are
* distributed arbitrarily to the remaining KEY_* codes.
*
* In a future version, this could be simplified by mapping *all* the X11
* KeySyms to KEY_* codes.
*/
void _xwin_get_keyboard_mapping(void)
{
int i;
int count;
int missing = 0;
memset(used, 0, sizeof used);
memset(_xwin.keycode_to_scancode, 0, sizeof _xwin.keycode_to_scancode);
XLOCK();
XDisplayKeycodes(_xwin.display, &min_keycode, &max_keycode);
count = 1 + max_keycode - min_keycode;
if (keysyms) {
XFree(keysyms);
}
keysyms = XGetKeyboardMapping(_xwin.display, min_keycode,
count, &sym_per_key);
TRACE (PREFIX_I "%i keys, %i symbols per key.\n", count, sym_per_key);
missing = 0;
for (i = min_keycode; i <= max_keycode; i++) {
KeySym sym = keysyms[sym_per_key * (i - min_keycode)];
KeySym sym2 = keysyms[sym_per_key * (i - min_keycode) + 1];
char *sym_str, *sym2_str;
int allegro_key = 0;
sym_str = XKeysymToString(sym);
sym2_str = XKeysymToString(sym2);
TRACE (PREFIX_I "key [%i: %s %s]", i, sym_str ? sym_str : "NULL", sym2_str ?
sym2_str : "NULL");
/* Hack for French keyboards, to correctly map KEY_0 to KEY_9. */
if (sym2 >= XK_0 && sym2 <= XK_9) {
allegro_key = find_allegro_key(sym2);
}
if (!allegro_key) {
if (sym != NoSymbol) {
allegro_key = find_allegro_key(sym);
if (allegro_key == 0) {
missing++;
TRACE (" defering.\n");
}
}
else {
/* No KeySym for this key - ignore it. */
_xwin.keycode_to_scancode[i] = -1;
TRACE (" not assigned.\n");
}
}
if (allegro_key) {
if (used[allegro_key]) {
TRACE(" *double*");
}
_xwin.keycode_to_scancode[i] = allegro_key;
key_names[allegro_key] =
XKeysymToString(keysyms[sym_per_key * (i - min_keycode)]);
used[allegro_key] = 1;
TRACE(" assigned to %i.\n", allegro_key);
}
}
if (missing) {
/* The keys still not assigned are just assigned arbitrarily now. */
for (i = min_keycode; i <= max_keycode; i++) {
if (_xwin.keycode_to_scancode[i] == 0) {
find_unknown_key_assignment(i);
}
}
}
if (xmodmap)
XFreeModifiermap(xmodmap);
xmodmap = XGetModifierMapping(_xwin.display);
for (i = 0; i < 8; i++) {
int j;
TRACE (PREFIX_I "Modifier %d:", i + 1);
for (j = 0; j < xmodmap->max_keypermod; j++) {
KeySym sym = XKeycodeToKeysym(_xwin.display,
xmodmap->modifiermap[i * xmodmap->max_keypermod + j], 0);
char *sym_str = XKeysymToString(sym);
TRACE(" %s", sym_str ? sym_str : "NULL");
}
TRACE("\n");
}
/* The [xkeymap] section can be useful, e.g. if trying to play a
* game which has X and Y hardcoded as KEY_X and KEY_Y to mean
* left/right movement, but on the X11 keyboard X and Y are far apart.
* For normal use, a user never should have to touch [xkeymap] anymore
* though, and proper written programs will not hardcode such mappings.
*/
{
char *section, *option_format;
char option[128], tmp1[128], tmp2[128];
section = uconvert_ascii("xkeymap", tmp1);
option_format = uconvert_ascii("keycode%d", tmp2);
for (i = min_keycode; i <= max_keycode; i++) {
int scancode;
uszprintf(option, sizeof(option), option_format, i);
scancode = get_config_int(section, option, -1);
if (scancode > 0) {
_xwin.keycode_to_scancode[i] = scancode;
TRACE(PREFIX_I "User override: KeySym %i assigned to %i.\n", i, scancode);
}
}
}
XUNLOCK();
}
/* This function is borrowed from Wine (LGPL'ed)
http://source.winehq.org/source/dlls/x11drv/keyboard.c
with adjustments to match dosemu
The idea is, if $_layout="auto", to match each keyboard map with
the X keymap and choose the one that matches best.
It is used when we can access display, not just for xdosemu,
but also in xterms. Remote users using terminals will have
to specify $_layout explicitly though.
The console map is just another map in this scheme that may
or may not be the best one.
*/
int X11_DetectLayout (void)
{
Display *display;
unsigned match, mismatch, seq, i, alternate;
int score, keyc, key, pkey, ok = 0;
KeySym keysym;
unsigned max_seq[3] = {0, 0};
int max_score[3] = {INT_MIN, INT_MIN};
int ismatch = 0;
int min_keycode, max_keycode;
t_unicode ckey[2] = {0, 0};
t_keysym lkey[2] = {0, 0};
struct keytable_entry *kt;
struct char_set_state X_charset;
char *display_name = config.X_display ? config.X_display : getenv("DISPLAY");
display = XOpenDisplay(display_name);
if (display == NULL) return 1;
XDisplayKeycodes(display, &min_keycode, &max_keycode);
#ifndef HAVE_XKB
int keysyms_per_keycode;
KeySym *key_mapping;
/* get data for keycode from X server */
key_mapping = XGetKeyboardMapping(display, min_keycode,
max_keycode + 1 - min_keycode,
&keysyms_per_keycode);
#endif
init_charset_state(&X_charset, lookup_charset("X_keysym"));
for (kt = keytable_list, alternate = 0; kt->name; ) {
k_printf("Attempting to match against \"%s\"\n", kt->name);
match = 0;
mismatch = 0;
score = 0;
seq = 0;
pkey = -1;
for (keyc = min_keycode; keyc <= max_keycode; keyc++) {
for (i = 0; i < 2; i++) {
#ifdef HAVE_XKB
keysym = XkbKeycodeToKeysym(display, keyc, alternate, i);
#else
keysym = X11_KeycodeToKeysym(key_mapping, keysyms_per_keycode,
min_keycode, keyc, alternate, i);
#endif
charset_to_unicode(&X_charset, &ckey[i],
(const unsigned char *)&keysym, sizeof(keysym));
}
if (ckey[0] != U_VOID && (ckey[0] & 0xf000) != 0xe000) {
/* search for a match in layout table */
/* right now, we just find an absolute match for defined positions */
/* (undefined positions are ignored, so if it's defined as "3#" in */
/* the table, it's okay that the X server has "3#£", for example) */
/* however, the score will be higher for longer matches */
for (key = 0; key < kt->sizemap; key++) {
lkey[0] = keysym_to_unicode(kt->key_map[key]);
lkey[1] = keysym_to_unicode(kt->shift_map[key]);
for (ok = 0, i = 0; (ok >= 0) && (i < 2); i++) {
if (lkey[i] != U_VOID) {
if (lkey[i] == ckey[i])
ok++;
else if (ckey[i] != U_VOID)
ok = -1;
}
}
if (debug_level('k') > 5)
k_printf("key: % 3d score % 2d for keycode % 3d, %04x %04x, "
"got %04x %04x\n",
key, ok, keyc, lkey[0], lkey[1], ckey[0], ckey[1]);
if (ok > 0) {
score += ok;
break;
}
}
/* count the matches and mismatches */
if (ok > 0) {
match++;
/* and how much the keycode order matches */
if (key > pkey) seq++;
pkey = key;
} else {
/* print spaces instead of \0's */
for (i = 0; i < ARRAY_SIZE(ckey); i++) if (!ckey[i]) ckey[i] = ' ';
mismatch++;
score -= 2;
}
}
}
k_printf("matches=%d, mismatches=%d, seq=%d, score=%d\n",
match, mismatch, seq, score);
if (score > max_score[alternate] ||
(score == max_score[alternate] &&
((seq > max_seq[alternate]) ||
(seq == max_seq[alternate] && kt->keyboard == KEYB_AUTO)))) {
/* best match so far */
if (alternate) {
/* alternate keyboards are optional so a threshold is used */
if (score > 20) config.altkeytable = kt;
}
else
config.keytable = kt;
max_score[alternate] = score;
max_seq[alternate] = seq;
ismatch = !mismatch;
}
alternate = !alternate;
if (!alternate)
kt++;
}
cleanup_charset_state(&X_charset);
#ifndef HAVE_XKB
XFree(key_mapping);
#endif
/* we're done, report results if necessary */
if (!ismatch)
k_printf("Using closest match (%s) for scan/virtual codes mapping.\n",
config.keytable->name);
c_printf("CONF: detected layout is \"%s\"\n", config.keytable->name);
if (config.altkeytable)
c_printf("CONF: detected alternate layout: %s\n", config.altkeytable->name);
XCloseDisplay(display);
return 0;
}
main()
{
Window w2;
Display *dpy = XOpenDisplay(NIL);
assert(dpy);
Screen *scr = DefaultScreenOfDisplay(dpy);
// CreateWindow
Window w = XCreateWindow(dpy, RootWindowOfScreen(scr), 10, 100, 200, 300, 0, CopyFromParent,
CopyFromParent, CopyFromParent,
0, NIL);
XDestroyWindow(dpy, w);
// CreateWindow with arguments
XSetWindowAttributes swa;
swa.background_pixel = WhitePixelOfScreen(scr);
swa.bit_gravity = NorthWestGravity;
swa.border_pixel = BlackPixelOfScreen(scr);
swa.colormap = DefaultColormapOfScreen(scr);
swa.cursor = None;
swa.win_gravity = NorthGravity;
w = XCreateWindow(dpy, RootWindowOfScreen(scr), 10, 100, 200, 300, 0, CopyFromParent,
CopyFromParent, CopyFromParent,
CWBackPixel | CWBitGravity | CWBorderPixel | CWColormap | CWCursor | CWWinGravity,
&swa);
// CreateWindow with other arguments
XDestroyWindow(dpy, w);
Pixmap pixmap = XCreatePixmap(dpy, RootWindowOfScreen(scr), 45, 25, DefaultDepthOfScreen(scr));
assert(pixmap);
swa.background_pixmap = pixmap;
swa.border_pixmap = pixmap;
w = XCreateWindow(dpy, RootWindowOfScreen(scr), 10, 100, 200, 300, 0, CopyFromParent,
CopyFromParent, CopyFromParent,
CWBackPixmap | CWBorderPixmap,
&swa);
// ChangeWindowAttributes
swa.backing_planes = 0x1;
swa.backing_pixel = WhitePixelOfScreen(scr);
swa.save_under = True;
swa.event_mask = KeyPressMask | KeyReleaseMask;
swa.do_not_propagate_mask = ButtonPressMask | Button4MotionMask;
swa.override_redirect = False;
XChangeWindowAttributes(dpy, w, CWBackingPlanes | CWBackingPixel | CWSaveUnder | CWEventMask
| CWDontPropagate | CWOverrideRedirect, &swa);
// GetWindowAttributes
XWindowAttributes wa;
Status success = XGetWindowAttributes(dpy, w, &wa);
// DestroyWindow (done)
// DestroySubwindows
w2 = XCreateWindow(dpy, w, 20, 30, 40, 50, 3, CopyFromParent, CopyFromParent, CopyFromParent, 0, NIL);
XDestroySubwindows(dpy, w);
// ChangeSaveSet
// Display *dpy2 = XOpenDisplay(NIL);
// assert(dpy2);
// XAddToSaveSet(dpy2, w);
// XCloseDisplay(dpy2);
// ReparentWindow
w2 = XCreateWindow(dpy, RootWindowOfScreen(scr), 20, 30, 40, 50, 3,
CopyFromParent, CopyFromParent, CopyFromParent, 0, NIL);
XReparentWindow(dpy, w2, w, 10, 5);
// MapWindow
XMapWindow(dpy, w);
// MapSubwindows
XMapSubwindows(dpy, w);
// UnmapWindow
XUnmapWindow(dpy, w);
// UnmapSubwindows
XMapWindow(dpy, w);
XUnmapSubwindows(dpy, w2);
XMapSubwindows(dpy, w);
// ConfigureWindow
Window w3 = XCreateWindow(dpy, w, 10, 50, 100, 10, 2,
CopyFromParent, CopyFromParent, CopyFromParent, 0, NIL);
XMapWindow(dpy, w3);
XWindowChanges wc;
wc.x = -5;
wc.y = -10;
wc.width = 50;
wc.height = 40;
wc.border_width = 7;
wc.sibling = w2;
wc.stack_mode = Opposite;
XConfigureWindow(dpy, w3,
CWX | CWY | CWWidth | CWHeight | CWBorderWidth | CWSibling | CWStackMode,
&wc);
// CirculateWindow
XCirculateSubwindows(dpy, w, RaiseLowest);
// GetGeometry
Window root;
int x, y;
unsigned width, height, border_width, depth;
XGetGeometry(dpy, w, &root, &x, &y, &width, &height, &border_width, &depth);
// QueryTree
Window parent;
Window *children;
unsigned nchildren;
success = XQueryTree(dpy, w, &root, &parent, &children, &nchildren);
XFree(children);
// InternAtom
Atom a = XInternAtom(dpy, "WM_PROTOCOLS", True);
// GetAtomName
char *string = XGetAtomName(dpy, XA_PRIMARY);
XFree(string);
// ChangeProperty
XStoreName(dpy, w, "test window");
// DeleteProperty
XDeleteProperty(dpy, w, XA_WM_NAME);
// GetProperty
// TODO
// ListProperties
int num_prop;
Atom *list = XListProperties(dpy, w, &num_prop);
XFree(list);
// SetSelectionOwner
XSetSelectionOwner(dpy, XA_PRIMARY, w, 12000);
XSetSelectionOwner(dpy, XA_SECONDARY, w, CurrentTime);
// GetSelectionOwner
Window wx = XGetSelectionOwner(dpy, XA_PRIMARY);
// ConvertSelection
XConvertSelection(dpy, XA_SECONDARY, XA_CURSOR, XA_POINT, w, CurrentTime);
// SendEvent
// GrabPointer
std::cerr << "Grabbing" << std::endl;
int res = XGrabPointer(dpy, w, False, Button5MotionMask | PointerMotionHintMask,
GrabModeSync, GrabModeAsync, w, None, CurrentTime);
XSync(dpy, False);
// sleep(5);
// UngrabPointer
std::cerr << "Ungrabbing" << std::endl;
XUngrabPointer(dpy, CurrentTime);
// GrabButton
XGrabButton(dpy, 3, ShiftMask | ControlMask, w, False, PointerMotionHintMask | Button2MotionMask,
GrabModeAsync, GrabModeSync, None, None);
XGrabButton(dpy, 2, AnyModifier, w, False, PointerMotionHintMask | Button2MotionMask,
GrabModeAsync, GrabModeSync, None, None);
// UngrabButton
XUngrabButton(dpy, 2, LockMask, w);
// ChangeActivePointerGrab
XChangeActivePointerGrab(dpy, ButtonPressMask, None, CurrentTime);
// GrabKeyboard
XGrabKeyboard(dpy, w, True, GrabModeSync, GrabModeSync, 12000);
// UngrabKeyboard
XUngrabKeyboard(dpy, 13000);
// GrabKey
XGrabKey(dpy, XKeysymToKeycode(dpy, XK_Tab), ShiftMask | Mod3Mask, w, True, GrabModeSync,
GrabModeSync);
// UngrabKey
XUngrabKey(dpy, AnyKey, AnyModifier, w);
// AllowEvents
XAllowEvents(dpy, AsyncPointer, 14000);
// GrabServer
XGrabServer(dpy);
// UngrabServer
XUngrabServer(dpy);
// QueryPointer
Window child;
int root_x, root_y, win_x, win_y;
unsigned mask;
Bool bres = XQueryPointer(dpy, w, &root, &child, &root_x, &root_y, &win_x, &win_y, &mask);
// GetMotionEvents
int nevents;
XGetMotionEvents(dpy, w, 15000, 16000, &nevents);
// TranslateCoordinates
int dest_x, dest_y;
XTranslateCoordinates(dpy, w, w2, 10, 20, &dest_x, &dest_y, &child);
// WarpPointer
XWarpPointer(dpy, w, w2, 0, 0, 100, 100, 20, 30);
// SetInputFocus
XSetInputFocus(dpy,w, RevertToPointerRoot, 17000);
XSetInputFocus(dpy, PointerRoot, RevertToPointerRoot, 17000);
// GetInputFocus
Window focus;
int revert_to;
XGetInputFocus(dpy, &focus, &revert_to);
// QueryKeymap
char keys_return[32];
XQueryKeymap(dpy, keys_return);
// OpenFont
Font fid = XLoadFont(dpy, "cursor");
// CloseFont
XUnloadFont(dpy, fid);
// QueryFont
XFontStruct *fs = XLoadQueryFont(dpy, "cursor");
assert(fs);
// QueryTextExtents
int direction, font_ascent, font_descent;
XCharStruct overall;
XQueryTextExtents(dpy, fs -> fid, "toto", 4, &direction, &font_ascent, &font_descent, &overall);
XQueryTextExtents(dpy, fs -> fid, "odd__length", 11, &direction, &font_ascent, &font_descent, &overall);
XChar2b c2bs;
c2bs.byte1 = '$';
c2bs.byte2 = 'B';
XQueryTextExtents16(dpy, fs -> fid, &c2bs, 1, &direction, &font_ascent, &font_descent, &overall);
XQueryTextExtents(dpy, fs -> fid, longString, strlen(longString), &direction, &font_ascent,
&font_descent, &overall);
// ListFonts
int actual_count;
char **fontList = XListFonts(dpy, "*", 100, &actual_count);
XFree((char *)fontList);
// ListFontsWithInfo
int count;
XFontStruct *info;
char **names = XListFontsWithInfo(dpy, "*", 100, &count, &info);
XFreeFontInfo(names, info, count);
// SetFontPath
// GetFontPath
int npaths;
char **charList = XGetFontPath(dpy, &npaths);
char **charList2 = new char *[npaths + 1];
memcpy(charList2, charList, npaths * sizeof(char *));
charList2[npaths] = charList2[0];
XSetFontPath(dpy, charList2, npaths + 1);
XSetFontPath(dpy, charList, npaths); // Reset to some reasonnable value
XFreeFontPath(charList);
delete [] charList2;
// CreatePixmap
Pixmap pix2 = XCreatePixmap(dpy, w, 100, 200, DefaultDepthOfScreen(scr));
// FreePixmap
XFreePixmap(dpy, pix2);
// CreateGC
Pixmap bitmap = XCreateBitmapFromData(dpy, RootWindowOfScreen(scr),
"\000\000\001\000\000\001\000\000\001\377\377\377", 3, 4);
XGCValues gcv;
gcv.function = GXand;
gcv.plane_mask = 0x1;
gcv.foreground = WhitePixelOfScreen(scr);
gcv.background = BlackPixelOfScreen(scr);
gcv.line_width = 2;
gcv.line_style = LineDoubleDash;
gcv.cap_style = CapProjecting;
gcv.join_style = JoinRound;
gcv.fill_style = FillStippled;
gcv.fill_rule = EvenOddRule;
gcv.arc_mode = ArcPieSlice;
gcv.tile = pixmap;
gcv.stipple = bitmap;
gcv.ts_x_origin = 3;
gcv.ts_y_origin = 4;
gcv.font = fs -> fid;
gcv.subwindow_mode = ClipByChildren;
gcv.graphics_exposures = True;
gcv.clip_x_origin = 5;
gcv.clip_y_origin = 6;
gcv.clip_mask = bitmap;
gcv.dash_offset = 1;
gcv.dashes = 0xc2;
GC gc = XCreateGC(dpy, w,
GCFunction | GCPlaneMask | GCForeground | GCBackground | GCLineWidth
| GCLineStyle | GCCapStyle | GCJoinStyle | GCFillStyle | GCFillRule | GCTile
| GCStipple | GCTileStipXOrigin | GCTileStipYOrigin | GCFont | GCSubwindowMode
| GCGraphicsExposures | GCClipXOrigin | GCClipYOrigin | GCClipMask | GCDashOffset
| GCDashList | GCArcMode,
&gcv);
// ChangeGC
gcv.function = GXandReverse;
// Only a few of these should appear, since the values are cached on the client side by the Xlib.
XChangeGC(dpy, gc, GCFunction | GCLineStyle | GCStipple | GCGraphicsExposures | GCDashList, &gcv);
// CopyGC
GC gc2 = XCreateGC(dpy, w, 0, NIL);
XCopyGC(dpy, gc, GCFunction | GCLineStyle | GCStipple | GCGraphicsExposures | GCDashList, gc2);
// SetDashes
XSetDashes(dpy, gc, 3, "\001\377\001", 3);
// SetClipRectangles
XRectangle rectangles[] = { { 10, 20, 30, 40 }, { 100, 200, 5, 3 }, { -5, 1, 12, 24 } };
XSetClipRectangles(dpy, gc, 12, 9, rectangles, SIZEOF(rectangles), Unsorted);
// FreeGC
// done already
// ClearArea
XClearArea(dpy, w, 30, 10, 10, 100, False);
// CopyArea
XCopyArea(dpy, w, pixmap, gc, 0, 0, 100, 100, 10, 10);
// CopyPlane
// This won't work if the Screen doesn't have at least 3 planes
XCopyPlane(dpy, pixmap, w, gc, 20, 10, 40, 30, 0, 0, 0x4);
// PolyPoint
XDrawPoint(dpy, w, gc, 1, 2);
XPoint points[] = { { 3, 4 }, { 5, 6 } };
XDrawPoints(dpy, w, gc, points, SIZEOF(points), CoordModeOrigin);
// PolyLine
XDrawLines(dpy, w, gc, points, SIZEOF(points), CoordModePrevious);
// PolySegment
XSegment segments[] = { { 7, 8, 9, 10 }, { 11, 12, 13, 14 }, { 15, 16, 17, 18 } };
XDrawSegments(dpy, w, gc, segments, SIZEOF(segments));
// PolyRectangle
XDrawRectangles(dpy, w, gc, rectangles, SIZEOF(rectangles));
// PolyArc
XArc arcs[] = { { 10, 20, 30, 40, 50, 60 }, { -70, 80, 90, 100, 110, 120 },
{ 10, 20, 30, 40, 50, -30 } };
XDrawArcs(dpy, w, gc, arcs, SIZEOF(arcs));
// FillPoly
XFillPolygon(dpy, w, gc, points, SIZEOF(points), Convex, CoordModePrevious);
// PolyFillRectangle
XFillRectangles(dpy, w, gc, rectangles, SIZEOF(rectangles));
// PolyFillArc
XFillArcs(dpy, w, gc, arcs, SIZEOF(arcs));
// PutImage
// GetImage
XImage *image = XGetImage(dpy, w, 10, 20, 40, 30, AllPlanes, ZPixmap);
XPutImage(dpy, w, gc, image, 0, 0, 50, 60, 40, 30);
XSync(dpy, False); // Make the next request starts at the beginning of a packet
// PolyText8
XTextItem textItems[3];
textItems[0].chars = "toto";
textItems[0].nchars = strlen(textItems[0].chars);
textItems[0].delta = -3;
textItems[0].font = fs->fid;
textItems[1].chars = "titi";
textItems[1].nchars = strlen(textItems[1].chars);
textItems[1].delta = 3;
textItems[1].font = None;
textItems[2].chars = "tutu";
textItems[2].nchars = strlen(textItems[2].chars);
textItems[2].delta = 0;
textItems[2].font = fs->fid;
XDrawText(dpy, w, gc, 10, 10, textItems, 3);
XTextItem textItems2[3];
textItems2[0].chars = "totox";
textItems2[0].nchars = strlen(textItems2[0].chars);
textItems2[0].delta = -3;
textItems2[0].font = fs->fid;
textItems2[1].chars = "titi";
textItems2[1].nchars = strlen(textItems2[1].chars);
textItems2[1].delta = 3;
textItems2[1].font = None;
textItems2[2].chars = "tutu";
textItems2[2].nchars = strlen(textItems2[2].chars);
textItems2[2].delta = 0;
textItems2[2].font = fs->fid;
XDrawText(dpy, w, gc, 10, 10, textItems2, 3);
// PolyText16
XChar2b c2b2[] = { 0, 't', 0, 'x' };
XTextItem16 items16[] = { { &c2bs, 1, -5, None }, { NULL, 0, 0, None }, { c2b2, 2, 0, fs -> fid } };
XDrawText16(dpy, w, gc, 10, 0, items16, SIZEOF(items16));
// ImageText8
XDrawImageString(dpy, w, gc, 10, 10, "toto", 4);
// ImageText16
XDrawImageString16(dpy, w, gc, 10, 10, &c2bs, 1);
XDrawImageString16(dpy, w, gc, 10, 20, c2b2, 2);
// CreateColormap
// Don't forget to tell the kids how it was when we had only 8 bits per pixel.
Colormap colormap = XCreateColormap(dpy, w, DefaultVisualOfScreen(scr), None);
// FreeColormap
XFreeColormap(dpy, colormap);
colormap = XCreateColormap(dpy, w, DefaultVisualOfScreen(scr), None);
// CopyColormapAndFree
Colormap colormap2 = XCopyColormapAndFree(dpy, colormap);
// InstallColormap
XInstallColormap(dpy, colormap2);
// UninstallColormap
XUninstallColormap(dpy, colormap2);
// ListInstalledColormaps
int num;
Colormap *colormapList = XListInstalledColormaps(dpy, w, &num);
// AllocColor
XColor screen;
screen.red = 0;
screen.green = 32767;
screen.blue = 65535;
screen.flags = DoRed | DoGreen | DoBlue;
success = XAllocColor(dpy, colormap, &screen);
// AllocNamedColor
XColor screen2, exact;
success = XAllocNamedColor(dpy, colormap, "Wheat", &screen2, &exact);
// AllocColorCells
unsigned long plane_masks, pixels;
success = XAllocColorCells(dpy, colormap, False, &plane_masks, 1, &pixels, 1);
// AllocColorPlanes
unsigned long rmask, gmask, bmask;
success = XAllocColorPlanes(dpy, colormap, False, &pixels, 1, 0, 0, 0, &rmask, &gmask, &bmask);
// FreeColors
unsigned long pixels2[2] = { screen.pixel, screen2.pixel };
XFreeColors(dpy, colormap, pixels2, 2, 0);
// StoreColors
success = XAllocColorCells(dpy, colormap, False, NIL, 0, pixels2, 2);
// On many contemporary (that is, year 2000) video cards, you can't allocate read / write cells
// I want my requests to be sent, however.
if (!success) {
XSetErrorHandler(errorHandler);
}
XColor colors[2];
colors[0] = screen; colors[0].pixel = pixels2[0];
colors[1] = screen2; colors[1].pixel = pixels2[1];
XStoreColors(dpy, colormap, colors, 2);
// StoreNamedColor
XStoreNamedColor(dpy, colormap, "Wheat", colors[0].pixel, DoBlue);
XSync(dpy, False);
XSetErrorHandler(NIL); // Restore the default handler
// QueryColors
screen2.pixel = WhitePixelOfScreen(scr);
XQueryColor(dpy, colormap, &screen2);
// LookupColor
success = XLookupColor(dpy, colormap, "DarkCyan", &exact, &screen);
// CreateCursor
Cursor cursor = XCreatePixmapCursor(dpy, pixmap, None, &exact, colors, 10, 10);
// CreateGlyphCursor
Cursor cursor2 = XCreateGlyphCursor(dpy, fs -> fid, fs -> fid, 'X', 0, &exact, colors);
// FreeCursor
XFreeCursor(dpy, cursor2);
// RecolorCursor
XRecolorCursor(dpy, cursor, colors, &exact);
// QueryBestSize
success = XQueryBestSize(dpy, CursorShape, RootWindowOfScreen(scr), 100, 20, &width, &height);
// QueryExtension
int major_opcode, first_event, first_error;
XQueryExtension(dpy, "toto", &major_opcode, &first_event, &first_error);
// ListExtensions
int nextensions;
char **extensionList = XListExtensions(dpy, &nextensions);
for(char **p = extensionList; nextensions; nextensions--, p++) std::cout << *p << std::endl;
XFree(extensionList);
// ChangeKeyboardMapping
// GetKeyboardMapping
int min_keycodes, max_keycodes;
XDisplayKeycodes(dpy, &min_keycodes, &max_keycodes);
int keysyms_per_keycode;
KeySym *keysyms = XGetKeyboardMapping(dpy, min_keycodes, max_keycodes - min_keycodes + 1,
&keysyms_per_keycode);
XChangeKeyboardMapping(dpy, min_keycodes, keysyms_per_keycode, keysyms,
max_keycodes - min_keycodes + 1);
// ChangeKeyboardControl
// GetKeyboardControl
XKeyboardState keyboardState;
XGetKeyboardControl(dpy, &keyboardState);
XKeyboardControl keyboardValues;
keyboardValues.key_click_percent = keyboardState.key_click_percent;
keyboardValues.bell_percent = keyboardState.bell_percent;
keyboardValues.bell_pitch = keyboardState.bell_pitch;
keyboardValues.bell_duration = keyboardState.bell_duration;
keyboardValues.led = 1;
keyboardValues.led_mode = LedModeOn;
keyboardValues.key = min_keycodes;
keyboardValues.auto_repeat_mode = AutoRepeatModeDefault;
XChangeKeyboardControl(dpy,
KBKeyClickPercent | KBBellPercent | KBBellPitch | KBBellDuration
| KBLed | KBLedMode | KBKey | KBAutoRepeatMode,
&keyboardValues);
// Bell
XBell(dpy, 90);
// ChangePointerControl
// GetPointerControl
int accel_numerator, accel_denominator, threshold;
XGetPointerControl(dpy, &accel_numerator, &accel_denominator, &threshold);
XChangePointerControl(dpy, True, True, accel_numerator, accel_denominator, threshold);
// SetScreenSaver
// GetScreenSaver
int timeout, interval, prefer_blanking, allow_exposures;
XGetScreenSaver(dpy, &timeout, &interval, &prefer_blanking, &allow_exposures);
XSetScreenSaver(dpy, timeout, interval, prefer_blanking, allow_exposures);
// ChangeHosts
// ListHosts
int nhosts;
Bool state;
XHostAddress *hostList = XListHosts(dpy, &nhosts, &state);
XHostAddress host;
host.family = FamilyInternet;
host.length = 4;
host.address = "\001\002\003\004";
XAddHost(dpy, &host);
// SetAccessControl
XSetAccessControl(dpy, EnableAccess);
// SetCloseDownMode
XSetCloseDownMode(dpy, RetainTemporary);
// KillClient
XKillClient(dpy, AllTemporary);
// RotateProperties
Atom properties[] = { XInternAtom(dpy, "CUT_BUFFER0", False),
XInternAtom(dpy, "CUT_BUFFER1", False),
XInternAtom(dpy, "CUT_BUFFER2", False) };
XRotateWindowProperties(dpy, RootWindowOfScreen(scr), properties, SIZEOF(properties), -1);
// ForceScreenSaver
XForceScreenSaver(dpy, ScreenSaverReset);
// SetPointerMapping
// GetPointerMapping
unsigned char map[64];
int map_length = XGetPointerMapping(dpy, map, 64);
XSetPointerMapping(dpy, map, map_length);
// SetModifierMapping
// GetModifierMapping
XModifierKeymap *modmap = XGetModifierMapping(dpy);
XSetModifierMapping(dpy, modmap);
// NoOperation
XNoOp(dpy);
for(;;) {
XEvent e;
XNextEvent(dpy, &e);
std::cout << "Got an event of type " << e.type << std::endl;
}
}
static int x11ScancodeToDDKey(int scancode)
{
int symCount;
KeySym *syms = XGetKeyboardMapping(QX11Info::display(), scancode, 1, &symCount);
if (!symCount)
{
XFree(syms);
return 0;
}
KeySym sym = syms[0];
XFree(syms);
syms = nullptr;
if (sym == NoSymbol) return 0;
unsigned int ucs4 = X11_KeySymToUcs4(sym);
if (ucs4)
{
// ASCII range.
if (ucs4 > ' ' && ucs4 < 128) return ucs4;
//qDebug() << "ucs4:" << ucs4 << hex << ucs4 << dec;
return 0;
}
//qDebug() << "sym:" << hex << sym << dec;
switch (sym)
{
case XK_KP_Insert: return DDKEY_NUMPAD0;
case XK_KP_End: return DDKEY_NUMPAD1;
case XK_KP_Down: return DDKEY_NUMPAD2;
case XK_KP_Page_Down: return DDKEY_NUMPAD3;
case XK_KP_Left: return DDKEY_NUMPAD4;
case XK_KP_Begin: return DDKEY_NUMPAD5;
case XK_KP_Right: return DDKEY_NUMPAD6;
case XK_KP_Home: return DDKEY_NUMPAD7;
case XK_KP_Up: return DDKEY_NUMPAD8;
case XK_KP_Page_Up: return DDKEY_NUMPAD9;
case XK_KP_0: return DDKEY_NUMPAD0;
case XK_KP_1: return DDKEY_NUMPAD1;
case XK_KP_2: return DDKEY_NUMPAD2;
case XK_KP_3: return DDKEY_NUMPAD3;
case XK_KP_4: return DDKEY_NUMPAD4;
case XK_KP_5: return DDKEY_NUMPAD5;
case XK_KP_6: return DDKEY_NUMPAD6;
case XK_KP_7: return DDKEY_NUMPAD7;
case XK_KP_8: return DDKEY_NUMPAD8;
case XK_KP_9: return DDKEY_NUMPAD9;
case XK_KP_Equal: return '=';
case XK_KP_Multiply: return DDKEY_MULTIPLY;
case XK_KP_Add: return DDKEY_ADD;
case XK_KP_Separator: return DDKEY_DECIMAL;
case XK_KP_Delete: return DDKEY_DECIMAL;
case XK_KP_Subtract: return DDKEY_SUBTRACT;
case XK_KP_Decimal: return DDKEY_DECIMAL;
case XK_KP_Divide: return DDKEY_DIVIDE;
default:
break;
}
//qDebug() << "=>failed to map";
return 0;
}
/* Figure out what keysyms are attached to what modifiers */
void
update_modifier_map (void)
{
unsigned int modmasks[] =
{ Mod1Mask, Mod2Mask, Mod3Mask, Mod4Mask, Mod5Mask };
int row, col; /* The row and column in the modifier table. */
int found_alt_or_meta;
XModifierKeymap *mods;
int min_code, max_code;
int syms_per_code;
KeySym *syms;
rp_modifier_info.meta_mod_mask = 0;
rp_modifier_info.alt_mod_mask = 0;
rp_modifier_info.super_mod_mask = 0;
rp_modifier_info.hyper_mod_mask = 0;
rp_modifier_info.num_lock_mask = 0;
rp_modifier_info.scroll_lock_mask = 0;
XDisplayKeycodes (dpy, &min_code, &max_code);
syms = XGetKeyboardMapping (dpy,
min_code, max_code - min_code + 1,
&syms_per_code);
mods = XGetModifierMapping (dpy);
for (row=3; row < 8; row++)
{
found_alt_or_meta = 0;
for (col=0; col < mods->max_keypermod; col++)
{
KeyCode code = mods->modifiermap[(row * mods->max_keypermod) + col];
PRINT_DEBUG (("row: %d col: %d code: %d\n", row, col, code));
if (code == 0) continue;
/* Are any of this keycode's keysyms a meta key? */
{
int code_col;
for (code_col = 0; code_col < syms_per_code; code_col++)
{
int sym = syms[((code - min_code) * syms_per_code) + code_col];
switch (sym)
{
case XK_Meta_L:
case XK_Meta_R:
found_alt_or_meta = 1;
rp_modifier_info.meta_mod_mask |= modmasks[row - 3];
PRINT_DEBUG (("Found Meta on %d\n",
rp_modifier_info.meta_mod_mask));
break;
case XK_Alt_L:
case XK_Alt_R:
found_alt_or_meta = 1;
rp_modifier_info.alt_mod_mask |= modmasks[row - 3];
PRINT_DEBUG (("Found Alt on %d\n",
rp_modifier_info.alt_mod_mask));
break;
case XK_Super_L:
case XK_Super_R:
if (!found_alt_or_meta)
{
rp_modifier_info.super_mod_mask |= modmasks[row - 3];
PRINT_DEBUG (("Found Super on %d\n",
rp_modifier_info.super_mod_mask));
}
code_col = syms_per_code;
col = mods->max_keypermod;
break;
case XK_Hyper_L:
case XK_Hyper_R:
if (!found_alt_or_meta)
{
rp_modifier_info.hyper_mod_mask |= modmasks[row - 3];
PRINT_DEBUG (("Found Hyper on %d\n",
rp_modifier_info.hyper_mod_mask));
}
code_col = syms_per_code;
col = mods->max_keypermod;
break;
case XK_Num_Lock:
rp_modifier_info.num_lock_mask |= modmasks[row - 3];
PRINT_DEBUG (("Found NumLock on %d\n",
rp_modifier_info.num_lock_mask));
break;
case XK_Scroll_Lock:
rp_modifier_info.scroll_lock_mask |= modmasks[row - 3];
PRINT_DEBUG (("Found ScrollLock on %d\n",
rp_modifier_info.scroll_lock_mask));
break;
default:
break;
}
}
}
}
}
/* Stolen from Emacs 21.0.90 - xterm.c */
/* If we couldn't find any meta keys, accept any alt keys as meta keys. */
if (! rp_modifier_info.meta_mod_mask)
{
rp_modifier_info.meta_mod_mask = rp_modifier_info.alt_mod_mask;
rp_modifier_info.alt_mod_mask = 0;
}
/* If some keys are both alt and meta,
make them just meta, not alt. */
if (rp_modifier_info.alt_mod_mask & rp_modifier_info.meta_mod_mask)
{
rp_modifier_info.alt_mod_mask &= ~rp_modifier_info.meta_mod_mask;
}
XFree ((char *) syms);
XFreeModifiermap (mods);
}
static void xtest_key_press(unsigned char letter) {
unsigned int shiftcode = XKeysymToKeycode(dpy, XStringToKeysym("Shift_L"));
int upper = 0;
int skip_lookup = 0;
char s[2];
s[0] = letter;
s[1] = 0;
KeySym sym = XStringToKeysym(s);
KeyCode keycode;
if (sym == 0) {
sym = letter;
}
if (sym == '\n') {
sym = XK_Return;
skip_lookup = 1;
} else if (sym == '\t') {
sym = XK_Tab;
skip_lookup = 1;
}
keycode = XKeysymToKeycode(dpy, sym);
if (keycode == 0) {
sym = 0xff00 | letter;
keycode = XKeysymToKeycode(dpy, sym);
}
if (!skip_lookup) {
// Here we try to determine if a keysym
// needs a modifier key (shift), such as a
// shifted letter or symbol.
// The second keysym should be the shifted char
KeySym *syms;
int keysyms_per_keycode;
syms = XGetKeyboardMapping(dpy, keycode, 1, &keysyms_per_keycode);
int i = 0;
for (i = 0; i <= keysyms_per_keycode; i++) {
if (syms[i] == 0)
break;
if (i == 0 && syms[i] != letter)
upper = 1;
}
}
if (upper)
XTestFakeKeyEvent(dpy, shiftcode, True, 0);
XTestFakeKeyEvent(dpy, keycode, True, 0);
XTestFakeKeyEvent(dpy, keycode, False, 0);
if (upper)
XTestFakeKeyEvent(dpy, shiftcode, False, 0);
}
static guint
panel_applet_bindings_get_real_modifier_mask (guint mask)
{
guint real_mask;
Display *display;
int i, min_keycode, max_keycode, keysyms_per_keycode;
int max_keycodes_per_modifier;
KeySym *keysyms_for_keycodes;
XModifierKeymap *modifier_keymap;
real_mask = mask & ((Mod5Mask << 1) - 1);
/* Already real */
if (mask == real_mask) {
return mask;
}
display = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ());
XDisplayKeycodes (display, &min_keycode, &max_keycode);
keysyms_for_keycodes = XGetKeyboardMapping (display,
min_keycode,
max_keycode - min_keycode + 1,
&keysyms_per_keycode);
modifier_keymap = XGetModifierMapping (display);
max_keycodes_per_modifier = modifier_keymap->max_keypermod;
/* Loop through all the modifiers and find out which "real"
* (Mod2..Mod5) modifiers Super, Hyper, and Meta are mapped to.
* Note, Mod1 is used by the Alt modifier */
for (i = Mod2MapIndex * max_keycodes_per_modifier;
i < (Mod5MapIndex + 1) * max_keycodes_per_modifier;
i++) {
int keycode;
int j;
KeySym *keysyms_for_keycode;
int map_index;
int map_mask;
keycode = modifier_keymap->modifiermap[i];
/* The array is sparse, there may be some
* empty entries. Filter those out
* (along with any invalid entries) */
if (keycode < min_keycode || keycode > max_keycode)
continue;
keysyms_for_keycode = keysyms_for_keycodes +
(keycode - min_keycode) * keysyms_per_keycode;
map_index = i / max_keycodes_per_modifier;
g_assert (map_index <= Mod5MapIndex);
map_mask = 1 << map_index;
for (j = 0; j < keysyms_per_keycode; j++) {
switch (keysyms_for_keycode[j]) {
case XK_Super_L:
case XK_Super_R:
if (mask & GDK_SUPER_MASK)
real_mask |= map_mask;
break;
case XK_Hyper_L:
case XK_Hyper_R:
if (mask & GDK_HYPER_MASK)
real_mask |= map_mask;
break;
case XK_Meta_L:
case XK_Meta_R:
if (mask & GDK_META_MASK)
real_mask |= map_mask;
break;
default:
break;
}
}
}
XFreeModifiermap (modifier_keymap);
XFree (keysyms_for_keycodes);
return real_mask;
}
void enqueue(XEvent event)
{
if( qlen >= QUEUE_MAX ) {
fprintf(stderr, "Queue is full!\n");
return;
}
static KeyCode release_find = 0;
static KeyCode release_replace = 0;
static KeyCode release_kill1 = 0;
static KeyCode release_kill2 = 0;
int keysyms_per_keycode_return;
KeySym *keysym = XGetKeyboardMapping(display,
event.xkey.keycode,
1,
&keysyms_per_keycode_return);
if( keysym[0] == XK_Control_L ) // XCAPE shows us the second Ctrl_L press?!?!
return;
struct item *it = queue + qlen++;
it->exists = 1;
it->ev = event;
it->sym = keysym[0];
XFree(keysym);
#if 0
fprintf(stderr,
" %s event sym '%s', raw: %c\n",
event2str(it->ev),
XKeysymToString(it->sym),
(int)it->sym
);
#endif
int i;
#define KEYSWAP(newkeysym,newstate) do{ \
release_find = it->ev.xkey.keycode; \
it->ev.xkey.keycode = XKeysymToKeycode(display,(newkeysym)); \
if( newstate!=AnyModifier ) \
it->ev.xkey.state = newstate; \
release_replace = it->ev.xkey.keycode; \
} while(0)
#define REMOVE(keysym) do { \
KeyCode kc = XKeysymToKeycode(display,(keysym)); \
int phase = 1; \
for( i=0; i<qlen; i++ ) { \
struct item *it = queue + i; \
if( it->sym!=keysym ) \
continue; \
if( phase==1 && it->ev.type==KeyPress && it->exists ) { \
it->exists = 0; \
phase = 2; \
} \
else if( phase==2 && it->ev.type==KeyRelease && it->exists ) { \
it->exists = 0; \
phase = 3; \
break; \
} \
} \
if( phase==2 ) \
if( !release_kill1 ) \
release_kill1 = it->ev.xkey.keycode; \
else \
release_kill2 = it->ev.xkey.keycode; \
} while(0)
if( event.type==KeyRelease ) {
if( release_find==it->ev.xkey.keycode ) {
it->ev.xkey.keycode = release_replace;
release_find = 0;
release_replace = 0;
}
if( release_kill1==it->ev.xkey.keycode ) {
it->exists = 0;
release_kill1 = 0;
}
if( release_kill2==it->ev.xkey.keycode ) {
it->exists = 0;
release_kill2 = 0;
}
}
else if( level=='1' && it->sym==XK_KP_Multiply ) {
int status = XGrabKeyboard(display, window, 0, GrabModeAsync, GrabModeAsync, CurrentTime);
/* fprintf(stderr, "LEVEL1: XGrabKeyboard status: %d\n", status); */
it->exists = 0;
qlen--;
level = '2';
}
else if( level=='1' && it->sym==XK_KP_Divide ) {
release_find = it->ev.xkey.keycode;
it->ev.xkey.keycode = last_press_event.xkey.keycode;
it->ev.xkey.state = last_press_event.xkey.state;
release_replace = last_press_event.xkey.keycode;
/* fprintf(stderr, "LEVEL1: REPEAT! sym:%c state:%x\n", last_press_event.xkey.keycode, last_press_event.xkey.state); */
}
else if( level=='1' ) {
fprintf(stderr, "LEVEL1: Mysterious sym caught: %d '%c'\n", (int)it->sym, (int)it->sym);
// FIXME: this can happen when pressing a non-level-1 key while a level-1 key is already down, so we have focus
}
else if( level=='2' ) {
#define LJCODE(from,to,shf) \
( it->sym==from ) { \
KEYSWAP(to,(mask?:AnyModifier)|shf); \
XUngrabKeyboard(display, CurrentTime); \
level = '1'; \
mask = 0; \
}
#if 0
fprintf(stderr, "LEVELJ: XUngrabKeyboard, XK_* " #from " -> " #to "\n"); \
#endif
if( it->sym==XK_c ) {
REMOVE(it->sym);
it->exists = 0; // why doesn't REMOVE get rid of this???? FIXME
fprintf(stderr, "Control locked down\n");
mask |= ControlMask;
level = 'c';
}
else if( it->sym==XK_s ) {
REMOVE(it->sym);
it->exists = 0; // why doesn't REMOVE get rid of this???? FIXME
fprintf(stderr, "Shift locked down\n");
mask |= ShiftMask;
level = 's';
}
else if( it->sym==XK_a ) {
REMOVE(it->sym);
it->exists = 0; // why doesn't REMOVE get rid of this???? FIXME
fprintf(stderr, "Alt locked down\n");
mask |= Mod1Mask;
level = 'a';
}
else if( it->sym==XK_m ) {
REMOVE(it->sym);
it->exists = 0; // why doesn't REMOVE get rid of this???? FIXME
XUngrabKeyboard(display, CurrentTime);
for( i=0; i<COUNT(movkeys); i++ )
grab(movkeys[i], 0);
fprintf(stderr, "Entering movement mode\n");
level = 'm';
}
else if( it->sym==XK_n ) {
REMOVE(it->sym);
it->exists = 0; // why doesn't REMOVE get rid of this???? FIXME
XUngrabKeyboard(display, CurrentTime);
for( i=0; i<COUNT(numkeys); i++ )
grab(numkeys[i], 0);
fprintf(stderr, "Entering numpad mode\n");
level = 'n';
}
else if LJCODE(XK_KP_Multiply, XK_Escape, 0)
else if LJCODE(XK_q, XK_parenleft , ShiftMask)
else if LJCODE(XK_w, XK_parenright, ShiftMask)
else if LJCODE(XK_e, XK_Escape , 0)
// e unused
// r unused
else if LJCODE(XK_t, XK_asciitilde, ShiftMask)
// y unused
// u unused
else if LJCODE(XK_i, XK_braceleft , ShiftMask)
else if LJCODE(XK_o, XK_braceright, ShiftMask)
else if LJCODE(XK_p, XK_plus , ShiftMask)
// a alt
// s shift
else if LJCODE(XK_d, XK_Delete , 0)
else if LJCODE(XK_f, XK_underscore, ShiftMask)
else if LJCODE(XK_g, XK_grave , 0)
else if LJCODE(XK_h, XK_Home , 0)
else if LJCODE(XK_j, XK_Page_Down , 0)
else if LJCODE(XK_k, XK_Page_Up , 0)
else if LJCODE(XK_l, XK_End , 0)
else if LJCODE(XK_z, XK_less , 0)
else if LJCODE(XK_x, XK_greater , ShiftMask)
// c control
else if LJCODE(XK_v, XK_bar , ShiftMask)
else if LJCODE(XK_b, XK_BackSpace , 0)
// n number mode
// m movement mode
else if LJCODE(XK_1 , XK_F1 , 0)
else if LJCODE(XK_2 , XK_F2 , 0)
else if LJCODE(XK_3 , XK_F3 , 0)
else if LJCODE(XK_4 , XK_F4 , 0)
else if LJCODE(XK_5 , XK_F5 , 0)
else if LJCODE(XK_6 , XK_F6 , 0)
else if LJCODE(XK_7 , XK_F7 , 0)
else if LJCODE(XK_8 , XK_F8 , 0)
else if LJCODE(XK_9 , XK_F9 , 0)
else if LJCODE(XK_0 , XK_F10, 0)
else if LJCODE(XK_minus, XK_F11, 0)
else if LJCODE(XK_equal, XK_F12, 0)
else {
XUngrabKeyboard(display, CurrentTime);
level = '1';
mask = 0;
}
}
// Translate an X11 key code to a GLFW key code.
//
static int translateKeyCode(int scancode)
{
int keySym;
// Valid key code range is [8,255], according to the Xlib manual
if (scancode < 8 || scancode > 255)
return GLFW_KEY_UNKNOWN;
if (_glfw.x11.xkb.available)
{
// Try secondary keysym, for numeric keypad keys
// Note: This way we always force "NumLock = ON", which is intentional
// since the returned key code should correspond to a physical
// location.
keySym = XkbKeycodeToKeysym(_glfw.x11.display, scancode, 0, 1);
switch (keySym)
{
case XK_KP_0: return GLFW_KEY_KP_0;
case XK_KP_1: return GLFW_KEY_KP_1;
case XK_KP_2: return GLFW_KEY_KP_2;
case XK_KP_3: return GLFW_KEY_KP_3;
case XK_KP_4: return GLFW_KEY_KP_4;
case XK_KP_5: return GLFW_KEY_KP_5;
case XK_KP_6: return GLFW_KEY_KP_6;
case XK_KP_7: return GLFW_KEY_KP_7;
case XK_KP_8: return GLFW_KEY_KP_8;
case XK_KP_9: return GLFW_KEY_KP_9;
case XK_KP_Separator:
case XK_KP_Decimal: return GLFW_KEY_KP_DECIMAL;
case XK_KP_Equal: return GLFW_KEY_KP_EQUAL;
case XK_KP_Enter: return GLFW_KEY_KP_ENTER;
default: break;
}
// Now try primary keysym for function keys (non-printable keys). These
// should not be layout dependent (i.e. US layout and international
// layouts should give the same result).
keySym = XkbKeycodeToKeysym(_glfw.x11.display, scancode, 0, 0);
}
else
{
int dummy;
KeySym* keySyms;
keySyms = XGetKeyboardMapping(_glfw.x11.display, scancode, 1, &dummy);
keySym = keySyms[0];
XFree(keySyms);
}
switch (keySym)
{
case XK_Escape: return GLFW_KEY_ESCAPE;
case XK_Tab: return GLFW_KEY_TAB;
case XK_Shift_L: return GLFW_KEY_LEFT_SHIFT;
case XK_Shift_R: return GLFW_KEY_RIGHT_SHIFT;
case XK_Control_L: return GLFW_KEY_LEFT_CONTROL;
case XK_Control_R: return GLFW_KEY_RIGHT_CONTROL;
case XK_Meta_L:
case XK_Alt_L: return GLFW_KEY_LEFT_ALT;
case XK_Mode_switch: // Mapped to Alt_R on many keyboards
case XK_ISO_Level3_Shift: // AltGr on at least some machines
case XK_Meta_R:
case XK_Alt_R: return GLFW_KEY_RIGHT_ALT;
case XK_Super_L: return GLFW_KEY_LEFT_SUPER;
case XK_Super_R: return GLFW_KEY_RIGHT_SUPER;
case XK_Menu: return GLFW_KEY_MENU;
case XK_Num_Lock: return GLFW_KEY_NUM_LOCK;
case XK_Caps_Lock: return GLFW_KEY_CAPS_LOCK;
case XK_Print: return GLFW_KEY_PRINT_SCREEN;
case XK_Scroll_Lock: return GLFW_KEY_SCROLL_LOCK;
case XK_Pause: return GLFW_KEY_PAUSE;
case XK_Delete: return GLFW_KEY_DELETE;
case XK_BackSpace: return GLFW_KEY_BACKSPACE;
case XK_Return: return GLFW_KEY_ENTER;
case XK_Home: return GLFW_KEY_HOME;
case XK_End: return GLFW_KEY_END;
case XK_Page_Up: return GLFW_KEY_PAGE_UP;
case XK_Page_Down: return GLFW_KEY_PAGE_DOWN;
case XK_Insert: return GLFW_KEY_INSERT;
case XK_Left: return GLFW_KEY_LEFT;
case XK_Right: return GLFW_KEY_RIGHT;
case XK_Down: return GLFW_KEY_DOWN;
case XK_Up: return GLFW_KEY_UP;
case XK_F1: return GLFW_KEY_F1;
case XK_F2: return GLFW_KEY_F2;
case XK_F3: return GLFW_KEY_F3;
case XK_F4: return GLFW_KEY_F4;
case XK_F5: return GLFW_KEY_F5;
case XK_F6: return GLFW_KEY_F6;
case XK_F7: return GLFW_KEY_F7;
case XK_F8: return GLFW_KEY_F8;
case XK_F9: return GLFW_KEY_F9;
case XK_F10: return GLFW_KEY_F10;
case XK_F11: return GLFW_KEY_F11;
case XK_F12: return GLFW_KEY_F12;
case XK_F13: return GLFW_KEY_F13;
case XK_F14: return GLFW_KEY_F14;
case XK_F15: return GLFW_KEY_F15;
case XK_F16: return GLFW_KEY_F16;
case XK_F17: return GLFW_KEY_F17;
case XK_F18: return GLFW_KEY_F18;
case XK_F19: return GLFW_KEY_F19;
case XK_F20: return GLFW_KEY_F20;
case XK_F21: return GLFW_KEY_F21;
case XK_F22: return GLFW_KEY_F22;
case XK_F23: return GLFW_KEY_F23;
case XK_F24: return GLFW_KEY_F24;
case XK_F25: return GLFW_KEY_F25;
// Numeric keypad
case XK_KP_Divide: return GLFW_KEY_KP_DIVIDE;
case XK_KP_Multiply: return GLFW_KEY_KP_MULTIPLY;
case XK_KP_Subtract: return GLFW_KEY_KP_SUBTRACT;
case XK_KP_Add: return GLFW_KEY_KP_ADD;
// These should have been detected in secondary keysym test above!
case XK_KP_Insert: return GLFW_KEY_KP_0;
case XK_KP_End: return GLFW_KEY_KP_1;
case XK_KP_Down: return GLFW_KEY_KP_2;
case XK_KP_Page_Down: return GLFW_KEY_KP_3;
case XK_KP_Left: return GLFW_KEY_KP_4;
case XK_KP_Right: return GLFW_KEY_KP_6;
case XK_KP_Home: return GLFW_KEY_KP_7;
case XK_KP_Up: return GLFW_KEY_KP_8;
case XK_KP_Page_Up: return GLFW_KEY_KP_9;
case XK_KP_Delete: return GLFW_KEY_KP_DECIMAL;
case XK_KP_Equal: return GLFW_KEY_KP_EQUAL;
case XK_KP_Enter: return GLFW_KEY_KP_ENTER;
// Last resort: Check for printable keys (should not happen if the XKB
// extension is available). This will give a layout dependent mapping
// (which is wrong, and we may miss some keys, especially on non-US
// keyboards), but it's better than nothing...
case XK_a: return GLFW_KEY_A;
case XK_b: return GLFW_KEY_B;
case XK_c: return GLFW_KEY_C;
case XK_d: return GLFW_KEY_D;
case XK_e: return GLFW_KEY_E;
case XK_f: return GLFW_KEY_F;
case XK_g: return GLFW_KEY_G;
case XK_h: return GLFW_KEY_H;
case XK_i: return GLFW_KEY_I;
case XK_j: return GLFW_KEY_J;
case XK_k: return GLFW_KEY_K;
case XK_l: return GLFW_KEY_L;
case XK_m: return GLFW_KEY_M;
case XK_n: return GLFW_KEY_N;
case XK_o: return GLFW_KEY_O;
case XK_p: return GLFW_KEY_P;
case XK_q: return GLFW_KEY_Q;
case XK_r: return GLFW_KEY_R;
case XK_s: return GLFW_KEY_S;
case XK_t: return GLFW_KEY_T;
case XK_u: return GLFW_KEY_U;
case XK_v: return GLFW_KEY_V;
case XK_w: return GLFW_KEY_W;
case XK_x: return GLFW_KEY_X;
case XK_y: return GLFW_KEY_Y;
case XK_z: return GLFW_KEY_Z;
case XK_1: return GLFW_KEY_1;
case XK_2: return GLFW_KEY_2;
case XK_3: return GLFW_KEY_3;
case XK_4: return GLFW_KEY_4;
case XK_5: return GLFW_KEY_5;
case XK_6: return GLFW_KEY_6;
case XK_7: return GLFW_KEY_7;
case XK_8: return GLFW_KEY_8;
case XK_9: return GLFW_KEY_9;
case XK_0: return GLFW_KEY_0;
case XK_space: return GLFW_KEY_SPACE;
case XK_minus: return GLFW_KEY_MINUS;
case XK_equal: return GLFW_KEY_EQUAL;
case XK_bracketleft: return GLFW_KEY_LEFT_BRACKET;
case XK_bracketright: return GLFW_KEY_RIGHT_BRACKET;
case XK_backslash: return GLFW_KEY_BACKSLASH;
case XK_semicolon: return GLFW_KEY_SEMICOLON;
case XK_apostrophe: return GLFW_KEY_APOSTROPHE;
case XK_grave: return GLFW_KEY_GRAVE_ACCENT;
case XK_comma: return GLFW_KEY_COMMA;
case XK_period: return GLFW_KEY_PERIOD;
case XK_slash: return GLFW_KEY_SLASH;
case XK_less: return GLFW_KEY_WORLD_1; // At least in some layouts...
default: break;
}
// No matching translation was found
return GLFW_KEY_UNKNOWN;
}
void
startDriver() {
x_dpy = XOpenDisplay(NULL);
if (!x_dpy) {
fprintf(stderr, "XOpenDisplay failed\n");
exit(1);
}
e_dpy = eglGetDisplay(x_dpy);
if (!e_dpy) {
fprintf(stderr, "eglGetDisplay failed: %s\n", eglGetErrorStr());
exit(1);
}
EGLint e_major, e_minor;
if (!eglInitialize(e_dpy, &e_major, &e_minor)) {
fprintf(stderr, "eglInitialize failed: %s\n", eglGetErrorStr());
exit(1);
}
if (!eglBindAPI(EGL_OPENGL_ES_API)) {
fprintf(stderr, "eglBindAPI failed: %s\n", eglGetErrorStr());
exit(1);
}
static const EGLint attribs[] = {
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_BLUE_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_RED_SIZE, 8,
EGL_DEPTH_SIZE, 16,
EGL_CONFIG_CAVEAT, EGL_NONE,
EGL_NONE
};
EGLint num_configs;
if (!eglChooseConfig(e_dpy, attribs, &e_config, 1, &num_configs)) {
fprintf(stderr, "eglChooseConfig failed: %s\n", eglGetErrorStr());
exit(1);
}
EGLint vid;
if (!eglGetConfigAttrib(e_dpy, e_config, EGL_NATIVE_VISUAL_ID, &vid)) {
fprintf(stderr, "eglGetConfigAttrib failed: %s\n", eglGetErrorStr());
exit(1);
}
XVisualInfo visTemplate;
visTemplate.visualid = vid;
int num_visuals;
x_visual_info = XGetVisualInfo(x_dpy, VisualIDMask, &visTemplate, &num_visuals);
if (!x_visual_info) {
fprintf(stderr, "XGetVisualInfo failed\n");
exit(1);
}
x_root = RootWindow(x_dpy, DefaultScreen(x_dpy));
x_colormap = XCreateColormap(x_dpy, x_root, x_visual_info->visual, AllocNone);
if (!x_colormap) {
fprintf(stderr, "XCreateColormap failed\n");
exit(1);
}
static const EGLint ctx_attribs[] = {
EGL_CONTEXT_CLIENT_VERSION, 3,
EGL_NONE
};
e_ctx = eglCreateContext(e_dpy, e_config, EGL_NO_CONTEXT, ctx_attribs);
if (!e_ctx) {
fprintf(stderr, "eglCreateContext failed: %s\n", eglGetErrorStr());
exit(1);
}
wm_delete_window = XInternAtom(x_dpy, "WM_DELETE_WINDOW", False);
wm_protocols = XInternAtom(x_dpy, "WM_PROTOCOLS", False);
wm_take_focus= XInternAtom(x_dpy, "WM_TAKE_FOCUS", False);
const int key_lo = 8;
const int key_hi = 255;
int keysyms_per_keycode;
KeySym *keysyms = XGetKeyboardMapping(x_dpy, key_lo, key_hi-key_lo+1, &keysyms_per_keycode);
if (keysyms_per_keycode < 2) {
fprintf(stderr, "XGetKeyboardMapping returned too few keysyms per keycode: %d\n", keysyms_per_keycode);
exit(1);
}
int k;
for (k = key_lo; k <= key_hi; k++) {
onKeysym(k,
keysyms[(k-key_lo)*keysyms_per_keycode + 0],
keysyms[(k-key_lo)*keysyms_per_keycode + 1]);
}
}
