/*

SDL - Simple DirectMedia Layer

This library is free software; you can redistribute it and/or

modify it under the terms of the GNU Lesser General Public

License as published by the Free Software Foundation; either

version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public

License along with this library; if not, write to the Free Software

Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

Sam Lantinga

slouken@libsdl.org

*/

#include "SDL_config.h"

#include <sys/types.h>

#include <sys/time.h>

#include <unistd.h>

#include "SDL_x11video.h"

#include "../../events/SDL_events_c.h"

#include "SDL_syswm.h"

#include <stdio.h>

//Touch Input/event* includes

#include <linux/input.h>

#include <fcntl.h>

static void

X11_DispatchEvent(_THIS)

{

SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata;

SDL_WindowData *data;

XEvent xevent;

int i;

SDL_zero(xevent); /* valgrind fix. --ryan. */

XNextEvent(videodata->display, &xevent);

/* filter events catchs XIM events and sends them to the correct

handler */

if (XFilterEvent(&xevent, None) == True) {

printf("Filtered event type = %d display = %d window = %d\n",

xevent.type, xevent.xany.display, xevent.xany.window);

#endif

return;

}

SDL_SysWMmsg wmmsg;

SDL_VERSION(&wmmsg.version);

wmmsg.subsystem = SDL_SYSWM_X11;

wmmsg.event.xevent = xevent;

SDL_SendSysWMEvent(&wmmsg);

}

data = NULL;

if (videodata && videodata->windowlist) {

for (i = 0; i < videodata->numwindows; ++i) {

if ((videodata->windowlist[i] != NULL) &&

data = videodata->windowlist[i];

break;

}

}

}

if (!data) {

return;

}

printf("type = %d display = %d window = %d\n",

xevent.type, xevent.xany.display, xevent.xany.window);

switch (xevent.type) {

/* Gaining mouse coverage? */

case EnterNotify:{

#ifdef DEBUG_XEVENTS

printf("EnterNotify! (%d,%d,%d)\n",

xevent.xcrossing.x,

xevent.xcrossing.y,

xevent.xcrossing.mode);

if (xevent.xcrossing.mode == NotifyGrab)

printf("Mode: NotifyGrab\n");

if (xevent.xcrossing.mode == NotifyUngrab)

printf("Mode: NotifyUngrab\n");

#endif

/* FIXME: Should we reset data for all mice? */

for (i = 0; i < SDL_GetNumMice(); ++i) {

SDL_Mouse *mouse = SDL_GetMouse(i);

}

break;

/* Losing mouse coverage? */

case LeaveNotify:{

#ifdef DEBUG_XEVENTS

printf("LeaveNotify! (%d,%d,%d)\n",

xevent.xcrossing.x,

xevent.xcrossing.y,

xevent.xcrossing.mode);

if (xevent.xcrossing.mode == NotifyGrab)

printf("Mode: NotifyGrab\n");

if (xevent.xcrossing.mode == NotifyUngrab)

printf("Mode: NotifyUngrab\n");

#endif

for (i = 0; i < SDL_GetNumMice(); ++i) {

SDL_Mouse *mouse = SDL_GetMouse(i);

SDL_SetMouseFocus(mouse->id, 0);

}

}

}

break;

/* Gaining input focus? */

case FocusIn:{

#ifdef DEBUG_XEVENTS

printf("FocusIn!\n");

#endif

#ifdef X_HAVE_UTF8_STRING

if (data->ic) {

XSetICFocus(data->ic);

}

#endif

}

break;

/* Losing input focus? */

case FocusOut:{

#ifdef DEBUG_XEVENTS

printf("FocusOut!\n");

#endif

SDL_SetKeyboardFocus(videodata->keyboard, 0);

#ifdef X_HAVE_UTF8_STRING

if (data->ic) {

XUnsetICFocus(data->ic);

}

#endif

}

break;

/* Generated upon EnterWindow and FocusIn */

case KeymapNotify:{

#ifdef DEBUG_XEVENTS

printf("KeymapNotify!\n");

#endif

/* FIXME:

X11_SetKeyboardState(SDL_Display, xevent.xkeymap.key_vector);

*/

}

break;

/* Has the keyboard layout changed? */

case MappingNotify:{

#ifdef DEBUG_XEVENTS

printf("MappingNotify!\n");

#endif

}

break;

/* Key press? */

case KeyPress:{

KeyCode keycode = xevent.xkey.keycode;

#ifdef DEBUG_XEVENTS

printf("KeyPress (X11 keycode = 0x%X)\n", xevent.xkey.keycode);

#endif

if (videodata->key_layout[keycode] == SDLK_UNKNOWN) {

int min_keycode, max_keycode;

XDisplayKeycodes(videodata->display, &min_keycode,

&max_keycode);

keysym = XKeycodeToKeysym(videodata->display, keycode, 0);

"The key you just pressed is not recognized by SDL. To help get this fixed, please report this to the SDL mailing list <sdl@libsdl.org> X11 KeyCode %d (%d), X11 KeySym 0x%X (%s).\n",

keycode, keycode - min_keycode, keysym,

XKeysymToString(keysym));

#ifdef X_HAVE_UTF8_STRING

if (data->ic) {

Xutf8LookupString(data->ic, &xevent.xkey, text, sizeof(text),

}

#else

SDL_SendKeyboardText(videodata->keyboard, text);

}

}

break;

/* Key release? */

case KeyRelease:{

KeyCode keycode = xevent.xkey.keycode;

#ifdef DEBUG_XEVENTS

printf("KeyRelease (X11 keycode = 0x%X)\n", xevent.xkey.keycode);

#endif

}

break;

/* Have we been iconified? */

case UnmapNotify:{

#ifdef DEBUG_XEVENTS

printf("UnmapNotify!\n");

#endif

SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_HIDDEN, 0, 0);

SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_MINIMIZED, 0, 0);

}

break;

/* Have we been restored? */

case MapNotify:{

#ifdef DEBUG_XEVENTS

printf("MapNotify!\n");

#endif

SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_SHOWN, 0, 0);

SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_RESTORED, 0, 0);

}

break;

/* Have we been resized or moved? */

case ConfigureNotify:{

#ifdef DEBUG_XEVENTS

printf("ConfigureNotify! (resize: %dx%d)\n",

xevent.xconfigure.width, xevent.xconfigure.height);

#endif

xevent.xconfigure.width,

xevent.xconfigure.height);

}

break;

/* Have we been requested to quit (or another client message?) */

case ClientMessage:{

if ((xevent.xclient.format == 32) &&

(xevent.xclient.data.l[0] == videodata->WM_DELETE_WINDOW)) {

}

}

break;

/* Do we need to refresh ourselves? */

case Expose:{

#ifdef DEBUG_XEVENTS

printf("Expose (count = %d)\n", xevent.xexpose.count);

#endif

}

break;

default:{

for (i = 0; i < SDL_GetNumMice(); ++i) {

SDL_Mouse *mouse;

mouse = SDL_GetMouse(i);

switch (xevent.type) {

case MotionNotify:

#ifdef DEBUG_MOTION

printf("X11 motion: %d,%d\n", xevent.xmotion.x,

xevent.xmotion.y);

SDL_SendMouseMotion(mouse->id, 0, xevent.xmotion.x,

xevent.xmotion.y, 0);

break;

case ButtonPress:

SDL_SendMouseButton(mouse->id, SDL_PRESSED,

xevent.xbutton.button);

break;

case ButtonRelease:

SDL_SendMouseButton(mouse->id, SDL_RELEASED,

xevent.xbutton.button);

break;

}

continue;

}

#if SDL_VIDEO_DRIVER_X11_XINPUT

data = (X11_MouseData *) mouse->driverdata;

if (xevent.type == data->motion) {

XDeviceMotionEvent *move =

(XDeviceMotionEvent *) & xevent;

SDL_SendMouseMotion(move->deviceid, 0, move->x, move->y,

move->axis_data[2]);

return;

}

XDeviceButtonPressedEvent *pressed =

(XDeviceButtonPressedEvent *) & xevent;

SDL_SendMouseButton(pressed->deviceid, SDL_PRESSED,

pressed->button);

return;

}

XDeviceButtonReleasedEvent *released =

(XDeviceButtonReleasedEvent *) & xevent;

SDL_SendMouseButton(released->deviceid, SDL_RELEASED,

released->button);

return;

}

if (xevent.type == data->proximity_in) {

XProximityNotifyEvent *proximity =

(XProximityNotifyEvent *) & xevent;

SDL_SendProximity(proximity->deviceid, proximity->x,

proximity->y, SDL_PROXIMITYIN);

return;

}

if (xevent.type == data->proximity_out) {

XProximityNotifyEvent *proximity =

(XProximityNotifyEvent *) & xevent;

SDL_SendProximity(proximity->deviceid, proximity->x,

proximity->y, SDL_PROXIMITYOUT);

return;

}

#endif

}

break;

}

}

/* Ack! XPending() actually performs a blocking read if no events available */

int

X11_Pending(Display * display)

{

/* Flush the display connection and look to see if events are queued */

XFlush(display);

if (XEventsQueued(display, QueuedAlready)) {

return (1);

}

/* More drastic measures are required -- see if X is ready to talk */

{

static struct timeval zero_time; /* static == 0 */

int x11_fd;

fd_set fdset;

x11_fd = ConnectionNumber(display);

FD_ZERO(&fdset);

FD_SET(x11_fd, &fdset);

if (select(x11_fd + 1, &fdset, NULL, NULL, &zero_time) == 1) {

return (XPending(display));

}

}

/* Oh well, nothing is ready .. */

return (0);

}

void

X11_PumpEvents(_THIS)

{

SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;

/* Update activity every 30 seconds to prevent screensaver */

if (_this->suspend_screensaver) {

Uint32 now = SDL_GetTicks();

if (!data->screensaver_activity ||

XResetScreenSaver(data->display);

data->screensaver_activity = now;

}

}

/* Keep processing pending events */

while (X11_Pending(data->display)) {

X11_DispatchEvent(_this);

}

/* Process Touch events - TODO When X gets touch support, use that instead*/

int i = 0,rd;

struct input_event ev[64];

int size = sizeof (struct input_event);

static int initd = 0; //TODO - HACK!

for(i = 0;i < SDL_GetNumTouch();++i) {

SDL_Touch* touch = SDL_GetTouchIndex(i);

if(!touch) printf("Touch %i/%i DNE\n",i,SDL_GetNumTouch());

EventTouchData* data;

if(!initd){//data->eventStream <= 0) {

touch->driverdata = SDL_malloc(sizeof(EventTouchData));

data = (EventTouchData*)(touch->driverdata);

printf("Openning device...\n");

O_RDONLY | O_NONBLOCK);

ioctl (data->eventStream, EVIOCGNAME (sizeof (name)), name);

printf ("Reading From : %s\n", name);

initd = 1;

}

else

data = (EventTouchData*)(touch->driverdata);

if(data->eventStream <= 0)

printf("Error: Couldn't open stream\n");

rd = read(data->eventStream, ev, size * 64);

//printf("Got %i/%i bytes\n",rd,size);

if(rd >= size) {

for (i = 0; i < rd / sizeof(struct input_event); i++) {

switch (ev[i].type) {

case EV_ABS:

//printf("Got position x: %i!\n",data->x);

if(ev[i].code == ABS_X)

data->x = ev[i].value;

else if (ev[i].code == ABS_Y)

data->y = ev[i].value;

else if (ev[i].code == ABS_MISC) {

data->up = SDL_TRUE;

data->finger = ev[i].value;

}

break;

case EV_MSC:

if(ev[i].code == MSC_SERIAL)

data->finger = ev[i].value;

break;

case EV_SYN:

if(data->x >= 0 || data->y >= 0)

SDL_SendTouchMotion(touch->id,data->finger,

SDL_FALSE,data->x,data->y,

data->pressure);

if(data->up)

SDL_SendFingerDown(touch->id,data->finger,

SDL_FALSE,data->x,data->y,

data->pressure);

//printf("Synched: %i tx: %i, ty: %i\n",

// data->finger,data->x,data->y);

data->x = -1;

data->y = -1;

data->pressure = -1;

data->finger = 0;

data->up = SDL_FALSE;

break;

}

}

}

}

}

/* This is so wrong it hurts */

#define GNOME_SCREENSAVER_HACK

#ifdef GNOME_SCREENSAVER_HACK

#include <unistd.h>

static pid_t screensaver_inhibit_pid;

static void

gnome_screensaver_disable()

{

screensaver_inhibit_pid = fork();

if (screensaver_inhibit_pid == 0) {

close(0);

close(1);

close(2);

execl("/usr/bin/gnome-screensaver-command",

"gnome-screensaver-command",

"--inhibit",

"--reason",

exit(2);

}

}

static void

gnome_screensaver_enable()

{

kill(screensaver_inhibit_pid, 15);

}

#endif

#if SDL_VIDEO_DRIVER_X11_SCRNSAVER

SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;

int dummy;

int major_version, minor_version;

if (SDL_X11_HAVE_XSS) {

/* XScreenSaverSuspend was introduced in MIT-SCREEN-SAVER 1.1 */

if (!XScreenSaverQueryExtension(data->display, &dummy, &dummy) ||

!XScreenSaverQueryVersion(data->display,

&major_version, &minor_version) ||

major_version < 1 || (major_version == 1 && minor_version < 1)) {

return;

}

XScreenSaverSuspend(data->display, _this->suspend_screensaver);

XResetScreenSaver(data->display);

#ifdef GNOME_SCREENSAVER_HACK

if (_this->suspend_screensaver) {

gnome_screensaver_disable();

} else {

gnome_screensaver_enable();

}

}

/* vi: set ts=4 sw=4 expandtab: */