static gint
spi_dec_x11_get_keycode (SpiDEController *controller,
gint keysym,
gchar *key_str,
gboolean fix,
guint *modmask)
{
KeyCode keycode = 0;
if (key_str && key_str[0])
keysym = XStringToKeysym(key_str);
keycode = XKeysymToKeycode (spi_get_display (), (KeySym) keysym);
if (!keycode && fix)
{
DEControllerPrivateData *priv = controller->priv;
/* if there's no keycode available, fix it */
if (replace_map_keysym (priv, priv->reserved_keycode, keysym))
{
keycode = priv->reserved_keycode;
/*
* queue a timer to restore the old keycode. Ugly, but required
* due to races / asynchronous X delivery.
* Long-term fix is to extend the X keymap here instead of replace entries.
*/
priv->reserved_reset_timeout = g_timeout_add (500, spi_dec_reset_reserved, priv);
}
if (modmask)
*modmask = 0;
return keycode;
}
if (modmask)
*modmask = keysym_mod_mask (keysym, keycode);
return keycode;
}
static void xkeymap_char_to_keycode(struct _xkeymap *p, char ch, KeyCode *kc, int *modifier)
{
if ((ch == 10) || (ch == 13))
{
*kc = XKeysymToKeycode(main_window->display, XK_Return);
*modifier = 0;
return;
}
for (int i = p->min_keycode+1; i <= p->max_keycode; i++)
{
if (p->alphabet[p->latin_group][i].lower_sym[0] != NULLSYM)
if (p->alphabet[p->latin_group][i].lower_sym[0] == ch)
{
*kc = i;
*modifier = 0;
return;
}
if (p->alphabet[p->latin_group][i].upper_sym[0] != NULLSYM)
if (p->alphabet[p->latin_group][i].upper_sym[0] == ch)
{
*kc = i;
*modifier = 1;
return;
}
}
kc = 0;
modifier = 0;
return;
}
void handleKeyEvent(Display * dpy, MouseEvent *pEvent) {
unsigned int keycode = pEvent->value & 0xff;
int keysym;
switch (keycode) {
case kKeycodeLeft:
keysym = XK_Left;
break;
case kKeycodeRight:
keysym = XK_Right;
break;
case kKeycodeDown:
keysym = XK_Down;
break;
case kKeycodeUp:
keysym = XK_Up;
break;
case kKeycodeBackSpace:
keysym = XK_BackSpace;
break;
case kKeycodeReturn:
keysym = XK_Return;
break;
default:
XBell(dpy, 100);
return;
break;
}
KeyCode x11Keycode = XKeysymToKeycode(dpy, keysym);
if (x11Keycode != 0) {
XTestFakeKeyEvent(dpy, x11Keycode, pEvent->type == EVENT_KEY_DOWN, 0);
}
}
/*
* Purpose:
* Send a key press to a display
*
* Parameters:
* 1st - filled in video display structure
* 2nd - key press to send
* 3rd - PRESS or RELEASE
*
* Returns:
* GOOD on success
* BAD on failure
*
* History:
* 21/03/2001 (Mike Bennett): Coded to deal with special characters
* 22/03/2001 (Mike Bennett): Rewrote to use index arrays for specials
* 14/04/2001 (Mike Bennett): Rewrote completely to use external user
* definable key maps
*
* Note:
* This can easily be optimised in many ways, and REALLY should
* be. Anyone want to volunteer? Join the Down with Nasty Code
* Now Organisation :)
*/
int sendKey(WSETUP *wayv, GDISPLAY *video, char *key, int state) {
#ifdef HAVE_X_TEST
int i;
if(!XQueryExtension(video->display, "XTEST", &i, &i, &i))
return BAD;
/* Figure out what kind of keypress to send */
for(i = 0; wayv->keymap[i] != NULL; i++) {
/* Send a normal key PRESS/RELEASE? */
if(wayv->keymap[i]->normal && strcmp(wayv->keymap[i]->normal, key) == 0) {
XTestFakeKeyEvent(video->display, wayv->keymap[i]->kcode,
state, 0);
break;
}
/* Send a key PRESS/RELEASE with shift? */
if(wayv->keymap[i]->shift && strcmp(wayv->keymap[i]->shift, key) == 0) {
XTestFakeKeyEvent(video->display,
XKeysymToKeycode(video->display, XK_Shift_L),
state, 0);
XTestFakeKeyEvent(video->display, wayv->keymap[i]->kcode,
state, 0);
break;
}
}
XFlush(video->display);
/* XSync(video->display, True); */
#endif /* HAVE_X_TEST */
return GOOD;
}
/*
** Part of dialog mnemonic processing. Search the widget tree under w
** for widgets with mnemonics. When found, add a passive grab to the
** dialog widget for the mnemonic character, thus directing mnemonic
** events to the dialog widget.
*/
static void addMnemonicGrabs(Widget dialog, Widget w)
{
char mneString[2];
WidgetList children;
int numChildren, i, isMenu;
KeySym mnemonic = '\0';
unsigned char rowColType;
if (XtIsComposite(w)) {
if (XtClass(w) == xmRowColumnWidgetClass) {
XtVaGetValues(w, XmNrowColumnType, &rowColType, 0);
isMenu = rowColType != XmWORK_AREA;
} else
isMenu = False;
if (!isMenu) {
XtVaGetValues(w, XmNchildren, &children, XmNnumChildren,
&numChildren, 0);
for (i=0; i<numChildren; i++)
addMnemonicGrabs(dialog, children[i]);
}
} else {
XtVaGetValues(w, XmNmnemonic, &mnemonic, 0);
if (mnemonic != '\0') {
mneString[0] = mnemonic; mneString[1] = '\0';
XtGrabKey(dialog, XKeysymToKeycode(XtDisplay(dialog),
XStringToKeysym(mneString)), Mod1Mask,
True, GrabModeAsync, GrabModeAsync);
}
}
}
int XttHotkey::grab_key( int keysym, int modifier)
{
GdkDisplay *display = gdk_display_get_default();
int n_screens = gdk_display_get_n_screens( display);
Display *dp = gdk_x11_display_get_xdisplay( display);
int mode = GrabModeAsync;
int keycode = XKeysymToKeycode( dp, keysym);
if ( !keycode)
return 0;
gdk_error_trap_push();
for ( int i = 0; i < n_screens; i++) {
GdkWindow *root = gdk_screen_get_root_window( gdk_display_get_screen( display, i));
Window w = gdk_x11_drawable_get_xid( root);
XGrabKey( dp, keycode, modifier, w, True, mode, mode);
XGrabKey( dp, keycode, modifier | LockMask, w, True, mode, mode);
XGrabKey( dp, keycode, modifier | Mod2Mask, w, True, mode, mode);
XGrabKey( dp, keycode, modifier | LockMask | Mod2Mask, w, True, mode, mode);
}
gdk_flush();
gdk_error_trap_pop();
return 1;
}
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);
}
bool KeyboardDevice::doKeyAction(Action action, int nativeKey, bool alterPressedKeys)
{
bool result = true;
#ifdef Q_OS_UNIX
KeyCode keyCode = XKeysymToKeycode(QX11Info::display(), nativeKey);
if(action == Press || action == Trigger)
result &= XTestFakeKeyEvent(QX11Info::display(), keyCode, True, CurrentTime);
if(action == Release || action == Trigger)
result &= XTestFakeKeyEvent(QX11Info::display(), keyCode, False, CurrentTime);
XFlush(QX11Info::display());
#endif
#ifdef Q_OS_WIN
INPUT input;
SecureZeroMemory(&input, sizeof(INPUT));
input.type = INPUT_KEYBOARD;
switch(mType)
{
case Win32:
{
input.ki.wVk = nativeKey;
HKL keyboardLayout = GetKeyboardLayout(0);
input.ki.wScan = MapVirtualKeyEx(nativeKey, MAPVK_VK_TO_VSC, keyboardLayout);
if(extendedKeys.count(nativeKey) > 0)
input.ki.dwFlags |= KEYEVENTF_EXTENDEDKEY;
}
break;
case DirectX:
input.ki.wVk = 0;
input.ki.wScan = ActionTools::KeyMapper::toDirectXKey(nativeKey);
break;
}
if(action == Press || action == Trigger)
result &= (SendInput(1, &input, sizeof(INPUT)) != 0);
if(action == Release || action == Trigger)
{
input.ki.dwFlags |= KEYEVENTF_KEYUP;
result &= (SendInput(1, &input, sizeof(INPUT)) != 0);
}
#endif
if(alterPressedKeys)
{
if(action == Press)
mPressedKeys.insert(nativeKey);
else if(action == Release)
mPressedKeys.remove(nativeKey);
}
return result;
}
/* keyboard */
void keyboard_set_state (const char* key, int state)
{
Display* display = XOpenDisplay(NULL);
KeySym sym = XStringToKeysym(key);
KeyCode keycode = XKeysymToKeycode(display, sym);
XTestFakeKeyEvent(display, keycode, state, 0);
XCloseDisplay(display);
}
void grab_manual_action(void)
{
for (enum _hotkey_action action = 0; action < MAX_HOTKEYS; action++)
{
if (btable[action].key_sym == 0)
continue;
XGrabKey(main_window->display,
XKeysymToKeycode(main_window->display, btable[action].key_sym),
btable[action].modifier_mask,
DefaultRootWindow (main_window->display),
FALSE, GrabModeAsync, GrabModeAsync);
if (main_window->keymap->numlock_mask)
XGrabKey (main_window->display, XKeysymToKeycode(main_window->display, btable[action].key_sym),
btable[action].modifier_mask | main_window->keymap->numlock_mask,
DefaultRootWindow (main_window->display),
FALSE, GrabModeAsync, GrabModeAsync);
if (main_window->keymap->capslock_mask)
XGrabKey (main_window->display, XKeysymToKeycode(main_window->display, btable[action].key_sym),
btable[action].modifier_mask | main_window->keymap->capslock_mask,
DefaultRootWindow (main_window->display),
FALSE, GrabModeAsync, GrabModeAsync);
if (main_window->keymap->scrolllock_mask)
XGrabKey (main_window->display, XKeysymToKeycode(main_window->display, btable[action].key_sym),
btable[action].modifier_mask | main_window->keymap->scrolllock_mask,
DefaultRootWindow (main_window->display),
FALSE, GrabModeAsync, GrabModeAsync);
if (main_window->keymap->numlock_mask && main_window->keymap->capslock_mask)
XGrabKey (main_window->display, XKeysymToKeycode(main_window->display, btable[action].key_sym),
btable[action].modifier_mask | main_window->keymap->numlock_mask | main_window->keymap->capslock_mask,
DefaultRootWindow (main_window->display),
FALSE, GrabModeAsync, GrabModeAsync);
if (main_window->keymap->numlock_mask && main_window->keymap->scrolllock_mask)
XGrabKey (main_window->display, XKeysymToKeycode(main_window->display, btable[action].key_sym),
btable[action].modifier_mask | main_window->keymap->numlock_mask | main_window->keymap->scrolllock_mask,
DefaultRootWindow (main_window->display),
FALSE, GrabModeAsync, GrabModeAsync);
if (main_window->keymap->capslock_mask && main_window->keymap->scrolllock_mask)
XGrabKey (main_window->display, XKeysymToKeycode(main_window->display, btable[action].key_sym),
btable[action].modifier_mask | main_window->keymap->capslock_mask | main_window->keymap->scrolllock_mask,
DefaultRootWindow (main_window->display),
FALSE, GrabModeAsync, GrabModeAsync);
if (main_window->keymap->numlock_mask && main_window->keymap->capslock_mask && main_window->keymap->scrolllock_mask)
XGrabKey (main_window->display, XKeysymToKeycode(main_window->display, btable[action].key_sym),
btable[action].modifier_mask | main_window->keymap->numlock_mask | main_window->keymap->capslock_mask | main_window->keymap->scrolllock_mask,
DefaultRootWindow (main_window->display),
FALSE, GrabModeAsync, GrabModeAsync);
}
}
void GLInjectLauncher::UpdateHotkey(bool enabled, unsigned int keysym, unsigned int modifiers) {
GLInjectHeader *header = (GLInjectHeader*) m_shm_main_ptr;
std::atomic_thread_fence(std::memory_order_acquire);
header->hotkey_enabled = enabled;
header->hotkey_keycode = XKeysymToKeycode(QX11Info::display(), keysym);
header->hotkey_modifiers = modifiers;
std::atomic_thread_fence(std::memory_order_release);
}
void grab_user_action(void)
{
for (int action = 0; action < xconfig->actions_count; action++)
{
if (ubtable[action].key_sym == 0)
continue;
XGrabKey(main_window->display,
XKeysymToKeycode(main_window->display, ubtable[action].key_sym),
ubtable[action].modifier_mask,
DefaultRootWindow (main_window->display),
FALSE, GrabModeAsync, GrabModeAsync);
if (main_window->keymap->numlock_mask)
XGrabKey (main_window->display, XKeysymToKeycode(main_window->display, ubtable[action].key_sym),
ubtable[action].modifier_mask | main_window->keymap->numlock_mask,
DefaultRootWindow (main_window->display),
FALSE, GrabModeAsync, GrabModeAsync);
if (main_window->keymap->capslock_mask)
XGrabKey (main_window->display, XKeysymToKeycode(main_window->display, ubtable[action].key_sym),
ubtable[action].modifier_mask | main_window->keymap->capslock_mask,
DefaultRootWindow (main_window->display),
FALSE, GrabModeAsync, GrabModeAsync);
if (main_window->keymap->scrolllock_mask)
XGrabKey (main_window->display, XKeysymToKeycode(main_window->display, ubtable[action].key_sym),
ubtable[action].modifier_mask | main_window->keymap->scrolllock_mask,
DefaultRootWindow (main_window->display),
FALSE, GrabModeAsync, GrabModeAsync);
if (main_window->keymap->numlock_mask && main_window->keymap->capslock_mask)
XGrabKey (main_window->display, XKeysymToKeycode(main_window->display, ubtable[action].key_sym),
ubtable[action].modifier_mask | main_window->keymap->numlock_mask | main_window->keymap->capslock_mask,
DefaultRootWindow (main_window->display),
FALSE, GrabModeAsync, GrabModeAsync);
if (main_window->keymap->numlock_mask && main_window->keymap->scrolllock_mask)
XGrabKey (main_window->display, XKeysymToKeycode(main_window->display, ubtable[action].key_sym),
ubtable[action].modifier_mask | main_window->keymap->numlock_mask | main_window->keymap->scrolllock_mask,
DefaultRootWindow (main_window->display),
FALSE, GrabModeAsync, GrabModeAsync);
if (main_window->keymap->capslock_mask && main_window->keymap->scrolllock_mask)
XGrabKey (main_window->display, XKeysymToKeycode(main_window->display, ubtable[action].key_sym),
ubtable[action].modifier_mask | main_window->keymap->capslock_mask | main_window->keymap->scrolllock_mask,
DefaultRootWindow (main_window->display),
FALSE, GrabModeAsync, GrabModeAsync);
if (main_window->keymap->numlock_mask && main_window->keymap->capslock_mask && main_window->keymap->scrolllock_mask)
XGrabKey (main_window->display, XKeysymToKeycode(main_window->display, ubtable[action].key_sym),
ubtable[action].modifier_mask | main_window->keymap->numlock_mask | main_window->keymap->capslock_mask | main_window->keymap->scrolllock_mask,
DefaultRootWindow (main_window->display),
FALSE, GrabModeAsync, GrabModeAsync);
}
}
static void grabkey(struct WM_t *W, struct wmclient *C, KeySym sym, unsigned int mods)
{
KeyCode code = XKeysymToKeycode(W->XDisplay, sym);
XGrabKey(W->XDisplay, code, mods, C->win,
0, GrabModeAsync, GrabModeAsync);
XGrabKey(W->XDisplay, code, mods | LockMask, C->win,
0, GrabModeAsync, GrabModeAsync);
}
/*
* DoSendString - actually sends a string to the X Window having input focus
*
* The main task of this function is to convert the ascii char values
* into X KeyCodes. But they need to be converted to X KeySyms first
* and then to the keycodes. The KeyCodes can have any random values
* and are not contiguous like the ascii values are.
*
* Some escape sequences can be converted to the appropriate KeyCodes
* by this function. See the code below for details
*/
void CKeySendImpl::DoSendString(const StringX& str, unsigned delayMS, bool emulateMods)
{
atGlobals.error_detected = false;
atGlobals.errorString[0] = 0;
AutotypeEvent event(m_display);
// convert all the chars into keycodes and required shift states first
// Abort if any of the characters cannot be converted
typedef std::vector<KeyPressInfo> KeyPressInfoVector;
KeyPressInfoVector keypresses;
for (StringX::const_iterator srcIter = str.begin(); srcIter != str.end(); ++srcIter) {
//throw away 'vertical tab' chars which are only used on Windows to send a shift+tab
//as a workaround for some issues with IE
if (*srcIter == _T('\v'))
continue;
//Try a regular conversion first
KeySym sym = wchar2keysym(*srcIter);
if (NoSymbol != sym) {
KeyPressInfo keypress = {0, 0};
if ((keypress.code = XKeysymToKeycode(event.display, sym)) != 0) {
//non-zero return value implies sym -> code was successful
keypress.state |= CalcModifiersForKeysym(keypress.code, sym, event.display);
keypresses.push_back(keypress);
}
else {
const char* symStr = XKeysymToString(sym);
snprintf(atGlobals.errorString, NumberOf(atGlobals.errorString),
"Could not get keycode for key char(%s) - sym(%#X) - str(%s). Aborting autotype.\n\nIf \'xmodmap -pk\' does not list this KeySym, you probably need to install an appropriate keyboard layout.",
wchar2bytes(*srcIter).str(), static_cast<int>(sym), symStr ? symStr : "NULL");
atGlobals.error_detected = True;
return;
}
}
else {
snprintf(atGlobals.errorString, NumberOf(atGlobals.errorString),
"Cannot convert '%s' [U+%04X] to keysym. Aborting autotype", wchar2bytes(*srcIter).str(), int(*srcIter));
atGlobals.error_detected = True;
return;
}
}
m_method->EmulateMods(emulateMods);
for (KeyPressInfoVector::const_iterator itr = keypresses.begin(); itr != keypresses.end()
&& !atGlobals.error_detected; ++itr) {
event.keycode = itr->code;
event.state = itr->state;
event.time = CurrentTime;
(*m_method)(event);
pws_os::sleep_ms(delayMS);
}
}
bool wxUIActionSimulator::DoKey(int keycode, int modifiers, bool isDown)
{
wxX11Display display;
wxCHECK_MSG(display, false, "No display available!");
int mask, type;
if ( isDown )
{
type = KeyPress;
mask = KeyPressMask;
}
else
{
type = KeyRelease;
mask = KeyReleaseMask;
}
WXKeySym xkeysym = wxCharCodeWXToX(keycode);
KeyCode xkeycode = XKeysymToKeycode(display, xkeysym);
if ( xkeycode == NoSymbol )
return false;
Window focus;
int revert;
XGetInputFocus(display, &focus, &revert);
if (focus == None)
return false;
int mod = 0;
if (modifiers & wxMOD_SHIFT)
mod |= ShiftMask;
//Mod1 is alt in the vast majority of cases
if (modifiers & wxMOD_ALT)
mod |= Mod1Mask;
if (modifiers & wxMOD_CMD)
mod |= ControlMask;
XKeyEvent event;
event.display = display;
event.window = focus;
event.root = DefaultRootWindow(event.display);
event.subwindow = None;
event.time = CurrentTime;
event.x = 1;
event.y = 1;
event.x_root = 1;
event.y_root = 1;
event.same_screen = True;
event.type = type;
event.state = mod;
event.keycode = xkeycode;
XSendEvent(event.display, event.window, True, mask, (XEvent*) &event);
return true;
}
bool GetXlibKeyState(int key)
{
if(CurrentXDisplay == NULL)
return false;
KeySym ks = 0;
if(key >= eRENDERDOC_Key_A && key <= eRENDERDOC_Key_Z)
ks = key;
if(key >= eRENDERDOC_Key_0 && key <= eRENDERDOC_Key_9)
ks = key;
switch(key)
{
case eRENDERDOC_Key_Divide: ks = XK_KP_Divide; break;
case eRENDERDOC_Key_Multiply: ks = XK_KP_Multiply; break;
case eRENDERDOC_Key_Subtract: ks = XK_KP_Subtract; break;
case eRENDERDOC_Key_Plus: ks = XK_KP_Add; break;
case eRENDERDOC_Key_F1: ks = XK_F1; break;
case eRENDERDOC_Key_F2: ks = XK_F2; break;
case eRENDERDOC_Key_F3: ks = XK_F3; break;
case eRENDERDOC_Key_F4: ks = XK_F4; break;
case eRENDERDOC_Key_F5: ks = XK_F5; break;
case eRENDERDOC_Key_F6: ks = XK_F6; break;
case eRENDERDOC_Key_F7: ks = XK_F7; break;
case eRENDERDOC_Key_F8: ks = XK_F8; break;
case eRENDERDOC_Key_F9: ks = XK_F9; break;
case eRENDERDOC_Key_F10: ks = XK_F10; break;
case eRENDERDOC_Key_F11: ks = XK_F11; break;
case eRENDERDOC_Key_F12: ks = XK_F12; break;
case eRENDERDOC_Key_Home: ks = XK_Home; break;
case eRENDERDOC_Key_End: ks = XK_End; break;
case eRENDERDOC_Key_Insert: ks = XK_Insert; break;
case eRENDERDOC_Key_Delete: ks = XK_Delete; break;
case eRENDERDOC_Key_PageUp: ks = XK_Prior; break;
case eRENDERDOC_Key_PageDn: ks = XK_Next; break;
case eRENDERDOC_Key_Backspace: ks = XK_BackSpace; break;
case eRENDERDOC_Key_Tab: ks = XK_Tab; break;
case eRENDERDOC_Key_PrtScrn: ks = XK_Print; break;
case eRENDERDOC_Key_Pause: ks = XK_Pause; break;
default: break;
}
if(ks == 0)
return false;
KeyCode kc = XKeysymToKeycode(CurrentXDisplay, ks);
char keyState[32];
XQueryKeymap(CurrentXDisplay, keyState);
int byteIdx = (kc / 8);
int bitMask = 1 << (kc % 8);
uint8_t keyByte = (uint8_t)keyState[byteIdx];
return (keyByte & bitMask) != 0;
}
void send_fake_key_eve2(KeySym key, gboolean press)
{
#if WIN32
win32_FakeKey(key, press);
#else
KeyCode kc = XKeysymToKeycode(dpy, key);
XTestFakeKeyEvent(dpy, kc, press, CurrentTime);
#endif
}
void send(char c, int delay=0){
bool need_shift=false;
KeyCode kc = char2KeyCode(c, need_shift);
if(kc==0) return;
printf("DEBUG: send kc = %d\n",kc);
if(!shift && need_shift){
XTestFakeKeyEvent(display, XKeysymToKeycode(display, XK_Shift_L), True, CurrentTime); // is_press
}
XTestFakeKeyEvent(display, kc, True, 30); // is_press
XFlush(display);
XTestFakeKeyEvent(display, kc, False, 30); // KeyUp
XFlush(display);
if(!shift && need_shift){
XTestFakeKeyEvent(display, XKeysymToKeycode(display, XK_Shift_L), False, CurrentTime); // is_press
}
XFlush(display);
if(delay>0) usleep(delay*1000); // unit: ms
}
void x_grab_key_init()
{
x_disp = XOpenDisplay (NULL);
x_screen = DefaultScreen (x_disp);
x_root = RootWindow (x_disp, x_screen);
key_code = XKeysymToKeycode(x_disp , XK_Meta_R);
XSelectInput(x_disp , x_root , KeyReleaseMask);
XGrabKey(x_disp , key_code , AnyModifier , x_root, 1 , GrabModeAsync,GrabModeAsync );
}
static KeyCode keyToKeycode(const char *key)
{
KeySym keySym = XStringToKeysym(key);
if(keySym == NoSymbol)
return keyToKeycode("space");
return XKeysymToKeycode(QX11Info::display(), keySym);
}
void CKeySendImpl::SelectAll(unsigned delayMS)
{
AutotypeEvent event(m_display);
event.keycode = XKeysymToKeycode(event.display, XK_a);
event.state = ControlMask;
event.time = CurrentTime;
(*m_method)(event);
pws_os::sleep_ms(delayMS);
}
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);
}
static GdkFilterReturn
filter_mmkeys(GdkXEvent *xevent,
GdkEvent *event,
gpointer data)
{
XEvent *xev;
XKeyEvent *key;
Display *display;
XmrWindow *window;
GdkFilterReturn retv = GDK_FILTER_CONTINUE;
xev = (XEvent *)xevent;
if (xev->type != KeyPress)
return GDK_FILTER_CONTINUE;
key = (XKeyEvent *)xevent;
window = (XmrWindow *)data;
display = GDK_DISPLAY_XDISPLAY(gdk_display_get_default());
if (XKeysymToKeycode(display, XF86XK_AudioPlay) == key->keycode ||
XKeysymToKeycode(display, XF86XK_AudioPause) == key->keycode)
{
if (xmr_window_playing(window))
xmr_window_pause(window);
else
xmr_window_play(window);
retv = GDK_FILTER_REMOVE;
}
else if (XKeysymToKeycode (display, XF86XK_AudioStop) == key->keycode)
{
xmr_window_pause(window);
retv = GDK_FILTER_REMOVE;
}
else if (XKeysymToKeycode (display, XF86XK_AudioNext) == key->keycode)
{
xmr_window_play_next(window);
retv = GDK_FILTER_REMOVE;
}
return retv;
}
int main(int argc, const char **argv) {
if (!(dpy=XOpenDisplay(0x0))) return 1;
scr = DefaultScreen(dpy);
root = RootWindow(dpy,scr);
sw = DisplayWidth(dpy,scr);
sh = DisplayHeight(dpy,scr);
if (argc > 1) {
if (argv[1][0] == '-' && argv[1][1] == 'h')
printf("IOCANE: Copyright 2012, Jesse McClure\nSee `man iocane` for commands and examples.\n");
if (argv[1][0] == '-' && argv[1][1] == '\0')
stdinmode(argc,argv);
else scriptmode(argc,argv);
XCloseDisplay(dpy);
return 0;
}
/* no args -> interactive mode: */
Key *keys = NULL;
char *line = (char *) calloc(MAXLINE+MAXSYMLEN+2,sizeof(char));
char keystring[MAXSYMLEN];
KeySym keysym;
chdir(getenv("HOME"));
FILE *rcfile = fopen(".iocanerc","r");
if (rcfile == NULL) fopen("/usr/share/iocane/iocanerc","r");
if (rcfile == NULL) {
fprintf(stderr,"IOCANE: no iocanerc file found.\n");
XCloseDisplay(dpy);
return 0;
}
int i = 0;
while (fgets(line,MAXLINE+MAXSYMLEN+2,rcfile) != NULL) {
if (line[0] == '#' || line[0] == '\n') continue;
strncpy(keystring,line,MAXSYMLEN); *strchr(keystring,' ') = '\0';
if ( (keysym=XStringToKeysym(keystring)) == NoSymbol ) continue;
keys = realloc(keys,(i+1) * sizeof(Key));
keys[i].key = XKeysymToKeycode(dpy,keysym);
keys[i].command = (char *) calloc(strlen(line) - strlen(keystring),sizeof(char));
strcpy(keys[i].command,strchr(line,' ')+1);
XGrabKey(dpy,keys[i].key,0,root,True,GrabModeAsync,GrabModeAsync);
XGrabKey(dpy,keys[i++].key,LockMask,root,True,GrabModeAsync,GrabModeAsync);
}
int keycount = i;
free(line);
fclose(rcfile);
XEvent ev;
XKeyEvent *e;
while (running && !XNextEvent(dpy,&ev)) if (ev.type == KeyPress) {
e = &ev.xkey;
for (i = 0; i < keycount; i++)
if (e->keycode == keys[i].key && keys[i].command)
command(keys[i].command);
}
for (i = 0; i < keycount; i++) free(keys[i].command);
free(keys);
XCloseDisplay(dpy);
return 0;
}
static bool x_key_pressed(x11_input_t *x11, int key)
{
if (key >= RETROK_LAST)
return false;
unsigned sym = input_translate_rk_to_keysym((enum retro_key)key);
int keycode = XKeysymToKeycode(x11->display, sym);
bool ret = x11->state[keycode >> 3] & (1 << (keycode & 7));
return ret;
}
Bool is_key_pressed(Display *display, KeySym sym) {
// determine if the key "sym" is pressed or not
// this routine from "Introduction to the X Window System", 1989, p. 388
KeyCode code = XKeysymToKeycode(display, sym);
if (code == NoSymbol) return false;
char key_vector[32];
XQueryKeymap(display, key_vector);
return (key_vector[code/8] >> (code&7)) & 1;
}
void click_key(KeySym keysym)
{
KeyCode keycode = XKeysymToKeycode(main_window->display, keysym);
XTestFakeKeyEvent(main_window->display, keycode, TRUE, 0); // key press event
XTestFakeKeyEvent(main_window->display, keycode ,FALSE, 0); // key release event
XFlush(main_window->display);
return;
}
void X11Util::unregisterHotkey(int keycode)
{
Display* display = QX11Info::display();
Window root = DefaultRootWindow(display);
int modifiers = ControlMask | Mod1Mask;
int key = XKeysymToKeycode(display, keycode);
XUngrabKey(display, key, modifiers, root);
//printf("unregister Hotkey\n");
}
//Sends all words in the dictionary that can be formed by the given set of letters, then switches to the next
//set of letters.
void loop_through_dictionary( char* letters ) {
int x;
for( x = 0; x < NUM_WORDS; x++ ) {
if( composed_of( dictionary[x], letters ) && strlen( dictionary[x]) < 6 ) {
send_word( dictionary[x] );
}
}
sleep( 1 );
send_key( XKeysymToKeycode( display, XK_Control_L ) , 1);
}
unsigned int X11Extras::getGroup1KeySym(unsigned int virtualkey)
{
unsigned int result = 0;
Display *display = this->display();
unsigned int temp = XKeysymToKeycode(display, virtualkey);
result = XkbKeycodeToKeysym(display, temp, 0, 0);
return result;
}
