void t_keyboard_reload(void)
{
gint i, j, k;
if(started)
t_keyboard_shutdown();
started = TRUE;
xim_init();
for(i = 0; i < T_KEYBOARD_NUM_MODKEYS; ++i)
modkeys_keys[i] = 0;
modmap = XGetModifierMapping(t_display);
XDisplayKeycodes(t_display, &min_keycode, &max_keycode);
keymap = XGetKeyboardMapping(t_display, min_keycode, max_keycode - min_keycode + 1, &keysyms_per_keycode);
alt_l = meta_l = super_l = hyper_l = FALSE;
for(i = 0; i < NUM_MASKS; ++i) {
for(j = 0; j < modmap->max_keypermod; ++j) {
KeySym sym;
KeyCode keycode = modmap->modifiermap[i * modmap->max_keypermod + j];
if(keycode) {
for(k = 0; k < keysyms_per_keycode; ++k) {
sym = keymap[(keycode - min_keycode) * keysyms_per_keycode + k];
if(sym != NoSymbol) {
set_modkey_mask(nth_mask(i), sym);
}
}
}
}
}
modkeys_keys[T_KEYBOARD_MODKEY_CAPSLOCK] = LockMask;
modkeys_keys[T_KEYBOARD_MODKEY_SHIFT] = ShiftMask;
modkeys_keys[T_KEYBOARD_MODKEY_CONTROL] = ControlMask;
}
KeyboardMouse::KeyboardMouse(Window window) : m_window(window)
{
memset(&m_state, 0, sizeof(m_state));
m_display = XOpenDisplay(NULL);
int min_keycode, max_keycode;
XDisplayKeycodes(m_display, &min_keycode, &max_keycode);
// Keyboard Keys
for (int i = min_keycode; i <= max_keycode; ++i)
{
Key *temp_key = new Key(m_display, i, m_state.keyboard);
if (temp_key->m_keyname.length())
AddInput(temp_key);
else
delete temp_key;
}
// Mouse Buttons
AddInput(new Button(Button1Mask, m_state.buttons));
AddInput(new Button(Button2Mask, m_state.buttons));
AddInput(new Button(Button3Mask, m_state.buttons));
AddInput(new Button(Button4Mask, m_state.buttons));
AddInput(new Button(Button5Mask, m_state.buttons));
// Mouse Cursor, X-/+ and Y-/+
for (int i = 0; i != 4; ++i)
AddInput(new Cursor(!!(i & 2), !!(i & 1), (&m_state.cursor.x)[!!(i & 2)]));
}
static int
hotkeys_connect (void) {
#ifndef NO_XLIB_H
finished = 0;
loop_tid = 0;
disp = XOpenDisplay (NULL);
if (!disp)
{
fprintf (stderr, "hotkeys: could not open display\n");
return -1;
}
XSetErrorHandler (x_err_handler);
read_config (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);
init_mapped_keycodes (disp, syms, first_kk, last_kk, ks_per_kk);
XFree (syms);
XSync (disp, 0);
loop_tid = deadbeef->thread_start (hotkeys_event_loop, 0);
#else
read_config ();
#endif
return 0;
}
EAPI int
ecore_x_test_fake_key_press(const char *key)
{
#ifdef ECORE_XTEST
KeyCode keycode = 0;
KeySym keysym = 0;
int shift = 0;
LOGFN(__FILE__, __LINE__, __FUNCTION__);
if (!strncmp(key, "Keycode-", 8))
keycode = atoi(key + 8);
else
{
keysym = XStringToKeysym(key);
if (keysym == NoSymbol) return 0;
keycode = XKeysymToKeycode(_ecore_x_disp, keysym);
if (XKeycodeToKeysym(_ecore_x_disp, keycode, 0) != keysym)
{
if (XKeycodeToKeysym(_ecore_x_disp, keycode, 1) == keysym)
shift = 1;
else
keycode = 0;
}
else
shift = 0;
}
if (keycode == 0)
{
static int mod = 0;
KeySym *keysyms;
int keycode_min, keycode_max, keycode_num;
int i;
XDisplayKeycodes(_ecore_x_disp, &keycode_min, &keycode_max);
keysyms = XGetKeyboardMapping(_ecore_x_disp, keycode_min,
keycode_max - keycode_min + 1,
&keycode_num);
mod = (mod + 1) & 0x7;
i = (keycode_max - keycode_min - mod - 1) * keycode_num;
keysyms[i] = keysym;
XChangeKeyboardMapping(_ecore_x_disp, keycode_min, keycode_num,
keysyms, (keycode_max - keycode_min));
XFree(keysyms);
XSync(_ecore_x_disp, False);
keycode = keycode_max - mod - 1;
}
if (shift)
XTestFakeKeyEvent(_ecore_x_disp,
XKeysymToKeycode(_ecore_x_disp, XK_Shift_L), 1, 0);
XTestFakeKeyEvent(_ecore_x_disp, keycode, 1, 0);
XTestFakeKeyEvent(_ecore_x_disp, keycode, 0, 0);
if (shift)
XTestFakeKeyEvent(_ecore_x_disp,
XKeysymToKeycode(_ecore_x_disp, XK_Shift_L), 0, 0);
return 1;
#else
return 0;
#endif
}
void init_modifier_keys() {
int i, k = 0;
int min_keycode, max_keycode, keysyms_per_keycode = 0;
std::list<KeySym> Mod1MaskSyms, Mod2MaskSyms, Mod3MaskSyms,
Mod4MaskSyms, Mod5MaskSyms;
gXNumLockMask = 0;
XModifierKeymap *map = XGetModifierMapping(XimServer::gDpy);
XDisplayKeycodes(XimServer::gDpy, &min_keycode, &max_keycode);
KeySym *sym = XGetKeyboardMapping(XimServer::gDpy,
static_cast<KeyCode>(min_keycode),
(max_keycode - min_keycode + 1), &keysyms_per_keycode);
for (i = 0; i < 8; i++) {
int j;
for (j = 0; j < map->max_keypermod; j++) {
if (map->modifiermap[k]) {
KeySym ks;
int index = 0;
do {
ks = XkbKeycodeToKeysym(XimServer::gDpy,
map->modifiermap[k], 0, index);
index++;
} while (!ks && index < keysyms_per_keycode);
switch (i) {
case ShiftMapIndex: break;
case LockMapIndex: break;
case ControlMapIndex: break;
case Mod1MapIndex: Mod1MaskSyms.push_back(ks); break;
case Mod2MapIndex: Mod2MaskSyms.push_back(ks); break;
case Mod3MapIndex: Mod3MaskSyms.push_back(ks); break;
case Mod4MapIndex: Mod4MaskSyms.push_back(ks); break;
case Mod5MapIndex: Mod5MaskSyms.push_back(ks); break;
default: break;
}
// Check NumLock key
if (ks == XK_Num_Lock)
gXNumLockMask |= (1 << i);
}
k++;
}
}
XFreeModifiermap(map);
XFree(sym);
gMod1Mask = check_modifier(Mod1MaskSyms);
gMod2Mask = check_modifier(Mod2MaskSyms);
gMod3Mask = check_modifier(Mod3MaskSyms);
gMod4Mask = check_modifier(Mod4MaskSyms);
gMod5Mask = check_modifier(Mod5MaskSyms);
if (uim_scm_c_bool(uim_scm_callf("require-dynlib", "s", "xkb")))
uim_scm_callf("%xkb-set-display", "p", XimServer::gDpy);
#if UIM_XIM_USE_JAPANESE_KANA_KEYBOARD_HACK
// Init at here to sync with proper update timing although not a modifier.
uim_x_kana_input_hack_init(XimServer::gDpy);
#endif
}
void ModifiersModule::setupMacModifierKeys()
{
const int CODE_Ctrl_L = 0x25, CODE_Ctrl_R = 0x6d;
const int CODE_Win_L = 0x73, CODE_Win_R = 0x74;
//const int CODE_Alt_L = 0x40, CODE_Alt_R = 0x71;
int keyCodeMin, keyCodeMax, nKeyCodes, nSymsPerCode;
XDisplayKeycodes( tqt_xdisplay(), &keyCodeMin, &keyCodeMax );
nKeyCodes = keyCodeMax - keyCodeMin + 1;
KeySym* rgKeySyms = XGetKeyboardMapping( tqt_xdisplay(), keyCodeMin, nKeyCodes, &nSymsPerCode );
XModifierKeymap* xmk = XGetModifierMapping( tqt_xdisplay() );
SET_CODE_SYM( CODE_Ctrl_L, XK_Super_L )
SET_CODE_SYM( CODE_Ctrl_R, XK_Super_R )
SET_CODE_SYM( CODE_Win_L, XK_Control_L )
SET_CODE_SYM( CODE_Win_R, XK_Control_R )
//SET_CODE_SYM( CODE_Win_L, XK_Alt_L )
//SET_CODE_SYM( CODE_Win_R, XK_Alt_R )
//SET_CODE_SYM( CODE_Alt_L, XK_Control_L )
//SET_CODE_SYM( CODE_Alt_R, XK_Control_R )
SET_MOD_CODE( ControlMapIndex, CODE_Win_L, CODE_Win_R );
SET_MOD_CODE( Mod4MapIndex, CODE_Ctrl_L, CODE_Ctrl_R );
//SET_MOD_CODE( ControlMapIndex, CODE_Alt_L, CODE_Alt_R );
//SET_MOD_CODE( Mod1MapIndex, CODE_Win_L, CODE_Win_R );
//SET_MOD_CODE( Mod4MapIndex, CODE_Ctrl_L, CODE_Ctrl_R );
XSetModifierMapping( tqt_xdisplay(), xmk );
XChangeKeyboardMapping( tqt_xdisplay(), keyCodeMin, nSymsPerCode, rgKeySyms, nKeyCodes );
XFree( rgKeySyms );
XFreeModifiermap( xmk );
}
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;
}
}
KeyboardMouse::KeyboardMouse(Window window, int opcode, int pointer, int keyboard)
: m_window(window), xi_opcode(opcode), pointer_deviceid(pointer), keyboard_deviceid(keyboard)
{
memset(&m_state, 0, sizeof(m_state));
// The cool thing about each KeyboardMouse object having its own Display
// is that each one gets its own separate copy of the X11 event stream,
// which it can individually filter to get just the events it's interested
// in. So be aware that each KeyboardMouse object actually has its own X11
// "context."
m_display = XOpenDisplay(nullptr);
int min_keycode, max_keycode;
XDisplayKeycodes(m_display, &min_keycode, &max_keycode);
int unused; // should always be 1
XIDeviceInfo* pointer_device = XIQueryDevice(m_display, pointer_deviceid, &unused);
name = std::string(pointer_device->name);
XIFreeDeviceInfo(pointer_device);
XIEventMask mask;
unsigned char mask_buf[(XI_LASTEVENT + 7)/8];
mask.mask_len = sizeof(mask_buf);
mask.mask = mask_buf;
memset(mask_buf, 0, sizeof(mask_buf));
XISetMask(mask_buf, XI_ButtonPress);
XISetMask(mask_buf, XI_ButtonRelease);
XISetMask(mask_buf, XI_RawMotion);
XISetMask(mask_buf, XI_KeyPress);
XISetMask(mask_buf, XI_KeyRelease);
SelectEventsForDevice(DefaultRootWindow(m_display), &mask, pointer_deviceid);
SelectEventsForDevice(DefaultRootWindow(m_display), &mask, keyboard_deviceid);
// Keyboard Keys
for (int i = min_keycode; i <= max_keycode; ++i)
{
Key* temp_key = new Key(m_display, i, m_state.keyboard);
if (temp_key->m_keyname.length())
AddInput(temp_key);
else
delete temp_key;
}
// Mouse Buttons
for (int i = 0; i < 5; i++)
AddInput(new Button(i, m_state.buttons));
// Mouse Cursor, X-/+ and Y-/+
for (int i = 0; i != 4; ++i)
AddInput(new Cursor(!!(i & 2), !!(i & 1), (&m_state.cursor.x)[!!(i & 2)]));
// Mouse Axis, X-/+ and Y-/+
for (int i = 0; i != 4; ++i)
AddInput(new Axis(!!(i & 2), !!(i & 1), (&m_state.axis.x)[!!(i & 2)]));
}
static XkbDescPtr
get_xkb (ClutterKeymapX11 *keymap_x11)
{
ClutterBackendX11 *backend_x11 = CLUTTER_BACKEND_X11 (keymap_x11->backend);
if (keymap_x11->max_keycode == 0)
XDisplayKeycodes (backend_x11->xdpy,
&keymap_x11->min_keycode,
&keymap_x11->max_keycode);
if (keymap_x11->xkb_desc == NULL)
{
int flags = XkbKeySymsMask
| XkbKeyTypesMask
| XkbModifierMapMask
| XkbVirtualModsMask;
keymap_x11->xkb_desc = XkbGetMap (backend_x11->xdpy, flags, XkbUseCoreKbd);
if (G_UNLIKELY (keymap_x11->xkb_desc == NULL))
{
g_error ("Failed to get the keymap from XKB");
return NULL;
}
flags = XkbGroupNamesMask | XkbVirtualModNamesMask;
XkbGetNames (backend_x11->xdpy, flags, keymap_x11->xkb_desc);
update_modmap (backend_x11->xdpy, keymap_x11);
}
else if (keymap_x11->xkb_map_serial != backend_x11->keymap_serial)
{
int flags = XkbKeySymsMask
| XkbKeyTypesMask
| XkbModifierMapMask
| XkbVirtualModsMask;
CLUTTER_NOTE (BACKEND, "Updating XKB keymap");
XkbGetUpdatedMap (backend_x11->xdpy, flags, keymap_x11->xkb_desc);
flags = XkbGroupNamesMask | XkbVirtualModNamesMask;
XkbGetNames (backend_x11->xdpy, flags, keymap_x11->xkb_desc);
update_modmap (backend_x11->xdpy, keymap_x11);
keymap_x11->xkb_map_serial = backend_x11->keymap_serial;
}
if (keymap_x11->num_lock_mask == 0)
keymap_x11->num_lock_mask = XkbKeysymToModifiers (backend_x11->xdpy,
XK_Num_Lock);
if (keymap_x11->scroll_lock_mask == 0)
keymap_x11->scroll_lock_mask = XkbKeysymToModifiers (backend_x11->xdpy,
XK_Scroll_Lock);
return keymap_x11->xkb_desc;
}
void
ParseKeyBinding( ConfigItem *item, FreeStorageElem *func_elem, struct FuncKey **keyboard )
{
KeySym keysym;
KeyCode keycode;
int context, mods ;
int min = 0, max = 0 ;
if( item == NULL )
return ;
item->ok_to_free = 1;
if( item == NULL || func_elem == NULL || keyboard == NULL )
return ;
if( func_elem->term == NULL || func_elem->term->type != TT_FUNCTION )
return ;
/*
* Don't let a 0 keycode go through, since that means AnyKey to the
* XGrabKey call in GrabKeys().
*/
if( (keysym = XStringToKeysym (item->data.binding.sym)) == NoSymbol ||
(keycode = XKeysymToKeycode (dpy, keysym)) == 0)
return ;
XDisplayKeycodes (dpy, &min, &max);
for (keycode = min; keycode <= max; keycode++)
if (XKeycodeToKeysym (dpy, keycode, 0) == keysym)
break;
if (keycode > max)
return ;
context = item->data.binding.context ;
mods = item->data.binding.mods ;
if( !ReadConfigItem( item, func_elem ) )
return ;
if( item->data.function )
{ /* gotta add it to the keyboard hash */
FuncKey *tmp ;
tmp = (FuncKey *) safecalloc (1, sizeof (FuncKey));
tmp->next = *keyboard;
*keyboard = tmp ;
tmp->name = mystrdup(item->data.binding.sym);
tmp->keycode = keycode;
tmp->cont = context;
tmp->mods = mods;
tmp->fdata = item->data.function;
item->data.function = NULL ;
}
item->ok_to_free = (item->data.function != NULL);
}
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;
}
bool x11_hotkeys::grab_keys(Display *dpy, Keys_t keys[], int nb_keys)
{
int i;
int min, max;
int screen;
XDisplayKeycodes(dpy, &min, &max);
#ifdef DEBUG
printf("\n");
printf("min_keycode=%d max_keycode=%d (ie: know keycodes)\n",
min, max);
#endif
for (i = 0; i < nb_keys; i++) {
#ifdef DEBUG
print_key(dpy, &keys[i]);
#endif
if (keys[i].type == SYM) {
for (screen = 0; screen < ScreenCount (dpy); screen++) {
my_grab_key(dpy, XKeysymToKeycode(dpy, keys[i].key.sym),
keys[i].modifier, RootWindow(dpy, screen));
}
} else if (keys[i].type == BUTTON) {
for (screen = 0; screen < ScreenCount (dpy); screen++) {
my_grab_button(dpy, keys[i].key.button, keys[i].modifier,
RootWindow (dpy, screen));
}
} else {
if (keys[i].key.code >= min && keys[i].key.code <= max) {
for (screen = 0; screen < ScreenCount (dpy); screen++) {
my_grab_key (dpy, keys[i].key.code, keys[i].modifier,
RootWindow (dpy, screen));
}
} else {
#ifdef DEBUG
print_key (dpy, &keys[i]);
fprintf (stderr,
" The keycode %d cannot be used, as it's not between the\n"
" min(%d) and max(%d) keycode of your keyboard.\n"
" Please increase the 'maximum' value in\n"
" /usr/X11R6/lib/X11/xkb/keycodes/xfree86,\n"
" then restart X.\n", keys[i].key.code, min, max);
#endif
return false;
}
}
}
return true;
}
/**
* DEBUG function
* Dump the keyboard layout to the release log.
*/
static void dumpLayout(Display *display)
{
LogRel(("Your keyboard layout does not appear to be fully supported by\n"
"VirtualBox. If you are experiencing keyboard problems this.\n"
"information may help us to resolve them.\n"
"(Note: please tell us if you are using a custom layout.)\n\n"
"The correct table for your layout is:\n"));
/* First, build up a table of scan-to-key code mappings */
unsigned scanToKeycode[512] = { 0 };
int minKey, maxKey;
XDisplayKeycodes(display, &minKey, &maxKey);
for (int i = minKey; i < maxKey; ++i)
scanToKeycode[X11DRV_KeyEvent(display, i)] = i;
LogRel(("\""));
printKey(display, scanToKeycode[0x29]); /* `~ */
for (int i = 2; i <= 0xd; ++i) /* 1! - =+ */
{
LogRel(("\",\""));
printKey(display, scanToKeycode[i]);
}
LogRel(("\",\n"));
LogRel(("\""));
printKey(display, scanToKeycode[0x10]); /* qQ */
for (int i = 0x11; i <= 0x1b; ++i) /* wW - ]} */
{
LogRel(("\",\""));
printKey(display, scanToKeycode[i]);
}
LogRel(("\",\n"));
LogRel(("\""));
printKey(display, scanToKeycode[0x1e]); /* aA */
for (int i = 0x1f; i <= 0x28; ++i) /* sS - '" */
{
LogRel(("\",\""));
printKey(display, scanToKeycode[i]);
}
LogRel(("\",\""));
printKey(display, scanToKeycode[0x2b]); /* \| */
LogRel(("\",\n"));
LogRel(("\""));
printKey(display, scanToKeycode[0x2c]); /* zZ */
for (int i = 0x2d; i <= 0x35; ++i) /* xX - /? */
{
LogRel(("\",\""));
printKey(display, scanToKeycode[i]);
}
LogRel(("\",\""));
printKey(display, scanToKeycode[0x56]); /* The 102nd key */
LogRel(("\",\""));
printKey(display, scanToKeycode[0x73]); /* The Brazilian key */
LogRel(("\",\""));
printKey(display, scanToKeycode[0x7d]); /* The Yen key */
LogRel(("\"\n\n"));
}
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;
}
/* Before connecting and creating UI */
void
xkeymap_init(void)
{
unsigned int max_keycode;
if (strcmp(g_keymapname, "none"))
{
if (xkeymap_read(g_keymapname))
keymap_loaded = True;
}
XDisplayKeycodes(g_display, &min_keycode, (int *) &max_keycode);
}
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);
}
}
void
sugar_key_grabber_grab_keys(SugarKeyGrabber *grabber, const char **keys)
{
const char **cur = keys;
const char *key;
Key *keyinfo = NULL;
int min_keycodes, max_keycodes;
XDisplayKeycodes(GDK_DISPLAY_XDISPLAY(gdk_display_get_default()),
&min_keycodes, &max_keycodes);
while (*cur != NULL) {
key = *cur;
cur += 1;
keyinfo = g_new0 (Key, 1);
keyinfo->key = g_strdup(key);
if (!egg_accelerator_parse_virtual (key, &keyinfo->keysym,
&keyinfo->keycode,
&keyinfo->state)) {
g_warning ("Invalid key specified: %s", key);
continue;
}
if (keyinfo->keycode < min_keycodes || keyinfo->keycode > max_keycodes) {
g_warning ("Keycode out of bounds: %d for key %s", keyinfo->keycode, key);
continue;
}
gdk_error_trap_push();
grab_key(grabber, keyinfo, TRUE);
gdk_flush();
gint error_code = gdk_error_trap_pop ();
if(!error_code)
grabber->keys = g_list_append(grabber->keys, keyinfo);
else if(error_code == BadAccess)
g_warning ("Grab failed, another application may already have access to key '%s'", key);
else if(error_code == BadValue)
g_warning ("Grab failed, invalid key %s specified. keysym: %u keycode: %u state: %u",
key, keyinfo->keysym, keyinfo->keycode, keyinfo->state);
else
g_warning ("Grab failed for key '%s' for unknown reason '%d'", key, error_code);
}
}
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;
}
extern struct fb *fbopen(int width, int height)
{
struct fb *fb;
int screen;
XSetWindowAttributes attr;
if(!(fb = malloc(sizeof *fb))) return 0;
if(!(fb->hw = malloc(sizeof *fb->hw))) return 0;
fb->hw->display = XOpenDisplay(0);
screen = DefaultScreen(fb->hw->display);
if(!width) fb->width = DisplayWidth(fb->hw->display, screen);
else fb->width = width;
if(!height) fb->height = DisplayHeight(fb->hw->display, screen);
else fb->height = height;
fb->pitch = fb->width;
fb->hw->depth = DefaultDepth(fb->hw->display, screen);
if(xwchkbpp(fb, fb->hw->depth) == -1) return 0;
attr.border_pixel = 0;
attr.background_pixel = 0;
attr.event_mask = ExposureMask | StructureNotifyMask;
fb->hw->window = XCreateWindow(fb->hw->display, RootWindow(fb->hw->display, screen),
0, 0, fb->width, fb->height, 0, 0, InputOutput, CopyFromParent,
CWBackPixel | CWBorderPixel | CWEventMask, &attr);
XMapRaised(fb->hw->display, fb->hw->window);
XSelectInput(fb->hw->display, fb->hw->window, KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask);
XDisplayKeycodes(fb->hw->display, &fb->hw->min_keycode, &fb->hw->max_keycode);
if(!(width || height)) xwfullscreen(fb, 1);
xwhidecursor(fb);
fb->hw->gc = DefaultGC(fb->hw->display, screen);
xwinitbackbuf(fb);
#ifdef HAVE_X11_XINPUT2
xwinitxi2(fb);
#endif
fb->hw->mice.dx = 0;
fb->hw->mice.dy = 0;
return fb;
}
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);
}
/* Before connecting and creating UI */
void
xkeymap_init(void)
{
unsigned int max_keycode;
char *mapname_ptr;
/* Make keymapname lowercase */
mapname_ptr = keymapname;
while (*mapname_ptr)
{
*mapname_ptr = tolower((int)*mapname_ptr);
mapname_ptr++;
}
if (strcmp(keymapname, "none"))
{
if (xkeymap_read(keymapname))
keymap_loaded = True;
}
XDisplayKeycodes(display, &min_keycode, (int *) &max_keycode);
}
/*
* 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 void
X11_DispatchEvent(_THIS)
{
SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata;
SDL_WindowData *data;
XEvent xevent;
int i;
SDL_zero(xevent); /* valgrind fix. --ryan. */
XNextEvent(videodata->display, &xevent);
/* filter events catchs XIM events and sends them to the correct
handler */
if (XFilterEvent(&xevent, None) == True) {
#if 0
printf("Filtered event type = %d display = %d window = %d\n",
xevent.type, xevent.xany.display, xevent.xany.window);
#endif
return;
}
/* Send a SDL_SYSWMEVENT if the application wants them */
if (SDL_ProcessEvents[SDL_SYSWMEVENT] == SDL_ENABLE) {
SDL_SysWMmsg wmmsg;
SDL_VERSION(&wmmsg.version);
wmmsg.subsystem = SDL_SYSWM_X11;
wmmsg.event.xevent = xevent;
SDL_SendSysWMEvent(&wmmsg);
}
data = NULL;
if (videodata && videodata->windowlist) {
for (i = 0; i < videodata->numwindows; ++i) {
if ((videodata->windowlist[i] != NULL) &&
(videodata->windowlist[i]->window == xevent.xany.window)) {
data = videodata->windowlist[i];
break;
}
}
}
if (!data) {
return;
}
#if 0
printf("type = %d display = %d window = %d\n",
xevent.type, xevent.xany.display, xevent.xany.window);
#endif
switch (xevent.type) {
/* Gaining mouse coverage? */
case EnterNotify:{
#ifdef DEBUG_XEVENTS
printf("EnterNotify! (%d,%d,%d)\n",
xevent.xcrossing.x,
xevent.xcrossing.y,
xevent.xcrossing.mode);
if (xevent.xcrossing.mode == NotifyGrab)
printf("Mode: NotifyGrab\n");
if (xevent.xcrossing.mode == NotifyUngrab)
printf("Mode: NotifyUngrab\n");
#endif
#if 1
/* FIXME: Should we reset data for all mice? */
for (i = 0; i < SDL_GetNumMice(); ++i) {
SDL_Mouse *mouse = SDL_GetMouse(i);
SDL_SetMouseFocus(mouse->id, data->windowID);
}
#endif
}
break;
/* Losing mouse coverage? */
case LeaveNotify:{
#ifdef DEBUG_XEVENTS
printf("LeaveNotify! (%d,%d,%d)\n",
xevent.xcrossing.x,
xevent.xcrossing.y,
xevent.xcrossing.mode);
if (xevent.xcrossing.mode == NotifyGrab)
printf("Mode: NotifyGrab\n");
if (xevent.xcrossing.mode == NotifyUngrab)
printf("Mode: NotifyUngrab\n");
#endif
if (xevent.xcrossing.detail != NotifyInferior) {
#if 1
/* FIXME: Should we reset data for all mice? */
for (i = 0; i < SDL_GetNumMice(); ++i) {
SDL_Mouse *mouse = SDL_GetMouse(i);
SDL_SetMouseFocus(mouse->id, 0);
}
#endif
}
}
break;
/* Gaining input focus? */
case FocusIn:{
#ifdef DEBUG_XEVENTS
printf("FocusIn!\n");
#endif
SDL_SetKeyboardFocus(videodata->keyboard, data->windowID);
#ifdef X_HAVE_UTF8_STRING
if (data->ic) {
XSetICFocus(data->ic);
}
#endif
}
break;
/* Losing input focus? */
case FocusOut:{
#ifdef DEBUG_XEVENTS
printf("FocusOut!\n");
#endif
SDL_SetKeyboardFocus(videodata->keyboard, 0);
#ifdef X_HAVE_UTF8_STRING
if (data->ic) {
XUnsetICFocus(data->ic);
}
#endif
}
break;
/* Generated upon EnterWindow and FocusIn */
case KeymapNotify:{
#ifdef DEBUG_XEVENTS
printf("KeymapNotify!\n");
#endif
/* FIXME:
X11_SetKeyboardState(SDL_Display, xevent.xkeymap.key_vector);
*/
}
break;
/* Has the keyboard layout changed? */
case MappingNotify:{
#ifdef DEBUG_XEVENTS
printf("MappingNotify!\n");
#endif
X11_UpdateKeymap(_this);
}
break;
/* Key press? */
case KeyPress:{
KeyCode keycode = xevent.xkey.keycode;
KeySym keysym = NoSymbol;
char text[SDL_TEXTINPUTEVENT_TEXT_SIZE];
Status status = 0;
#ifdef DEBUG_XEVENTS
printf("KeyPress (X11 keycode = 0x%X)\n", xevent.xkey.keycode);
#endif
SDL_SendKeyboardKey(videodata->keyboard, SDL_PRESSED,
videodata->key_layout[keycode]);
#if 0
if (videodata->key_layout[keycode] == SDLK_UNKNOWN) {
int min_keycode, max_keycode;
XDisplayKeycodes(videodata->display, &min_keycode,
&max_keycode);
keysym = XKeycodeToKeysym(videodata->display, keycode, 0);
fprintf(stderr,
"The key you just pressed is not recognized by SDL. To help get this fixed, please report this to the SDL mailing list <*****@*****.**> X11 KeyCode %d (%d), X11 KeySym 0x%X (%s).\n",
keycode, keycode - min_keycode, keysym,
XKeysymToString(keysym));
}
#endif
/* */
SDL_zero(text);
#ifdef X_HAVE_UTF8_STRING
if (data->ic) {
Xutf8LookupString(data->ic, &xevent.xkey, text, sizeof(text),
&keysym, &status);
}
#else
XLookupString(&xevent.xkey, text, sizeof(text), &keysym, NULL);
#endif
if (*text) {
SDL_SendKeyboardText(videodata->keyboard, text);
}
}
break;
/* Key release? */
case KeyRelease:{
KeyCode keycode = xevent.xkey.keycode;
#ifdef DEBUG_XEVENTS
printf("KeyRelease (X11 keycode = 0x%X)\n", xevent.xkey.keycode);
#endif
SDL_SendKeyboardKey(videodata->keyboard, SDL_RELEASED,
videodata->key_layout[keycode]);
}
break;
/* Have we been iconified? */
case UnmapNotify:{
#ifdef DEBUG_XEVENTS
printf("UnmapNotify!\n");
#endif
SDL_SendWindowEvent(data->windowID, SDL_WINDOWEVENT_HIDDEN, 0, 0);
SDL_SendWindowEvent(data->windowID, SDL_WINDOWEVENT_MINIMIZED, 0,
0);
}
break;
/* Have we been restored? */
case MapNotify:{
#ifdef DEBUG_XEVENTS
printf("MapNotify!\n");
#endif
SDL_SendWindowEvent(data->windowID, SDL_WINDOWEVENT_SHOWN, 0, 0);
SDL_SendWindowEvent(data->windowID, SDL_WINDOWEVENT_RESTORED, 0,
0);
}
break;
/* Have we been resized or moved? */
case ConfigureNotify:{
#ifdef DEBUG_XEVENTS
printf("ConfigureNotify! (resize: %dx%d)\n",
xevent.xconfigure.width, xevent.xconfigure.height);
#endif
SDL_SendWindowEvent(data->windowID, SDL_WINDOWEVENT_MOVED,
xevent.xconfigure.x, xevent.xconfigure.y);
SDL_SendWindowEvent(data->windowID, SDL_WINDOWEVENT_RESIZED,
xevent.xconfigure.width,
xevent.xconfigure.height);
}
break;
/* Have we been requested to quit (or another client message?) */
case ClientMessage:{
if ((xevent.xclient.format == 32) &&
(xevent.xclient.data.l[0] == videodata->WM_DELETE_WINDOW)) {
SDL_SendWindowEvent(data->windowID, SDL_WINDOWEVENT_CLOSE, 0,
0);
}
}
break;
/* Do we need to refresh ourselves? */
case Expose:{
#ifdef DEBUG_XEVENTS
printf("Expose (count = %d)\n", xevent.xexpose.count);
#endif
SDL_SendWindowEvent(data->windowID, SDL_WINDOWEVENT_EXPOSED, 0,
0);
}
break;
default:{
for (i = 0; i < SDL_GetNumMice(); ++i) {
SDL_Mouse *mouse;
#if SDL_VIDEO_DRIVER_X11_XINPUT
X11_MouseData *data;
#endif
mouse = SDL_GetMouse(i);
if (!mouse->driverdata) {
switch (xevent.type) {
case MotionNotify:
#ifdef DEBUG_MOTION
printf("X11 motion: %d,%d\n", xevent.xmotion.x,
xevent.xmotion.y);
#endif
SDL_SendMouseMotion(mouse->id, 0, xevent.xmotion.x,
xevent.xmotion.y, 0);
break;
case ButtonPress:
SDL_SendMouseButton(mouse->id, SDL_PRESSED,
xevent.xbutton.button);
break;
case ButtonRelease:
SDL_SendMouseButton(mouse->id, SDL_RELEASED,
xevent.xbutton.button);
break;
}
continue;
}
#if SDL_VIDEO_DRIVER_X11_XINPUT
data = (X11_MouseData *) mouse->driverdata;
if (xevent.type == data->motion) {
XDeviceMotionEvent *move =
(XDeviceMotionEvent *) & xevent;
#ifdef DEBUG_MOTION
printf("X11 motion: %d,%d\n", move->x, move->y);
#endif
SDL_SendMouseMotion(move->deviceid, 0, move->x, move->y,
move->axis_data[2]);
return;
}
if (xevent.type == data->button_pressed) {
XDeviceButtonPressedEvent *pressed =
(XDeviceButtonPressedEvent *) & xevent;
SDL_SendMouseButton(pressed->deviceid, SDL_PRESSED,
pressed->button);
return;
}
if (xevent.type == data->button_released) {
XDeviceButtonReleasedEvent *released =
(XDeviceButtonReleasedEvent *) & xevent;
SDL_SendMouseButton(released->deviceid, SDL_RELEASED,
released->button);
return;
}
if (xevent.type == data->proximity_in) {
XProximityNotifyEvent *proximity =
(XProximityNotifyEvent *) & xevent;
SDL_SendProximity(proximity->deviceid, proximity->x,
proximity->y, SDL_PROXIMITYIN);
return;
}
if (xevent.type == data->proximity_out) {
XProximityNotifyEvent *proximity =
(XProximityNotifyEvent *) & xevent;
SDL_SendProximity(proximity->deviceid, proximity->x,
proximity->y, SDL_PROXIMITYOUT);
return;
}
#endif
}
#ifdef DEBUG_XEVENTS
printf("Unhandled event %d\n", xevent.type);
#endif
}
break;
}
}
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;
}
/* 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);
}
void X11KeyFaker::connect()
{
// Open the display.
dpy = XOpenDisplay(displayName.toLatin1().data());
if (!dpy) {
// Try again in a few milliseconds. Xnest may not be alive yet.
// Give up after 10 seconds.
if (++retryCount < 50)
QTimer::singleShot(200, this, SLOT(connect()));
else
QTimer::singleShot(0, this, SIGNAL(couldNotConnect()));
return;
}
// Query the XTest extension, which we need to fake the key events.
int event_base, error_base, major, minor;
if (!XTestQueryExtension
(dpy, &event_base, &error_base, &major, &minor)) {
XCloseDisplay(dpy);
dpy = 0;
QTimer::singleShot(0, this, SIGNAL(couldNotConnect()));
return;
}
// Modify the Xnest's keyboard mappings to add Qtopia's special keysyms.
int min_keycode = 1, max_keycode = 255;
XDisplayKeycodes(dpy, &min_keycode, &max_keycode);
bool ok = true;
for (KeySym key = QTOPIAXK_Max; key >= QTOPIAXK_Min; --key) {
// This is an extension keysym, not part of the standard X11 set.
if (!allocateSpecialKeysym(dpy, min_keycode, max_keycode, key)) {
ok = false;
break;
}
}
static const KeySym specials[] = {
XF86XK_Back, // Qt::Key_Back
XF86XK_AudioLowerVolume, // Qt::Key_VolumeUp
XF86XK_AudioRaiseVolume, // Qt::Key_VolumeDown
XK_F28, // Qt::Key_F28
NoSymbol
};
int index = 0;
while (ok && specials[index] != NoSymbol) {
// This is a standard X11/XFree86 keysym that Qtopia uses,
// but it may not be on the user's physical keyboard.
if (!allocateSpecialKeysym
(dpy, min_keycode, max_keycode, specials[index]))
ok = false;
++index;
}
if (!ok)
qWarning() << "There are insufficient spare X11 keycodes to allocate the special Qtopia keys";
// Change the root cursor to something more reasonable than "X".
Cursor cursor = XCreateFontCursor(dpy, XC_left_ptr);
XDefineCursor(dpy, RootWindow(dpy, DefaultScreen(dpy)), cursor);
// Look up the shift keys.
shiftKeycode = XKeysymToKeycode(dpy, XK_Shift_L);
if (shiftKeycode == NoSymbol)
shiftKeycode = XKeysymToKeycode(dpy, XK_Shift_R);
modeSwitchKeycode = XKeysymToKeycode(dpy, XK_Mode_switch);
// Make sure all of the above changes are flushed.
XFlush(dpy);
// Set up event handling for the display.
QSocketNotifier *notifier = new QSocketNotifier
(ConnectionNumber(dpy), QSocketNotifier::Read, this);
QObject::connect(notifier, SIGNAL(activated(int)), this, SLOT(readyRead()));
// Make sure the file descriptor is not inherited across exec's.
fcntl(ConnectionNumber(dpy), F_SETFD, 1);
// Notify interested parties that we are now connected to the X display.
QTimer::singleShot(0, this, SIGNAL(connected()));
}
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;
}
