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