const Result ctrlr_sendKeyPressEvent (const KeyPress &keyPress)
{
Display *display = XOpenDisplay(0);
if(display == NULL)
return (Result::fail("Can't open display"));
Window winRoot = XDefaultRootWindow(display);
Window winFocus;
int revert;
if (!XGetInputFocus(display, &winFocus, &revert))
{
return (Result::fail("XGetInputFocus failed"));
}
XKeyEvent event = createKeyEvent(display, winFocus, winRoot, true, keyPress.getKeyCode(), keyPress.getModifiers().getRawFlags());
if (XSendEvent(event.display, event.window, True, KeyPressMask, (XEvent *)&event) == 0)
{
return (Result::fail("XSendEvent failed"));
}
event = createKeyEvent(display, winFocus, winRoot, false, keyPress.getKeyCode(), keyPress.getModifiers().getRawFlags());
if (XSendEvent(event.display, event.window, True, KeyPressMask, (XEvent *)&event) == 0)
{
return (Result::fail("XSendEvent failed"));
}
XCloseDisplay(display);
return (Result::ok());
}
int cheese(int keyPress)
{
// Obtain the X11 display.
Display *display = XOpenDisplay(0);
if(display == NULL)
return -1;
// Get the root window for the current display.
Window winRoot = XDefaultRootWindow(display);
// Find the window which has the current keyboard focus.
Window winFocus;
int revert;
XGetInputFocus(display, &winFocus, &revert);
// Send a fake key press event to the window.
XKeyEvent event = createKeyEvent(display, winFocus, winRoot, true, keyPress, 0);
XSendEvent(event.display, event.window, True, KeyPressMask, (XEvent *)&event);
// Send a fake key release event to the window.
event = createKeyEvent(display, winFocus, winRoot, false, keyPress, 0);
XSendEvent(event.display, event.window, True, KeyPressMask, (XEvent *)&event);
// Done.
XCloseDisplay(display);
return 0;
}
void InputReader::keyChanged(int key, bool down)
{
if (down)
{
switch (key) {
case KC_LMENU :
case KC_RMENU :
mModifiers |= InputEvent::ALT_MASK;
break;
case KC_LSHIFT :
case KC_RSHIFT :
mModifiers |= InputEvent::SHIFT_MASK;
break;
case KC_LCONTROL :
case KC_RCONTROL :
mModifiers |= InputEvent::CTRL_MASK;
break;
}
createKeyEvent(KeyEvent::KE_KEY_PRESSED, key);
// Update keydown map
mBufferedKeysDown.insert(static_cast<KeyCode>(key));
}
else
{
switch (key) {
case KC_LMENU :
case KC_RMENU :
mModifiers &= ~InputEvent::ALT_MASK;
break;
case KC_LSHIFT :
case KC_RSHIFT :
mModifiers &= ~InputEvent::SHIFT_MASK;
break;
case KC_LCONTROL :
case KC_RCONTROL :
mModifiers &= ~InputEvent::CTRL_MASK;
break;
}
createKeyEvent(KeyEvent::KE_KEY_RELEASED, key);
createKeyEvent(KeyEvent::KE_KEY_CLICKED, key);
// Update keydown map
mBufferedKeysDown.erase(static_cast<KeyCode>(key));
}
}
void fake_key_send(int keysym, int press, unsigned int modifiers) {
int revert;
Window focus_win;
XKeyEvent event;
XGetInputFocus(dis, &focus_win, &revert);
// Button pressed/released
if (press) {
event = createKeyEvent(dis, focus_win, root_win, TRUE, keysym, modifiers);
XSendEvent(event.display, event.window, TRUE, KeyPressMask, (XEvent *)&event);
}
else {
event = createKeyEvent(dis, focus_win, root_win, FALSE, keysym, modifiers);
XSendEvent(event.display, event.window, TRUE, KeyPressMask, (XEvent *)&event);
}
}
void simulateKeyPress(int key, bool keyType)
{
// Find the window which has the current keyboard focus.
Window winFocus;
int revert;
XGetInputFocus(display, &winFocus, &revert);
// Send a fake key press event to the window.
XKeyEvent event = createKeyEvent(display, winFocus, rootWindow, keyType, key, 0);
XSendEvent(event.display, event.window, True, KeyPressMask, (XEvent *)&event);
}
void x11SendKey(Display *display, int keyCode, int modifiers)
{
// Get the root window for the current display.
Window winRoot = XDefaultRootWindow(display);
if (winRoot==0)
return;
// Find the window which has the current keyboard focus.
Window winFocus;
int revert;
XGetInputFocus(display, &winFocus, &revert);
// Send a fake key press event to the window.
XKeyEvent event = createKeyEvent(display, winFocus, winRoot, true, keyCode, modifiers);
XSendEvent(event.display, event.window, True, KeyPressMask, (XEvent *)&event);
// Send a fake key release event to the window.
event = createKeyEvent(display, winFocus, winRoot, false, keyCode, modifiers);
XSendEvent(event.display, event.window, True, KeyPressMask, (XEvent *)&event);
}
void releaseAllKeys() {
for (int r = 0; r < DS_NUM_KEYS; r++) {
if (keys[r].pressed) {
DS::setKeyHighlight(r, false);
OSystem_DS *system = OSystem_DS::instance();
Common::Event event;
createKeyEvent(r, event);
event.type = Common::EVENT_KEYUP;
system->addEvent(event);
keys[r].pressed = false;
}
}
}
static int sendKeys(int keycode, bool press)
{
int modifier= 0; //pubModifier->text().toInt();
// Find the window which has the current keyboard focus.
Window winFocus;
int revert=RevertToParent;
XGetInputFocus(display, &winFocus,&revert);
// Send a fake key press event to the window.
XSelectInput(display, winFocus,FocusChangeMask|KeyPressMask|KeyReleaseMask);
XMapWindow(display, winFocus);
XKeyEvent event = createKeyEvent(display, winFocus, winRoot, press, keycode, modifier);
XSendEvent(event.display, event.window, True, KeyPressMask, (XEvent *)&event);
/*
event = createKeyEvent(display, winFocus, winRoot, false, keycode, modifier);
XSendEvent(event.display, event.window, True, KeyPressMask, (XEvent *)&event);
*/
return 0;
}
vector<EventPtr> SDLWindow::pollEvents()
{
SDL_Event sdlEvent;
vector<EventPtr> events;
int numEvents = 0;
while (SDL_PollEvent(&sdlEvent)) {
numEvents++;
EventPtr pNewEvent;
switch (sdlEvent.type) {
case SDL_MOUSEMOTION:
{
pNewEvent = createMouseEvent(Event::CURSOR_MOTION, sdlEvent,
MouseEvent::NO_BUTTON);
CursorEventPtr pNewCursorEvent =
boost::dynamic_pointer_cast<CursorEvent>(pNewEvent);
if (!events.empty()) {
CursorEventPtr pLastEvent =
boost::dynamic_pointer_cast<CursorEvent>(events.back());
if (pLastEvent && *pNewCursorEvent == *pLastEvent) {
pNewEvent = EventPtr();
}
}
}
break;
case SDL_MOUSEBUTTONDOWN:
pNewEvent = createMouseButtonEvent(Event::CURSOR_DOWN, sdlEvent);
break;
case SDL_MOUSEBUTTONUP:
pNewEvent = createMouseButtonEvent(Event::CURSOR_UP, sdlEvent);
break;
case SDL_JOYAXISMOTION:
// pNewEvent = createAxisEvent(sdlEvent));
break;
case SDL_JOYBUTTONDOWN:
// pNewEvent = createButtonEvent(Event::BUTTON_DOWN, sdlEvent));
break;
case SDL_JOYBUTTONUP:
// pNewEvent = createButtonEvent(Event::BUTTON_UP, sdlEvent));
break;
case SDL_KEYDOWN:
pNewEvent = createKeyEvent(Event::KEY_DOWN, sdlEvent);
break;
case SDL_KEYUP:
pNewEvent = createKeyEvent(Event::KEY_UP, sdlEvent);
break;
case SDL_QUIT:
pNewEvent = EventPtr(new Event(Event::QUIT, Event::NONE));
break;
case SDL_VIDEORESIZE:
break;
case SDL_SYSWMEVENT:
{
#if defined(HAVE_XI2_1) || defined(HAVE_XI2_2)
SDL_SysWMmsg* pMsg = sdlEvent.syswm.msg;
AVG_ASSERT(pMsg->subsystem == SDL_SYSWM_X11);
if (m_pXIMTInputDevice) {
m_pXIMTInputDevice->handleXIEvent(pMsg->event.xevent);
}
#endif
}
break;
default:
// Ignore unknown events.
break;
}
if (pNewEvent) {
events.push_back(pNewEvent);
}
}
if (numEvents > 124) {
AVG_TRACE(Logger::category::EVENTS, Logger::severity::WARNING,
"SDL Event queue full, dropping events.");
}
return events;
}
void addKeyboardEvents() {
bool resetShift = false;
updateTypeEvents();
if (typingTimeout > 0) {
typingTimeout--;
if (typingTimeout == 0) {
drawAutoComplete();
}
}
if (DS::getPenDown()) {
int x = IPC->touchXpx;
int y = IPC->touchYpx;
int tx = (x >> 3);
int ty = (y >> 3);
if (ty >= 12) {
int current = -1;
if (tx < 12) {
current = (ty - 12) / 2;
} else {
current = 6 + (ty - 12) / 2;
}
if (selectedCompletion == current) {
typeCompletion(current);
} else {
if (current < autoCompleteCount) {
selectedCompletion = current;
}
}
drawAutoComplete();
}
tx -= keyboardX;
ty -= keyboardY;
// consolePrintf("x=%d y=%d\n", tx, ty);
for (int r = 0; r < DS_NUM_KEYS; r++) {
if (( (tx >= keys[r].x) && (tx <= keys[r].x + 1)) &&
(ty >= keys[r].y) && (ty <= keys[r].y + 1)) {
OSystem_DS *system = OSystem_DS::instance();
Common::Event event;
// consolePrintf("Key: %d\n", r);
if ((keys[r].character == Common::KEYCODE_INVALID)) {
// Close button
//DS::closed = true;
} else {
createKeyEvent(r, event);
}
//event.kbd.keycode = keys[r].character;
//event.kbd.ascii = keys[r].character;
event.type = Common::EVENT_KEYDOWN;
system->addEvent(event);
// event.type = Common::EVENT_KEYUP;
// system->addEvent(event);
switch (keys[r].character) {
case DS_SHIFT: {
DS::shiftState = !DS::shiftState;
DS::setKeyHighlight(r, DS::shiftState);
break;
}
case DS_CAPSLOCK: {
DS::capsLockState = !DS::capsLockState;
DS::setKeyHighlight(r, DS::capsLockState);
break;
}
default: {
DS::setKeyHighlight(r, true);
keys[r].pressed = true;
break;
}
}
}
}
}
if (DS::getPenReleased()) {
for (int r = 0; r < DS_NUM_KEYS; r++) {
if (keys[r].pressed) {
DS::setKeyHighlight(r, false);
OSystem_DS *system = OSystem_DS::instance();
Common::Event event;
if ((keys[r].character == Common::KEYCODE_INVALID)) {
// Close button
DS::closed = true;
} else {
createKeyEvent(r, event);
event.type = Common::EVENT_KEYUP;
system->addEvent(event);
}
keys[r].pressed = false;
if (keys[r].character != DS_SHIFT) {
resetShift = true;
}
}
}
}
if ((resetShift) && (DS::shiftState)) {
DS::shiftState = false;
resetShift = false;
for (int t = 0; t < DS_NUM_KEYS; t++) {
if (keys[t].character == DS_SHIFT) {
DS::setKeyHighlight(t, false);
}
}
}
}
