static gboolean is_modifier(guint keycode)
{
gint i;
gint map_size;
XModifierKeymap* mod_keymap;
gboolean retval = FALSE;
mod_keymap = XGetModifierMapping(gdk_x11_display_get_xdisplay(gdk_display_get_default()));
map_size = 8 * mod_keymap->max_keypermod;
i = 0;
while (i < map_size)
{
if (keycode == mod_keymap->modifiermap[i])
{
retval = TRUE;
break;
}
++i;
}
XFreeModifiermap(mod_keymap);
return retval;
}
/* 取得 LED 狀態 */
int gui_get_led_state(KeySym keysym)
{
KeyCode keycode = XKeysymToKeycode(gui->display, keysym);
if (keycode == NoSymbol)
return 0;
int keymask;
Window w1, w2;
int n1,n2,n3,n4;
unsigned int imask;
XModifierKeymap *map = XGetModifierMapping(gui->display);
int i;
for (i = 0 ; i < 8 ; i++)
{
if (map->modifiermap[map->max_keypermod * i] == keycode)
{
keymask = 1 << i;
}
}
XQueryPointer(gui->display, gui->root, &w1, &w2,
&n1, &n2, &n3, &n4, &imask);
XFreeModifiermap(map);
return ((keymask & imask) != 0);
}
Bool listen_init(Listen* obj, Display* display, Bool modifiers,
int idle_time, int poll_time) {
int i;
KeyCode kc;
XModifierKeymap* modmap;
obj->modifiers = modifiers;
obj->idle_time = ((double)idle_time)/1000.0;
obj->poll_time = poll_time*1000;
obj->display = display;
memset(obj->mask, 0xff, MTRACKD_KEYMAP_SIZE);
modmap = XGetModifierMapping(obj->display);
for (i = 0; i < 8 * modmap->max_keypermod; i++) {
kc = modmap->modifiermap[i];
if (kc != 0)
clear_bit(obj->mask, kc);
}
XFreeModifiermap(modmap);
XQueryKeymap(obj->display, (char*)obj->current);
memcpy(obj->previous, obj->current,
sizeof(unsigned char)*MTRACKD_KEYMAP_SIZE);
return True;
}
void init_key(void)
{
if(!(dpy = XOpenDisplay(NULL)))
{
fprintf(stderr, "error: can not open display %s", XDisplayName(NULL));
exit(1);
}
screen = DefaultScreen(dpy);
root = RootWindow(dpy, screen);
opt_key = conf_get_key();
modmask = conf_get_mod();
int i, j;
XModifierKeymap *modmap = XGetModifierMapping(dpy);
for(i = 0; i < 8; i++)
{
for(j = 0; j < modmap->max_keypermod; j++)
{
if(modmap->modifiermap[i * modmap->max_keypermod + j] == XKeysymToKeycode(dpy, XK_Num_Lock))
numlockmask = (1 << i);
}
}
XFreeModifiermap(modmap);
}
static void getOffendingModifiers(void)
{
int i;
XModifierKeymap *modmap;
KeyCode nlock, slock;
static int mask_table[8] = {
ShiftMask, LockMask, ControlMask, Mod1Mask,
Mod2Mask, Mod3Mask, Mod4Mask, Mod5Mask
};
nlock = XKeysymToKeycode(dpy, XK_Num_Lock);
slock = XKeysymToKeycode(dpy, XK_Scroll_Lock);
/*
* Find out the masks for the NumLock and ScrollLock modifiers,
* so that we can bind the grabs for when they are enabled too.
*/
modmap = XGetModifierMapping(dpy);
if (modmap != NULL && modmap->max_keypermod > 0) {
for (i = 0; i < 8 * modmap->max_keypermod; i++) {
if (modmap->modifiermap[i] == nlock && nlock != 0)
_NumLockMask = mask_table[i / modmap->max_keypermod];
else if (modmap->modifiermap[i] == slock && slock != 0)
_ScrollLockMask = mask_table[i / modmap->max_keypermod];
}
}
if (modmap)
XFreeModifiermap(modmap);
}
void iupdrvGetKeyState(char* key)
{
char keys[32];
Display* display = (Display*)iupdrvGetDisplay();
XModifierKeymap *modMap = XGetModifierMapping(display);
XQueryKeymap(display, keys);
if (xCheckModifier(modMap->modifiermap, modMap->max_keypermod, ShiftMapIndex, keys))
key[0] = 'S';
else
key[0] = ' ';
if (xCheckModifier(modMap->modifiermap, modMap->max_keypermod, ControlMapIndex, keys))
key[1] = 'C';
else
key[1] = ' ';
if (xCheckModifier(modMap->modifiermap, modMap->max_keypermod, Mod1MapIndex, keys) ||
xCheckModifier(modMap->modifiermap, modMap->max_keypermod, Mod5MapIndex, keys))
key[2] = 'A';
else
key[2] = ' ';
if (xCheckModifier(modMap->modifiermap, modMap->max_keypermod, Mod4MapIndex, keys))
key[3] = 'Y';
else
key[3] = ' ';
key[4] = 0;
XFreeModifiermap(modMap);
}
/* The interpretation of the ModN modifiers is dependent on what keys
are bound to them: Mod1 does not necessarily mean "meta". It only
means "meta" if Meta_L or Meta_R are bound to it. If Meta_L is on
Mod5, then Mod5 is the one that means Meta. Oh, and Meta and Alt
aren't necessarily the same thing. Icepicks in my forehead!
*/
static unsigned int
do_icccm_meta_key_stupidity (Display *dpy)
{
unsigned int modbits = 0;
# ifndef HAVE_COCOA
int i, j, k;
XModifierKeymap *modmap = XGetModifierMapping (dpy);
for (i = 3; i < 8; i++)
for (j = 0; j < modmap->max_keypermod; j++)
{
int code = modmap->modifiermap[i * modmap->max_keypermod + j];
KeySym *syms;
int nsyms = 0;
if (code == 0) continue;
syms = XGetKeyboardMapping (dpy, code, 1, &nsyms);
for (k = 0; k < nsyms; k++)
if (syms[k] == XK_Meta_L || syms[k] == XK_Meta_R ||
syms[k] == XK_Alt_L || syms[k] == XK_Alt_R)
modbits |= (1 << i);
XFree (syms);
}
XFreeModifiermap (modmap);
# endif /* HAVE_COCOA */
return modbits;
}
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;
}
// Calculates the masks (actually, shifts) used by the modifier with the KeySym "sym"
int FindModifierMask(Display* disp, KeySym sym)
{
int modmask = 0;
XModifierKeymap* modmap = XGetModifierMapping(disp);
if (modmap) {
const int last = 8*modmap->max_keypermod;
//begin at 4th row, where Mod1 starts
for (int i = Mod1MapIndex*modmap->max_keypermod; i < last && !modmask; i++) {
//
const KeyCode kc = modmap->modifiermap[i];
if (!kc)
continue;
int keysyms_per_keycode = 0;
// For each keycode attached to this modifier, get a list of all keysyms
// attached with this keycode. If any of those keysyms is what we are looking
// for, then this is the modifier to use
KeySym* symlist = XGetKeyboardMapping(disp, kc, 1, &keysyms_per_keycode);
if ( symlist) {
for (int j = 0; j < keysyms_per_keycode; j++) {
if (sym == symlist[j]) {
modmask = (i / modmap->max_keypermod);
break;
}
}
XFree(symlist);
}
}
XFreeModifiermap(modmap);
}
return modmask;
}
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 );
}
void
setup() {
unsigned int i, j;
XModifierKeymap *modmap;
XSetWindowAttributes wa;
/* init modifier map */
modmap = XGetModifierMapping(dpy);
for(i = 0; i < 8; i++)
for(j = 0; j < modmap->max_keypermod; j++) {
if(modmap->modifiermap[i * modmap->max_keypermod + j]
== XKeysymToKeycode(dpy, XK_Num_Lock))
numlockmask = (1 << i);
}
XFreeModifiermap(modmap);
wa.override_redirect = 0;
wa.background_pixmap = ParentRelative;
wa.event_mask = ExposureMask | ButtonPressMask | KeyPressMask;
mw = DisplayWidth(dpy, screen)-mx;
my = bottom ? DisplayHeight(dpy, screen) - mh : 0;
mh = 20;
win = XCreateWindow(dpy, root, mx,
my, mw, mh, 0,
DefaultDepth(dpy, screen), CopyFromParent,
DefaultVisual(dpy, screen),
CWOverrideRedirect | CWBackPixmap | CWEventMask, &wa);
setstruts(0);
XMapRaised(dpy, win);
XMoveWindow(dpy, win, mx, my);
}
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
}
/**
* "Find out the masks for the NumLock and ScrollLock modifiers,
* so that we can bind the grabs for when they are enabled too."
*/
void initMasks(Display* display) {
KeyCode nlock = XKeysymToKeycode(display, XK_Num_Lock);
KeyCode slock = XKeysymToKeycode(display, XK_Scroll_Lock);
static int mask_table[8] = {
ShiftMask, LockMask, ControlMask, Mod1Mask,
Mod2Mask, Mod3Mask, Mod4Mask, Mod5Mask
};
XModifierKeymap* modmap = XGetModifierMapping(display);
if (modmap != NULL && modmap->max_keypermod > 0) {
for (int i = 0; i < 8 * modmap->max_keypermod; i++) {
if (modmap->modifiermap[i] == nlock && nlock != 0) {
numLockMask = mask_table[i / modmap->max_keypermod];
} else if (modmap->modifiermap[i] == slock && slock != 0) {
scrollLockMask = mask_table[i / modmap->max_keypermod];
}
}
}
capsLockMask = LockMask;
if (modmap) {
XFreeModifiermap(modmap);
}
}
/*
* From eggcellrenderkeys.c.
*/
gboolean
tomboy_keybinder_is_modifier (guint keycode)
{
gint i;
gint map_size;
XModifierKeymap *mod_keymap;
gboolean retval = FALSE;
mod_keymap = XGetModifierMapping (gdk_display);
map_size = 8 * mod_keymap->max_keypermod;
i = 0;
while (i < map_size) {
if (keycode == mod_keymap->modifiermap[i]) {
retval = TRUE;
break;
}
++i;
}
XFreeModifiermap (mod_keymap);
return retval;
}
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) {
KeySym keysym = XKeycodeToKeysym(sysdisp, keycode, 0);
if (keysym == XK_Meta_L || keysym == XK_Meta_R)
_MetaDown = (1 << m);
else if (keysym == XK_Alt_L || keysym == XK_Alt_R)
_AltDown = (1 << m);
else if (keysym == XK_Mode_switch)
_ModeSwitch = (1 << m);
}
}
}
XFreeModifiermap(modmap);
}
static void
disable_caps_lock_default_behavior ()
{
Display *display;
KeyCode keycode;
XModifierKeymap *map;
char *error_msg;
display = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ());
keycode = XKeysymToKeycode (display, XK_Caps_Lock);
map = XGetModifierMapping (display);
map = XDeleteModifiermapEntry (map, keycode, LockMapIndex);
error_msg = NULL;
switch (XSetModifierMapping (display, map)) {
case MappingSuccess:
break;
case MappingBusy:
error_msg = "since it's busy.";
break;
default:
error_msg = "for some unknown reason.";
break;
}
if (error_msg != NULL) {
g_printerr ("SuperSwitcher could not disable the Caps Lock key, %s\n",
error_msg);
}
XFreeModifiermap (map);
}
static unsigned int
get_modifier_mask(KeySym sym)
{
unsigned int i, mask;
XModifierKeymap *mod;
KeyCode kcode;
const int masks[8] = {
ShiftMask, LockMask, ControlMask,
Mod1Mask, Mod2Mask, Mod3Mask, Mod4Mask, Mod5Mask
};
mod = XGetModifierMapping(gXDisplay);
kcode = XKeysymToKeycode(gXDisplay,sym);
if (mod) {
for (i = 0; i < (8 * mod->max_keypermod); i++){
if (!mod->modifiermap[i]) continue;
else if (kcode == mod->modifiermap[i]){
mask = masks[i / mod->max_keypermod];
XFreeModifiermap(mod);
return mask;
}
}
XFreeModifiermap(mod);
}
return 0;
}
int get_key_state(int key)
{
KeyCode key_code = XKeysymToKeycode(main_window->display, key);
XModifierKeymap *map = XGetModifierMapping(main_window->display);
if (key_code == NoSymbol)
return 0;
int i, key_mask = 0;
for (i = 0; i < 8; i++)
if (map->modifiermap[map->max_keypermod * i] == key_code)
key_mask = 1 << i;
if (key_mask == 0)
return 0;
XFreeModifiermap(map);
Window wDummy;
int iDummy;
unsigned int mask;
XQueryPointer(main_window->display, DefaultRootWindow(main_window->display), &wDummy, &wDummy, &iDummy, &iDummy, &iDummy, &iDummy, &mask);
return ((mask & key_mask) != 0);
}
void ModifiersModule::updateWidgets()
{
if( m_pchkMacKeyboard->isChecked() ) {
// If keys are swapped around to reflect MacOS norms:
if( m_pchkMacSwap->isChecked() ) {
m_plblCtrl->setText( i18n("Command") ); // Ctrl in Alt's place
m_plblAlt->setText( i18n("Option") ); // Alt in Win's place
m_plblWin->setText( i18n("Control") ); // Win in Ctrl's place
} else {
m_plblCtrl->setText( i18n("Control") ); // Ctrl labeled Control
m_plblAlt->setText( i18n("Option") ); // Alt labeled Command
m_plblWin->setText( i18n("Command") ); // Win labeled Option
}
m_pchkMacSwap->setEnabled( true );
} else {
m_plblCtrl->setText( i18n(TQACCEL_OBJECT_NAME_STRING, "Ctrl") );
m_plblAlt->setText( i18n(TQACCEL_OBJECT_NAME_STRING, "Alt") );
m_plblWin->setText( i18n("Win") );
m_pchkMacSwap->setEnabled( false );
}
XModifierKeymap* xmk = XGetModifierMapping( tqt_xdisplay() );
for( int iKey = m_plstXMods->columns()-1; iKey < xmk->max_keypermod; iKey++ )
m_plstXMods->addColumn( i18n("Key %1").arg(iKey+1) );
//int iModWinDef = -1;
for( int iMod = 0; iMod < 8; iMod++ ) {
// Find the default modifier index for the Win key.
/*if( iMod > Mod2Index ) {
uint symX = XkbKeycodeToKeysym( tqt_xdisplay(), xmk->modifiermap[xmk->max_keypermod * iMod], 0, 0 );
if( symX == XK_Super_L || symX == XK_Super_R )
iModWinDef = iMod;
else if( iModWinDef == -1 && (symX == XK_Meta_L || symX == XK_Meta_R) )
iModWinDef = iMod;
}*/
// Insert items into X modifier map list
for( int iKey = 0; iKey < xmk->max_keypermod; iKey++ ) {
uint symX = XkbKeycodeToKeysym( tqt_xdisplay(), xmk->modifiermap[xmk->max_keypermod * iMod + iKey], 0, 0 );
m_plstXMods->itemAtIndex( iMod )->setText( 1 + iKey, XKeysymToString( symX ) );
}
}
XFreeModifiermap( xmk );
int i;
switch( KKeyNative::modX(KKey::WIN) ) {
case Mod2Mask: i = 2; break;
case Mod3Mask: i = 3; break;
case Mod4Mask: i = 4; break;
case Mod5Mask: i = 5; break;
default: i = 0;
}
if( i != 0 )
m_plblWinModX->setText( "mod" + TQString::number(i) );
else
m_plblWinModX->setText( "<" + i18n("None") + ">" );
}
void xf_kbd_init(xfContext* xfc)
{
xf_kbd_clear(xfc);
xfc->keyboard_layout_id = xfc->instance->settings->KeyboardLayout;
xfc->keyboard_layout_id = freerdp_keyboard_init(xfc->keyboard_layout_id);
xfc->instance->settings->KeyboardLayout = xfc->keyboard_layout_id;
xfc->modifier_map = XGetModifierMapping(xfc->display);
}
static void
Mappingaction(Widget w, XEvent *e, String *p, Cardinal *np)
{
if (modmap)
XFreeModifiermap(modmap);
modmap = XGetModifierMapping(e->xany.display);
if (modmap)
keypermod = modmap->max_keypermod;
}
boolean xf_event_MappingNotify(xfInfo* xfi, XEvent* event, boolean app)
{
if (event->xmapping.request == MappingModifier)
{
XFreeModifiermap(xfi->modifier_map);
xfi->modifier_map = XGetModifierMapping(xfi->display);
}
return true;
}
static int
xf_handle_event_MappingNotify(xfInfo * xfi, XEvent * xevent)
{
if (xevent->xmapping.request == MappingModifier)
{
XFreeModifiermap(xfi->mod_map);
xfi->mod_map = XGetModifierMapping(xfi->display);
}
return 0;
}
static BOOL xf_event_MappingNotify(xfInfo* xfi, XEvent* event, BOOL app)
{
if (event->xmapping.request == MappingModifier)
{
XFreeModifiermap(xfi->modifier_map);
xfi->modifier_map = XGetModifierMapping(xfi->display);
}
return TRUE;
}
bool KGlobalAccel::grabKey( uint keysym, uint mod ) {
// Most of this comes from kpanel/main.C
// Copyright (C) 1996,97 Matthias Ettrich
static int NumLockMask = 0;
debug("KGlobalAccel::grabKey");
if (!XKeysymToKeycode(qt_xdisplay(), keysym)) return false;
if (!NumLockMask){
XModifierKeymap* xmk = XGetModifierMapping(qt_xdisplay());
int i;
for (i=0; i<8; i++){
if (xmk->modifiermap[xmk->max_keypermod * i] ==
XKeysymToKeycode(qt_xdisplay(), XK_Num_Lock))
NumLockMask = (1<<i);
}
}
grabFailed = false;
// We wan't to catch only our own errors
XSync(qt_xdisplay(),0);
XErrorHandler savedErrorHandler=XSetErrorHandler(XGrabErrorHandler);
debug("Will grab key and variants with keyboard locks: %d, %d", keysym, mod);
XGrabKey(qt_xdisplay(),
XKeysymToKeycode(qt_xdisplay(), keysym), mod,
qt_xrootwin(), True,
GrabModeAsync, GrabModeSync);
XGrabKey(qt_xdisplay(),
XKeysymToKeycode(qt_xdisplay(), keysym), mod | LockMask,
qt_xrootwin(), True,
GrabModeAsync, GrabModeSync);
XGrabKey(qt_xdisplay(),
XKeysymToKeycode(qt_xdisplay(), keysym), mod | NumLockMask,
qt_xrootwin(), True,
GrabModeAsync, GrabModeSync);
XGrabKey(qt_xdisplay(),
XKeysymToKeycode(qt_xdisplay(), keysym), mod | LockMask | NumLockMask,
qt_xrootwin(), True,
GrabModeAsync, GrabModeSync);
XSync(qt_xdisplay(),0);
XSetErrorHandler(savedErrorHandler);
debug(" grabbed");
if (grabFailed) {
// FIXME: ungrab all successfull grabs!
//warning("Global grab failed!");
return false;
}
return true;
}
void
get_defaults()
{
char *opt;
XModifierKeymap *modmap;
unsigned int numlockmask = 0;
int i, j;
char def_key[] = "ControlAlt+y";
char def_key_bigger[] = "Control+KP_Add";
char def_key_smaller[] = "Control+KP_Subtract";
char def_key_full[] = "Alt+F11";
/* modifier stuff taken from evilwm */
modmap = XGetModifierMapping(dpy);
for (i = 0; i < 8; i++) {
for (j = 0; j < modmap->max_keypermod; j++) {
if (modmap->modifiermap[i * modmap->max_keypermod + j] == XKeysymToKeycode(dpy, XK_Num_Lock)) {
numlockmask = (1 << i);
}
}
}
XFreeModifiermap(modmap);
opt = XGetDefault(dpy, progname, "screenWidth");
opt_width = opt ? atoi(opt) : DisplayWidth(dpy, screen);
opt = XGetDefault(dpy, progname, "xrandrSupport");
opt_xrandr = opt ? atoi(opt) : 0;
opt = XGetDefault(dpy, progname, "handleColor");
opt_color = opt ? opt : "grey70";
opt = XGetDefault(dpy, progname, "handleWidth");
opt_bw = opt ? atoi(opt) : 3;
opt = XGetDefault(dpy, progname, "consoleHeight");
opt_height = opt ? atoi(opt) : 10;
opt = XGetDefault(dpy, progname, "xOffset");
opt_x = opt_x_orig = opt ? atoi(opt) : 0;
opt = XGetDefault(dpy, progname, "yOffset");
opt_y = opt_y_orig = opt ? atoi(opt) : 0;
opt = XGetDefault(dpy, progname, "aniDelay");
opt_delay = opt ? atoi(opt) : 40;
opt = XGetDefault(dpy, progname, "stepSize");
opt_step = opt_xrandr ? 0 : opt ? atoi(opt) : 1;
opt = XGetDefault(dpy, progname, "restart");
opt_restart = opt ? atoi(opt) : 0;
opt = XGetDefault(dpy, progname, "restartHidden");
opt_restart_hidden = opt ? atoi(opt) : 0;
opt = XGetDefault(dpy, progname, "term");
opt_term = opt ? opt : "xterm";
opt = XGetDefault(dpy, progname, "toggleKey");
opt_key = opt ? grab_that_key(opt, numlockmask) : grab_that_key(def_key, numlockmask);
opt = XGetDefault(dpy, progname, "keySmaller");
opt_key_smaller = opt ? grab_that_key(opt, numlockmask) : grab_that_key(def_key_smaller, numlockmask);
opt = XGetDefault(dpy, progname, "keyBigger");
opt_key_bigger = opt ? grab_that_key(opt, numlockmask) : grab_that_key(def_key_bigger, numlockmask);
opt = XGetDefault(dpy, progname, "keyFull");
opt_key_full = opt ? grab_that_key(opt, numlockmask) : grab_that_key(def_key_full, numlockmask);
}
static BOOL xf_event_MappingNotify(xfContext* xfc, XEvent* event, BOOL app)
{
if (event->xmapping.request == MappingModifier)
{
if (xfc->modifierMap)
XFreeModifiermap(xfc->modifierMap);
xfc->modifierMap = XGetModifierMapping(xfc->display);
}
return TRUE;
}
void grab_modifier_keys(Window window, int is_grab)
{
int i, k = 0;
XModifierKeymap *modmap = XGetModifierMapping (main_window->display);
for (i = 0; i < 8; i++)
{
int j;
for (j = 0; j < modmap->max_keypermod; j++)
{
// Dirty hack for using Shift /*and Ctrl*/ on xneur
if ((i == 0)/* || (i == 2)*/)
{
k++;
continue;
}
if (modmap->modifiermap[k])
{
/*
int keysyms_per_keycode_return;
KeySym *keysym = XGetKeyboardMapping(main_window->display,
modmap->modifiermap[k],
1,
&keysyms_per_keycode_return);
log_message (ERROR, "Modifiers List:");
log_message (ERROR, "%d %d %s", i, j, XKeysymToString(keysym[0]));
XFree(keysym);
*/
if (is_grab)
XGrabKey(main_window->display, modmap->modifiermap[k], AnyModifier, window, FALSE, GrabModeAsync, GrabModeAsync);
else
XUngrabKey(main_window->display, modmap->modifiermap[k], AnyModifier, window);
}
k++;
}
}
if (modmap)
XFreeModifiermap (modmap);
int menu_kc = XKeysymToKeycode(main_window->display, XK_Menu);
if (is_grab)
XGrabKey(main_window->display, menu_kc, AnyModifier, window, FALSE, GrabModeAsync, GrabModeAsync);
else
XUngrabKey(main_window->display, menu_kc, AnyModifier, window);
return;
}
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);
}
static void
Realize(Widget w, XtValueMask *valueMask, XSetWindowAttributes *attrs)
{
*valueMask |= CWBackingStore;
attrs->backing_store = Always;
XtCreateWindow(w, InputOutput, (Visual *)0, *valueMask, attrs);
XtSetKeyboardFocus(w->core.parent, w);
if ((modmap = XGetModifierMapping(XtDisplay(w))))
keypermod = modmap->max_keypermod;
Resize(w);
}
