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); }