void x11_shadow_input_keyboard_event(x11ShadowSubsystem* subsystem, UINT16 flags, UINT16 code) { #ifdef WITH_XTEST DWORD vkcode; DWORD keycode; BOOL extended = FALSE; if (flags & KBD_FLAGS_EXTENDED) extended = TRUE; if (extended) code |= KBDEXT; vkcode = GetVirtualKeyCodeFromVirtualScanCode(code, 4); if (extended) vkcode |= KBDEXT; keycode = GetKeycodeFromVirtualKeyCode(vkcode, KEYCODE_TYPE_EVDEV); if (keycode != 0) { XTestGrabControl(subsystem->display, True); if (flags & KBD_FLAGS_DOWN) XTestFakeKeyEvent(subsystem->display, keycode, True, CurrentTime); else if (flags & KBD_FLAGS_RELEASE) XTestFakeKeyEvent(subsystem->display, keycode, False, CurrentTime); XTestGrabControl(subsystem->display, False); XFlush(subsystem->display); } #endif }
//actually creates an XWindows event :) void sendevent(const FakeEvent &e) { Display* display = QX11Info::display(); switch (e.type) { case FakeEvent::MouseMove: if (e.move.x == 0 && e.move.y == 0) return; XTestFakeRelativeMotionEvent(display, e.move.x, e.move.y, 0); break; case FakeEvent::KeyUp: if (e.keycode == 0) return; XTestFakeKeyEvent(display, e.keycode, false, 0); break; case FakeEvent::KeyDown: if (e.keycode == 0) return; XTestFakeKeyEvent(display, e.keycode, true, 0); break; case FakeEvent::MouseUp: if (e.keycode == 0) return; XTestFakeButtonEvent(display, e.keycode, false, 0); break; case FakeEvent::MouseDown: if (e.keycode == 0) return; XTestFakeButtonEvent(display, e.keycode, true, 0); break; } XFlush(display); }
static pa_hook_result_t sink_input_send_event_hook_cb( pa_core *c, pa_sink_input_send_event_hook_data *data, struct userdata *u) { KeySym sym; KeyCode code; Display *display; pa_assert(c); pa_assert(data); pa_assert(u); if (pa_streq(data->event, PA_STREAM_EVENT_REQUEST_CORK)) sym = XF86XK_AudioPause; else if (pa_streq(data->event, PA_STREAM_EVENT_REQUEST_UNCORK)) sym = XF86XK_AudioPlay; else return PA_HOOK_OK; pa_log_debug("Triggering X11 keysym: %s", XKeysymToString(sym)); display = pa_x11_wrapper_get_display(u->x11_wrapper); code = XKeysymToKeycode(display, sym); XTestFakeKeyEvent(display, code, True, CurrentTime); XSync(display, False); XTestFakeKeyEvent(display, code, False, CurrentTime); XSync(display, False); return PA_HOOK_OK; }
gboolean cairo_dock_simulate_key_sequence (gchar *cKeyString) // the idea was taken from xdo. { #ifdef HAVE_XEXTEND g_return_val_if_fail (cKeyString != NULL, FALSE); cd_message ("%s (%s)", __func__, cKeyString); int iNbKeys = 0; int *pKeySyms = egg_keystring_to_keysyms (cKeyString, &iNbKeys); int i; int keycode; Display *dpy = cairo_dock_get_Xdisplay (); for (i = 0; i < iNbKeys; i ++) { keycode = XKeysymToKeycode (dpy, pKeySyms[i]); XTestFakeKeyEvent (dpy, keycode, TRUE, CurrentTime); // TRUE <=> presse. } for (i = iNbKeys-1; i >=0; i --) { keycode = XKeysymToKeycode (dpy, pKeySyms[i]); XTestFakeKeyEvent (dpy, keycode, FALSE, CurrentTime); // TRUE <=> presse. } XFlush (dpy); return TRUE; #else return FALSE; #endif }
/* Send Fake Key Event */ static void SendKey (Display * disp, KeySym keysym, KeySym modsym) { KeyCode keycode = 0, modcode = 0; keycode = XKeysymToKeycode (disp, keysym); if (keycode == 0) return; XTestGrabControl (disp, True); /* Generate modkey press */ if (modsym != 0) { modcode = XKeysymToKeycode(disp, modsym); XTestFakeKeyEvent (disp, modcode, True, 0); } /* Generate regular key press and release */ XTestFakeKeyEvent (disp, keycode, True, 0); XTestFakeKeyEvent (disp, keycode, False, 0); /* Generate modkey release */ if (modsym != 0) XTestFakeKeyEvent (disp, modcode, False, 0); XSync (disp, False); XTestGrabControl (disp, False); }
void sendkey(void *s,int press_and_release,int toggled){ symbol_x11 *sym=(symbol_x11 *)s; KeyCode modifier; KeySym modifier_sym; assert(dpy); kbio.lastsent=sym->keycode; ungrabkeys(); XFlush(dpy); uk_log("send keysym 0x%x keycode %i %s modifier=%i", (unsigned int)sym->ks, (int)sym->keycode, XKeysymToString(sym->ks), sym->modifier); XTestFakeKeyEvent(dpy,sym->keycode,1,CurrentTime); XFlush(dpy); XTestFakeKeyEvent(dpy,sym->keycode,0,CurrentTime+100); XFlush(dpy); XFlush(dpy); grabkeys(); }
void xf_input_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code) { #ifdef WITH_XTEST DWORD vkcode; DWORD keycode; BOOL extended = FALSE; xfPeerContext* xfp = (xfPeerContext*) input->context; xfInfo* xfi = xfp->info; if (flags & KBD_FLAGS_EXTENDED) extended = TRUE; if (extended) code |= KBDEXT; vkcode = GetVirtualKeyCodeFromVirtualScanCode(code, 4); keycode = GetKeycodeFromVirtualKeyCode(vkcode, KEYCODE_TYPE_EVDEV); if (keycode != 0) { XTestGrabControl(xfi->display, True); if (flags & KBD_FLAGS_DOWN) XTestFakeKeyEvent(xfi->display, keycode, True, 0); else if (flags & KBD_FLAGS_RELEASE) XTestFakeKeyEvent(xfi->display, keycode, False, 0); XTestGrabControl(xfi->display, False); } #endif }
void xf_input_keyboard_event(rdpInput* input, uint16 flags, uint16 code) { #ifdef WITH_XTEST unsigned int keycode; boolean extended = false; xfPeerContext* xfp = (xfPeerContext*) input->context; xfInfo* xfi = xfp->info; if (flags & KBD_FLAGS_EXTENDED) extended = true; keycode = freerdp_keyboard_get_x11_keycode_from_rdp_scancode(code, extended); if (keycode != 0) { pthread_mutex_lock(&(xfp->mutex)); XTestGrabControl(xfi->display, True); if (flags & KBD_FLAGS_DOWN) XTestFakeKeyEvent(xfi->display, keycode, True, 0); else if (flags & KBD_FLAGS_RELEASE) XTestFakeKeyEvent(xfi->display, keycode, False, 0); XTestGrabControl(xfi->display, False); pthread_mutex_unlock(&(xfp->mutex)); } #endif }
int main(int argc, char *argv[]) { int i; if (argc <= 1) { fprintf(stderr, "usage: fake-key key1 key2 key3 ...\n"); return 1; } Display *dpy = XOpenDisplay(NULL); if (!dpy) return 1; for (i = 1; i < argc; ++i) XTestFakeKeyEvent(dpy, atoi(argv[i]), True, CurrentTime); for (i = argc - 1; i > 0; --i) XTestFakeKeyEvent(dpy, atoi(argv[i]), False, CurrentTime); XSync(dpy, False); XCloseDisplay(dpy); return 0; }
static int send_key_event (GdkWindow *gdkwindow, guint keysym, guint keycode, guint state) { Display *display; KeyCode keycode_real; display = GDK_WINDOW_XDISPLAY (gdkwindow); if (state != 0) { xsend_key_state (display, state, True); } if (keycode != 0) { keycode_real = (KeyCode) keycode; } else { keycode_real = XKeysymToKeycode (display, (KeySym) keysym); } XTestFakeKeyEvent (display, keycode_real, True, CurrentTime); XSync (display, False); XTestFakeKeyEvent (display, keycode_real, False, CurrentTime); XSync (display, False); if (state != 0) { xsend_key_state (display, state, False); } return TRUE; }
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 }
/* * 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; }
TEST_F(CXWindowsKeyStateTests, pollActiveModifiers_shiftKeyDownThenUp_masksAreCorrect) { CMockKeyMap keyMap; CMockEventQueue eventQueue; CXWindowsKeyState keyState( m_display, true, (IEventQueue&)keyMap, (CKeyMap&)eventQueue); // set mock modifier mapping std::fill( keyState.m_modifierFromX.begin(), keyState.m_modifierFromX.end(), 0); keyState.m_modifierFromX[ShiftMapIndex] = KeyModifierShift; KeyCode key = XKeysymToKeycode(m_display, XK_Shift_L); // fake shift key down (without using synergy) XTestFakeKeyEvent(m_display, key, true, CurrentTime); // function under test (1st call) KeyModifierMask modDown = keyState.pollActiveModifiers(); // fake shift key up (without using synergy) XTestFakeKeyEvent(m_display, key, false, CurrentTime); // function under test (2nd call) KeyModifierMask modUp = keyState.pollActiveModifiers(); EXPECT_TRUE((modDown & KeyModifierShift) == KeyModifierShift) << "shift key not in mask - key was not pressed"; EXPECT_TRUE((modUp & KeyModifierShift) == 0) << "shift key still in mask - make sure no keys are being held down"; }
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; }
int KeyEvent (const char* const keyname) { Display * display = NULL; Window window = 0; int revert_to_ret = 0; XKeyEvent event; Status status; display = XOpenDisplay(NULL); /* localhost:0.0 */ if (display == NULL) { fprintf(stderr, "Could not open display: localhost:0.0\n"); return 1; } /** * Target window is the window currently focused. */ XGetInputFocus(display, &window, &revert_to_ret); if (window == 0) { fprintf(stderr, "Could not detect the window which has gotten input focus.\n"); return 1; } event.display = display; event.window = window; event.root = RootWindow(display, DefaultScreen(display)); event.subwindow = None; event.time = CurrentTime; event.x = event.y = 1; event.x_root = event.y_root = 1; event.same_screen = 1; event.state = ShiftMask; event.keycode = XStringToToKeycode(display, keyname); /* event.state = modifiers; */ event.type = KeyPress; // status = XSendEvent(display, window, 1, KeyPressMask, (XEvent *)&event); status = XTestFakeKeyEvent(display, event.keycode, True, 0); if (status == 0) { fprintf(stderr, "Failed to send evnet: type=KeyPress\n"); return 1; /* error */ } // event.type = KeyRelease; // status = XSendEvent(display, window, 1, KeyReleaseMask, (XEvent *)&event); status = XTestFakeKeyEvent(display, event.keycode, False, 0); XSync(display, 1); XCloseDisplay(display); return status; }
static inline void set_output(int output) { XTestFakeKeyEvent(disp, mod, 1, 0); XTestFakeKeyEvent(disp, key[output], 1, 0); XTestFakeKeyEvent(disp, key[output], 0, 0); XTestFakeKeyEvent(disp, mod, 0, 0); XFlush(disp); }
static bool sendKey(const char *key) { bool result = true; result &= XTestFakeKeyEvent(QX11Info::display(), keyToKeycode(key), True, CurrentTime); result &= XTestFakeKeyEvent(QX11Info::display(), keyToKeycode(key), False, CurrentTime); return result; }
int main() { Display *xdpy; Window root; char *display_name = NULL; int ver; if ( (display_name = getenv("DISPLAY")) == (void *)NULL) { fprintf(stderr, "Error: DISPLAY environment variable not set\n"); exit(1); } printf("Display: %s\n", display_name); if ( (xdpy = XOpenDisplay(display_name)) == NULL) { fprintf(stderr, "Error: Can't open display: %s", display_name); exit(1); } if (XTestQueryExtension(xdpy, &ver, &ver, &ver, &ver) != True) { printf("No xtest :(\n"); return 1; } { int control, alt, key_l, key_two, del; control = XKeysymToKeycode(xdpy, XStringToKeysym("Control_L")); alt = XKeysymToKeycode(xdpy, XStringToKeysym("Alt_L")); key_l = XKeysymToKeycode(xdpy, XStringToKeysym("L")); key_two = XKeysymToKeycode(xdpy, XStringToKeysym("2")); del = XKeysymToKeycode(xdpy, XStringToKeysym("BackSpace")); printf("%d %d %d %d\n", control, alt, key_l, key_two); return; XTestFakeKeyEvent(xdpy, alt, True, CurrentTime); XTestFakeKeyEvent(xdpy, key_two, True, CurrentTime); XTestFakeKeyEvent(xdpy, key_two, False, CurrentTime); XTestFakeKeyEvent(xdpy, alt, False, CurrentTime); XTestFakeKeyEvent(xdpy, control, True, 100); XTestFakeKeyEvent(xdpy, key_l, True, CurrentTime); XTestFakeKeyEvent(xdpy, key_l, False, CurrentTime); XTestFakeKeyEvent(xdpy, control, False, CurrentTime); XTestFakeMotionEvent(xdpy, 0, 50, 55, CurrentTime); //XTestFakeButtonEvent(xdpy, 1, True, CurrentTime); //XTestFakeButtonEvent(xdpy, 1, False, CurrentTime); XTestFakeKeyEvent(xdpy, del, True, 50); XTestFakeKeyEvent(xdpy, del, False, CurrentTime); XTestFakeButtonEvent(xdpy, 2, True, CurrentTime); XTestFakeButtonEvent(xdpy, 2, False, CurrentTime); XFlush(xdpy); } return 0; }
JS_EXPORT_API void guide_simulate_input(double input) { Display* dpy = GDK_DISPLAY_XDISPLAY(gdk_display_get_default()); KeyCode keycode = XKeysymToKeycode(dpy,(int)input); guide_enable_keyboard(); XTestFakeKeyEvent(dpy, keycode, TRUE, 0); XTestFakeKeyEvent(dpy, keycode, FALSE, 0); guide_disable_keyboard(); }
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 keys_up() { XTestFakeKeyEvent (display, keys_pressed[0], False, 0); keys_pressed[0] = 0; if(keys_pressed[1] != 0) { XTestFakeKeyEvent (display, keys_pressed[1], False, 0); keys_pressed[1] = 0; } XSync(display, False); }
void KNotificationRestrictions::Private::screensaverFakeKeyEvent() { kDebug(297); #ifdef HAVE_XTEST kDebug(297) << "---- using XTestFakeKeyEvent"; Display* display = QX11Info::display(); XTestFakeKeyEvent(display, XTestKeyCode, true, CurrentTime); XTestFakeKeyEvent(display, XTestKeyCode, false, CurrentTime); XSync(display, false); #endif // HAVE_XTEST }
void send_fake_key_eve(KeySym key) { #if WIN32 win32_FakeKey(key, true); win32_FakeKey(key, false); #else KeyCode kc = XKeysymToKeycode(dpy, key); XTestFakeKeyEvent(dpy, kc, True, CurrentTime); XTestFakeKeyEvent(dpy, kc, False, CurrentTime); #endif }
void sendChar(char c) { KeySym ks, sks, *kss, ksl, ksu; KeyCode kc, skc; int Delay = 10; int syms; #ifdef DEBUG int i; #endif sks=XK_Shift_L; ks=XStringToKeysym(chartbl[0][(unsigned char)c]); if ( ( kc = XKeysymToKeycode ( RemoteDpy, ks ) ) == 0 ) { std::cerr << "No keycode on remote display found for char: " << c << std::endl; return; } if ( ( skc = XKeysymToKeycode ( RemoteDpy, sks ) ) == 0 ) { std::cerr << "No keycode on remote display found for XK_Shift_L!" << std::endl; return; } kss=XGetKeyboardMapping(RemoteDpy, kc, 1, &syms); if (!kss) { std::cerr << "XGetKeyboardMapping failed on the remote display (keycode: " << kc << ")" << std::endl; return; } for (; syms && (!kss[syms-1]); syms--); if (!syms) { std::cerr << "XGetKeyboardMapping failed on the remote display (no syms) (keycode: " << kc << ")" << std::endl; XFree(kss); return; } XConvertCase(ks,&ksl,&ksu); #ifdef DEBUG std::cout << "kss: "; for (i=0; i<syms; i++) std::cout << kss[i] << " "; std::cout << "(" << ks << " l: " << ksl << " h: " << ksu << ")" << std::endl; #endif if (ks==kss[0] && (ks==ksl && ks==ksu)) sks=NoSymbol; if (ks==ksl && ks!=ksu) sks=NoSymbol; if (sks!=NoSymbol) XTestFakeKeyEvent ( RemoteDpy, skc, True, Delay ); XTestFakeKeyEvent ( RemoteDpy, kc, True, Delay ); XFlush ( RemoteDpy ); XTestFakeKeyEvent ( RemoteDpy, kc, False, Delay ); if (sks!=NoSymbol) XTestFakeKeyEvent ( RemoteDpy, skc, False, Delay ); XFlush ( RemoteDpy ); XFree(kss); }
static inline void post_key_event(uiohook_event * const event) { #ifdef USE_XTEST // FIXME Currently ignoring EVENT_KEY_TYPED. if (event->type == EVENT_KEY_PRESSED) { XTestFakeKeyEvent( properties_disp, scancode_to_keycode(event->data.keyboard.keycode), True, 0); } else if (event->type == EVENT_KEY_RELEASED) { XTestFakeKeyEvent( properties_disp, scancode_to_keycode(event->data.keyboard.keycode), False, 0); } #else XKeyEvent key_event; key_event.serial = 0x00; key_event.send_event = False; key_event.display = properties_disp; key_event.time = CurrentTime; key_event.same_screen = True; unsigned int mask; if (!XQueryPointer(properties_disp, DefaultRootWindow(properties_disp), &(key_event.root), &(key_event.subwindow), &(key_event.x_root), &(key_event.y_root), &(key_event.x), &(key_event.y), &mask)) { key_event.root = DefaultRootWindow(properties_disp); key_event.window = key_event.root; key_event.subwindow = None; key_event.x_root = 0; key_event.y_root = 0; key_event.x = 0; key_event.y = 0; } key_event.state = convert_to_native_mask(event->mask); key_event.keycode = XKeysymToKeycode(properties_disp, scancode_to_keycode(event->data.keyboard.keycode)); // FIXME Currently ignoring typed events. if (event->type == EVENT_KEY_PRESSED) { key_event.type = KeyPress; XSendEvent(properties_disp, InputFocus, False, KeyPressMask, (XEvent *) &key_event); } else if (event->type == EVENT_KEY_RELEASED) { key_event.type = KeyRelease; XSendEvent(properties_disp, InputFocus, False, KeyReleaseMask, (XEvent *) &key_event); } #endif }
/* SaveFile: This function sends key commands to the FireFox save file dialog. Input: dsp: The current XWindows Display. win: The window to send the key commands to. Output: returns 0 on success and -1 on failure. */ int SaveFile(Display *dsp, Window win) { int err = 0; Window parent; Window root; Window *kids; int count; KeyCode keycode_return = XKeysymToKeycode(dsp, XK_Return); KeyCode keycode_tab = XKeysymToKeycode(dsp, XK_Tab); XRaiseWindow(dsp, win); XFlush(dsp); XSetInputFocus(dsp, win, RevertToNone, CurrentTime); XFlush(dsp); XTestGrabControl(dsp, True); printf("Sending Tab key\n"); XTestFakeKeyEvent(dsp, keycode_tab, True, 0); XFlush(dsp); XTestFakeKeyEvent(dsp, keycode_tab, False, 0); XFlush(dsp); sleep(1); printf("Finished.\n"); printf("Sending Tab key\n"); XTestFakeKeyEvent(dsp, keycode_tab, True, 0); XTestFakeKeyEvent(dsp, keycode_tab, False, 0); XFlush(dsp); sleep(1); printf("Finished.\n"); printf("Sending Tab key\n"); XTestFakeKeyEvent(dsp, keycode_tab, True, 0); XTestFakeKeyEvent(dsp, keycode_tab, False, 0); XFlush(dsp); sleep(1); printf("Finished.\n"); printf("Sending Tab key\n"); XTestFakeKeyEvent(dsp, keycode_tab, True, 0); XTestFakeKeyEvent(dsp, keycode_tab, False, 0); XFlush(dsp); sleep(1); printf("Finished.\n"); printf("Sending Tab Return\n"); XTestFakeKeyEvent(dsp, keycode_return, True, 0); XTestFakeKeyEvent(dsp, keycode_return, False, 0); XFlush(dsp); printf("Finished\n"); return err; }
bool XRSERVER::processKbdEvent(XRNETKBDEVENT *event) { switch (event->type) { case XREVENT_KBD_DOWN: XTestFakeKeyEvent(this->display, event->keycode, True, CurrentTime); break; case XREVENT_KBD_UP: XTestFakeKeyEvent(this->display, event->keycode, False, CurrentTime); break; } this->flush(); return true; }
/* * Event: Key Type * Input: QString key */ int Event::keyboardType(QString key) { if(virtual_key_code[key].isValid()){ //key type Keycode keycode = XKeysymToKeycode(display, virtual_key_code[key].toInt()); XTestFakeKeyEvent (display, keycode, True, 0); XTestFakeKeyEvent (display, keycode, False, 0); XSync(display, False); return 0; }else{ return INPUT_ERROR; } }
/* void KeyDownUp (in long keysym); */ NS_IMETHODIMP MainComponent::KeyDownUp(PRInt32 keysym) { KeyCode keycode; long is_shift; GetKeys(keycode, is_shift, keysym); if(is_shift) XTestFakeKeyEvent(display, KEY_SHIFT, True, 0); XTestFakeKeyEvent(display, keycode, True, 0); XTestFakeKeyEvent(display, keycode, False, 0); if(is_shift) XTestFakeKeyEvent(display, KEY_SHIFT, False, 0); XSync(display,0); return NS_OK; }
void PressKeyVK(int key, _XDisplay *dpy = NULL) { bool local = false; if (!dpy) { if (!(dpy = XOpenDisplay(NULL))) return; local = true; } XTestFakeKeyEvent(dpy, XKeysymToKeycode(dpy, key), True, CurrentTime); XTestFakeKeyEvent(dpy, XKeysymToKeycode(dpy, key), False, CurrentTime); if (local) { XFlush(dpy); XCloseDisplay(dpy); } }