static void handle_key(XGenericEventCookie *cookie)
{
XIDeviceEvent *ev = (XIDeviceEvent *)cookie->data;
qboolean down = cookie->evtype == XI_KeyPress;
int keycode = ev->detail;
unsigned time = Sys_XTimeToSysTime(ev->time);
// Ignore shift_level for game key press
KeySym keysym = XkbKeycodeToKeysym(x11display.dpy, keycode, 0, 0);
int key = XLateKey( keysym );
// Set or clear 1 in the shift_level bitmask
if ( keysym == XK_Shift_L || keysym == XK_Shift_R )
shift_level ^= (-down ^ shift_level) & 1;
// Set or clear 2 in the shift_level bitmask
else if( keysym == XK_ISO_Level3_Shift )
shift_level ^= (-down ^ shift_level) & 2;
Key_Event(key, down, time);
if( down )
{
// Use shift_level for chat and console input
qwchar wc = keysym2ucs(XkbKeycodeToKeysym(x11display.dpy, keycode, 0, shift_level));
if( wc == -1 && key > K_NUMLOCK && key <= KP_EQUAL )
wc = ( qwchar )key;
// Convert ctrl-c / ctrl-v combinations to the expected events
if( Key_IsDown(K_LCTRL) || Key_IsDown(K_RCTRL) )
{
if( key == 'v' )
{
key = CTRLV;
wc = CTRLV;
}
else if( key == 'c' )
{
key = CTRLC;
wc = CTRLC;
}
}
Key_CharEvent( key, wc );
}
}
/*
===========
IN_ProcessEvents
===========
*/
void IN_ProcessEvents (void)
{
// handle the mouse state when windowed if that's changed
if (!vidmode_fullscreen)
{
if ( key_dest == key_game && !mouse_grab_active && vid_activewindow )
// if ( key_dest != key_console && !mouse_grab_active && vid_activewindow )
{
IN_GrabMouse ();
}
else if ( key_dest != key_game && mouse_grab_active )
// else if ( key_dest == key_console && mouse_grab_active )
{
IN_UngrabMouse ();
}
}
// getting and handle events
{
XEvent x_event;
static qboolean active = true;
if (!x_disp)
return;
while (XPending(x_disp))
{
XNextEvent(x_disp, &x_event);
switch (x_event.type)
{
case KeyPress: // key pressed
case KeyRelease: // key released
Key_Event(XLateKey(&x_event.xkey), x_event.type == KeyPress);
break;
case MotionNotify: // mouse moved
if (mouse_grab_active)
{
if (dga_mouse_active)
{
mouse_x += (float)x_event.xmotion.x_root;
mouse_y += (float)x_event.xmotion.y_root;
}
else
{
mouse_x = (float)x_event.xmotion.x - (float)(vid.width / 2);
mouse_y = (float)x_event.xmotion.y - (float)(vid.height / 2);
if (mouse_x || mouse_y) // do warp
{
// move the mouse to the window center again
XWarpPointer(x_disp, None, x_win, 0, 0, 0, 0, vid.width / 2, vid.height / 2);
}
}
}
break;
case ButtonPress: // mouse button pressed
case ButtonRelease: // mouse button released
switch (x_event.xbutton.button)
{
case 1:
Key_Event (K_MOUSE1, x_event.type == ButtonPress);
break;
case 2:
Key_Event (K_MOUSE3, x_event.type == ButtonPress);
break;
case 3:
Key_Event (K_MOUSE2, x_event.type == ButtonPress);
break;
case 4:
Key_Event (K_MWHEELUP, x_event.type == ButtonPress);
break;
case 5:
Key_Event (K_MWHEELDOWN, x_event.type == ButtonPress);
break;
case 6:
Key_Event (K_MOUSE4, x_event.type == ButtonPress);
break;
case 7:
Key_Event (K_MOUSE5, x_event.type == ButtonPress);
break;
case 8:
Key_Event (K_MOUSE6, x_event.type == ButtonPress);
break;
case 9:
Key_Event (K_MOUSE7, x_event.type == ButtonPress);
break;
case 10:
Key_Event (K_MOUSE8, x_event.type == ButtonPress);
break;
}
break;
case CreateNotify: // window created
window_x = x_event.xcreatewindow.x;
window_y = x_event.xcreatewindow.y;
window_width = x_event.xcreatewindow.width;
window_height = x_event.xcreatewindow.height;
break;
case ConfigureNotify: // window changed size/location
window_x = x_event.xconfigure.x;
window_y = x_event.xconfigure.y;
window_width = x_event.xconfigure.width;
window_height = x_event.xconfigure.height;
// check for resize
if (!vidmode_fullscreen)
{
if (window_width < 320)
window_width = 320;
if (window_height < 200)
window_height = 200;
vid.width = window_width;
vid.height = window_height;
vid.conwidth = vid.width;
vid.conheight = vid.height;
vid.recalc_refdef = true; // force a surface cache flush
}
break;
case DestroyNotify: // window has been destroyed
Sys_Quit (0);
break;
case ClientMessage: // window manager messages
if ((x_event.xclient.format == 32) && ((unsigned int)x_event.xclient.data.l[0] == wm_delete_window_atom))
Sys_Quit (0);
break;
case MapNotify: // window restored
case UnmapNotify: // window iconified/rolledup/whatever
vid_hiddenwindow = (x_event.type == UnmapNotify);
case FocusIn: // window is now the input focus
case FocusOut: // window is no longer the input focus
switch (x_event.xfocus.mode)
{
case NotifyNormal:
case NotifyGrab:
case NotifyUngrab:
vid_activewindow = (x_event.type == FocusIn);
break;
}
if(vidmode_fullscreen)
{
if(x_event.type == MapNotify)
{
// set our video mode
XF86VidModeSwitchToMode(x_disp, scrnum, &game_vidmode);
// move the viewport to top left
XF86VidModeSetViewPort(x_disp, scrnum, 0, 0);
}
else if(x_event.type == UnmapNotify)
{
// set our video mode
XF86VidModeSwitchToMode(x_disp, scrnum, &init_vidmode);
}
}
else //if (!vidmode_fullscreen)
{
// enable/disable sound, set/restore gamma and grab/ungrab keyb
// on focus gain/loss
if (vid_activewindow && !vid_hiddenwindow && !active)
{
S_UnblockSound ();
S_ClearBuffer ();
VID_Gamma_Set ();
IN_GrabKeyboard();
active = true;
}
else if (active)
{
S_BlockSound ();
S_ClearBuffer ();
VID_Gamma_Restore ();
IN_UngrabKeyboard();
active = false;
}
}
// fix the leftover Alt from any Alt-Tab or the like that switched us away
Key_ClearStates ();
break;
case EnterNotify: // mouse entered window
case LeaveNotify: // mouse left window
vid_notifywindow = (x_event.type == EnterNotify);
break;
}
}
}
}
static void HandleEvents( void ) {
int b;
int key;
XEvent event;
qboolean dowarp = qfalse;
char *p;
int dx, dy;
int t;
if ( !dpy ) {
return;
}
while ( XPending( dpy ) )
{
XNextEvent( dpy, &event );
switch ( event.type )
{
case KeyPress:
p = XLateKey( &event.xkey, &key );
if ( key ) {
Sys_QueEvent( 0, SE_KEY, key, qtrue, 0, NULL );
}
if ( p ) {
while ( *p )
{
Sys_QueEvent( 0, SE_CHAR, *p++, 0, 0, NULL );
}
}
break;
case KeyRelease:
// bk001206 - handle key repeat w/o XAutRepatOn/Off
// also: not done if console/menu is active.
// From Ryan's Fakk2.
// see game/q_shared.h, KEYCATCH_* . 0 == in 3d game.
if ( cls.keyCatchers == 0 ) { // FIXME: KEYCATCH_NONE
if ( repeated_press( &event ) == qtrue ) {
continue;
}
} // if
XLateKey( &event.xkey, &key );
Sys_QueEvent( 0, SE_KEY, key, qfalse, 0, NULL );
break;
case MotionNotify:
if ( mouse_active ) {
#ifdef PANDORA
//broken on Pandora
if (0) {
#else
if ( dgamouse ) {
#endif
if ( abs( event.xmotion.x_root ) > 1 ) {
mx += event.xmotion.x_root * 2;
} else {
mx += event.xmotion.x_root;
}
if ( abs( event.xmotion.y_root ) > 1 ) {
my += event.xmotion.y_root * 2;
} else {
my += event.xmotion.y_root;
}
t = Sys_Milliseconds();
if ( t - mouseResetTime > MOUSE_RESET_DELAY ) {
Sys_QueEvent( t, SE_MOUSE, mx, my, 0, NULL );
}
mx = my = 0;
} else
{
// If it's a center motion, we've just returned from our warp
if ( event.xmotion.x == glConfig.vidWidth / 2 &&
event.xmotion.y == glConfig.vidHeight / 2 ) {
mwx = glConfig.vidWidth / 2;
mwy = glConfig.vidHeight / 2;
t = Sys_Milliseconds();
if ( t - mouseResetTime > MOUSE_RESET_DELAY ) {
Sys_QueEvent( t, SE_MOUSE, mx, my, 0, NULL );
}
mx = my = 0;
break;
}
dx = ( (int)event.xmotion.x - mwx );
dy = ( (int)event.xmotion.y - mwy );
if ( abs( dx ) > 1 ) {
mx += dx * 2;
} else {
mx += dx;
}
if ( abs( dy ) > 1 ) {
my += dy * 2;
} else {
my += dy;
}
mwx = event.xmotion.x;
mwy = event.xmotion.y;
dowarp = qtrue;
}
}
break;
case ButtonPress:
if ( event.xbutton.button == 4 ) {
Sys_QueEvent( 0, SE_KEY, K_MWHEELUP, qtrue, 0, NULL );
} else if ( event.xbutton.button == 5 ) {
Sys_QueEvent( 0, SE_KEY, K_MWHEELDOWN, qtrue, 0, NULL );
} else
{
// NOTE TTimo there seems to be a weird mapping for K_MOUSE1 K_MOUSE2 K_MOUSE3 ..
b = -1;
if ( event.xbutton.button == 1 ) {
b = 0; // K_MOUSE1
} else if ( event.xbutton.button == 2 ) {
b = 2; // K_MOUSE3
} else if ( event.xbutton.button == 3 ) {
b = 1; // K_MOUSE2
} else if ( event.xbutton.button == 6 ) {
b = 3; // K_MOUSE4
} else if ( event.xbutton.button == 7 ) {
b = 4; // K_MOUSE5
}
;
Sys_QueEvent( 0, SE_KEY, K_MOUSE1 + b, qtrue, 0, NULL );
}
break;
case ButtonRelease:
if ( event.xbutton.button == 4 ) {
Sys_QueEvent( 0, SE_KEY, K_MWHEELUP, qfalse, 0, NULL );
} else if ( event.xbutton.button == 5 ) {
Sys_QueEvent( 0, SE_KEY, K_MWHEELDOWN, qfalse, 0, NULL );
} else
{
b = -1;
if ( event.xbutton.button == 1 ) {
b = 0;
} else if ( event.xbutton.button == 2 ) {
b = 2;
} else if ( event.xbutton.button == 3 ) {
b = 1;
} else if ( event.xbutton.button == 6 ) {
b = 3; // K_MOUSE4
} else if ( event.xbutton.button == 7 ) {
b = 4; // K_MOUSE5
}
;
Sys_QueEvent( 0, SE_KEY, K_MOUSE1 + b, qfalse, 0, NULL );
}
break;
case CreateNotify:
win_x = event.xcreatewindow.x;
win_y = event.xcreatewindow.y;
break;
case ConfigureNotify:
win_x = event.xconfigure.x;
win_y = event.xconfigure.y;
break;
}
}
if ( dowarp ) {
XWarpPointer( dpy,None,win,0,0,0,0,
( glConfig.vidWidth / 2 ),( glConfig.vidHeight / 2 ) );
}
}
void IN_ActivateMouse( void ) {
if ( !mouse_avail || !dpy || !win ) {
return;
}
if ( !mouse_active ) {
install_grabs();
mouse_active = qtrue;
}
}
void IN_DeactivateMouse( void ) {
if ( !mouse_avail || !dpy || !win ) {
return;
}
if ( mouse_active ) {
uninstall_grabs();
mouse_active = qfalse;
}
}
/*****************************************************************************/
static qboolean signalcaught = qfalse;;
void Sys_Exit( int ); // bk010104 - abstraction
static void signal_handler( int sig ) { // bk010104 - replace this... (NOTE TTimo huh?)
if ( signalcaught ) {
printf( "DOUBLE SIGNAL FAULT: Received signal %d, exiting...\n", sig );
Sys_Exit( 1 ); // bk010104 - abstraction
}
signalcaught = qtrue;
printf( "Received signal %d, exiting...\n", sig );
GLimp_Shutdown(); // bk010104 - shouldn't this be CL_Shutdown
Sys_Exit( 0 ); // bk010104 - abstraction NOTE TTimo send a 0 to avoid DOUBLE SIGNAL FAULT
}
static void InitSig( void ) {
signal( SIGHUP, signal_handler );
signal( SIGQUIT, signal_handler );
signal( SIGILL, signal_handler );
signal( SIGTRAP, signal_handler );
signal( SIGIOT, signal_handler );
signal( SIGBUS, signal_handler );
signal( SIGFPE, signal_handler );
signal( SIGSEGV, signal_handler );
signal( SIGTERM, signal_handler );
}
void
GetEvent(SDL_Event * event)
{
unsigned int key;
switch (event->type) {
case SDL_MOUSEBUTTONDOWN:
if (event->button.button == 4) {
keyq[keyq_head].key = K_MWHEELUP;
keyq[keyq_head].down = true;
keyq_head = (keyq_head + 1) & 63;
keyq[keyq_head].key = K_MWHEELUP;
keyq[keyq_head].down = false;
keyq_head = (keyq_head + 1) & 63;
} else if (event->button.button == 5) {
keyq[keyq_head].key = K_MWHEELDOWN;
keyq[keyq_head].down = true;
keyq_head = (keyq_head + 1) & 63;
keyq[keyq_head].key = K_MWHEELDOWN;
keyq[keyq_head].down = false;
keyq_head = (keyq_head + 1) & 63;
}
break;
case SDL_MOUSEBUTTONUP:
break;
#ifdef Joystick
case SDL_JOYBUTTONDOWN:
keyq[keyq_head].key =
((((SDL_JoyButtonEvent *) event)->button < 4) ? K_JOY1 : K_AUX1) +
((SDL_JoyButtonEvent *) event)->button;
keyq[keyq_head].down = true;
keyq_head = (keyq_head + 1) & 63;
break;
case SDL_JOYBUTTONUP:
keyq[keyq_head].key =
((((SDL_JoyButtonEvent *) event)->button < 4) ? K_JOY1 : K_AUX1) +
((SDL_JoyButtonEvent *) event)->button;
keyq[keyq_head].down = false;
keyq_head = (keyq_head + 1) & 63;
break;
#endif
case SDL_KEYDOWN:
if ((KeyStates[SDLK_LALT] || KeyStates[SDLK_RALT]) &&
(event->key.keysym.sym == SDLK_RETURN)) {
cvar_t *fullscreen;
SDL_WM_ToggleFullScreen(surface);
if (surface->flags & SDL_FULLSCREEN) {
ri.Cvar_SetValue("vid_fullscreen", 1);
} else {
ri.Cvar_SetValue("vid_fullscreen", 0);
}
fullscreen = ri.Cvar_Get("vid_fullscreen", "0", 0);
fullscreen->modified = false; /* we just changed it with SDL. */
break; /* ignore this key */
}
if ((KeyStates[SDLK_LCTRL] || KeyStates[SDLK_RCTRL]) &&
(event->key.keysym.sym == SDLK_g)) {
SDL_GrabMode gm = SDL_WM_GrabInput(SDL_GRAB_QUERY);
/*
* SDL_WM_GrabInput((gm == SDL_GRAB_ON) ?
* SDL_GRAB_OFF : SDL_GRAB_ON); gm =
* SDL_WM_GrabInput(SDL_GRAB_QUERY);
*/
ri.Cvar_SetValue("_windowed_mouse", (gm == SDL_GRAB_ON) ? /* 1 */ 0 : /* 0 */ 1);
break; /* ignore this key */
}
KeyStates[event->key.keysym.sym] = 1;
key = XLateKey(event->key.keysym.sym);
if (key) {
keyq[keyq_head].key = key;
keyq[keyq_head].down = true;
keyq_head = (keyq_head + 1) & 63;
}
break;
case SDL_KEYUP:
if (KeyStates[event->key.keysym.sym]) {
KeyStates[event->key.keysym.sym] = 0;
key = XLateKey(event->key.keysym.sym);
if (key) {
keyq[keyq_head].key = key;
keyq[keyq_head].down = false;
keyq_head = (keyq_head + 1) & 63;
}
}
break;
case SDL_QUIT:
ri.Cmd_ExecuteText(EXEC_NOW, "quit");
break;
}
}
static void
GetEvent (void)
{
ggi_event ev;
uint32 b;
ggiEventRead (ggivis, &ev, emAll);
switch (ev.any.type) {
case evKeyPress:
Key_Event (XLateKey (&ev.key), 0, true);
break;
case evKeyRelease:
Key_Event (XLateKey (&ev.key), 0, false);
break;
case evPtrRelative:
mouse_x += (float) ev.pmove.x;
mouse_y += (float) ev.pmove.y;
break;
case evPtrAbsolute:
mouse_x += (float) (ev.pmove.x - p_mouse_x);
mouse_y += (float) (ev.pmove.y - p_mouse_y);
p_mouse_x = ev.pmove.x;
p_mouse_y = ev.pmove.y;
break;
case evPtrButtonPress:
if (!mouse_avail)
return;
b = ev.pbutton.button - 1;
if (b < NUM_STDBUTTONS) {
Key_Event (K_MOUSE1 + b, 0, true);
} else if (b < NUM_STDBUTTONS + 2) {
b -= 3;
if (b)
Key_Event (K_MWHEELDOWN, 0, true);
else
Key_Event (K_MWHEELUP, 0, true);
} else if (b < NUM_BUTTONS) {
Key_Event (K_AUX32 - NUM_BUTTONS + b, 0, true);
}
break;
case evPtrButtonRelease:
if (!mouse_avail)
return;
b = ev.pbutton.button - 1;
if (b < NUM_STDBUTTONS) {
Key_Event (K_MOUSE1 + b, 0, false);
} else if (b < NUM_STDBUTTONS + 2) {
b -= 3;
if (b)
Key_Event (K_MWHEELDOWN, 0, false);
else
Key_Event (K_MWHEELUP, 0, false);
} else if (b < NUM_BUTTONS) {
Key_Event (K_AUX32 - NUM_BUTTONS + b, 0, false);
}
break;
#if 0
case ConfigureNotify:
//printf("config notify\n");
config_notify_width = ev.xconfigure.width;
config_notify_height = ev.xconfigure.height;
config_notify = 1;
break;
default:
#endif
}
}
static void HandleEvents(void)
{
XEvent event;
int key;
Uchar unicode;
qboolean dowarp = false;
if (!vidx11_display)
return;
in_mouse_x += in_mouse_x_save;
in_mouse_y += in_mouse_y_save;
in_mouse_x_save = 0;
in_mouse_y_save = 0;
while (XPending(vidx11_display))
{
XNextEvent(vidx11_display, &event);
switch (event.type)
{
case KeyPress:
// key pressed
key = XLateKey (&event.xkey, &unicode);
Key_Event(key, unicode, true);
break;
case KeyRelease:
// key released
key = XLateKey (&event.xkey, &unicode);
Key_Event(key, unicode, false);
break;
case MotionNotify:
// mouse moved
if (vid_usingmouse)
{
#ifdef USEDGA
if (vid_usingdgamouse)
{
in_mouse_x += event.xmotion.x_root;
in_mouse_y += event.xmotion.y_root;
}
else
#endif
{
if (!event.xmotion.send_event)
{
in_mouse_x += event.xmotion.x - in_windowmouse_x;
in_mouse_y += event.xmotion.y - in_windowmouse_y;
//if (abs(vid.width/2 - event.xmotion.x) + abs(vid.height/2 - event.xmotion.y))
if (vid_stick_mouse.integer || abs(vid.width/2 - event.xmotion.x) > vid.width / 4 || abs(vid.height/2 - event.xmotion.y) > vid.height / 4)
dowarp = true;
}
}
}
in_windowmouse_x = event.xmotion.x;
in_windowmouse_y = event.xmotion.y;
break;
case ButtonPress:
// mouse button pressed
if (event.xbutton.button <= 18)
Key_Event(buttonremap[event.xbutton.button - 1], 0, true);
else
Con_Printf("HandleEvents: ButtonPress gave value %d, 1-18 expected\n", event.xbutton.button);
break;
case ButtonRelease:
// mouse button released
if (event.xbutton.button <= 18)
Key_Event(buttonremap[event.xbutton.button - 1], 0, false);
else
Con_Printf("HandleEvents: ButtonRelease gave value %d, 1-18 expected\n", event.xbutton.button);
break;
case CreateNotify:
// window created
win_x = event.xcreatewindow.x;
win_y = event.xcreatewindow.y;
break;
case ConfigureNotify:
// window changed size/location
win_x = event.xconfigure.x;
win_y = event.xconfigure.y;
if((vid_resizable.integer < 2 || vid_isnetwmfullscreen) && (vid.width != event.xconfigure.width || vid.height != event.xconfigure.height))
{
vid.width = event.xconfigure.width;
vid.height = event.xconfigure.height;
if(vid_isnetwmfullscreen)
Con_Printf("NetWM fullscreen: actually using resolution %dx%d\n", vid.width, vid.height);
else
Con_DPrintf("Updating to ConfigureNotify resolution %dx%d\n", vid.width, vid.height);
DPSOFTRAST_Flush();
if(vid.softdepthpixels)
free(vid.softdepthpixels);
DestroyXImages();
XSync(vidx11_display, False);
if(!BuildXImages(vid.width, vid.height))
return;
XSync(vidx11_display, False);
vid.softpixels = (unsigned int *) vidx11_ximage[vidx11_ximage_pos]->data;
vid.softdepthpixels = (unsigned int *)calloc(4, vid.width * vid.height);
}
break;
case DestroyNotify:
// window has been destroyed
Sys_Quit(0);
break;
case ClientMessage:
// window manager messages
if ((event.xclient.format == 32) && ((unsigned int)event.xclient.data.l[0] == wm_delete_window_atom))
Sys_Quit(0);
break;
case MapNotify:
if (vid_isoverrideredirect)
break;
// window restored
vid_hidden = false;
VID_RestoreSystemGamma();
if(vid_isvidmodefullscreen)
{
// set our video mode
XF86VidModeSwitchToMode(vidx11_display, vidx11_screen, &game_vidmode);
// Move the viewport to top left
XF86VidModeSetViewPort(vidx11_display, vidx11_screen, 0, 0);
}
if(vid_isnetwmfullscreen)
{
// make sure it's fullscreen
XEvent event;
event.type = ClientMessage;
event.xclient.serial = 0;
event.xclient.send_event = True;
event.xclient.message_type = net_wm_state_atom;
event.xclient.window = win;
event.xclient.format = 32;
event.xclient.data.l[0] = 1;
event.xclient.data.l[1] = net_wm_state_fullscreen_atom;
event.xclient.data.l[2] = 0;
event.xclient.data.l[3] = 1;
event.xclient.data.l[4] = 0;
XSendEvent(vidx11_display, root, False, SubstructureRedirectMask | SubstructureNotifyMask, &event);
}
dowarp = true;
break;
case UnmapNotify:
if (vid_isoverrideredirect)
break;
// window iconified/rolledup/whatever
vid_hidden = true;
VID_RestoreSystemGamma();
if(vid_isvidmodefullscreen)
XF86VidModeSwitchToMode(vidx11_display, vidx11_screen, &init_vidmode);
break;
case FocusIn:
if (vid_isoverrideredirect)
break;
// window is now the input focus
vid_activewindow = true;
break;
case FocusOut:
if (vid_isoverrideredirect)
break;
if(vid_isnetwmfullscreen && event.xfocus.mode == NotifyNormal)
{
// iconify netwm fullscreen window when it loses focus
// when the user selects it in the taskbar, the window manager will map it again and send MapNotify
XEvent event;
event.type = ClientMessage;
event.xclient.serial = 0;
event.xclient.send_event = True;
event.xclient.message_type = net_wm_state_atom;
event.xclient.window = win;
event.xclient.format = 32;
event.xclient.data.l[0] = 1;
event.xclient.data.l[1] = net_wm_state_hidden_atom;
event.xclient.data.l[2] = 0;
event.xclient.data.l[3] = 1;
event.xclient.data.l[4] = 0;
XSendEvent(vidx11_display, root, False, SubstructureRedirectMask | SubstructureNotifyMask, &event);
}
// window is no longer the input focus
vid_activewindow = false;
VID_RestoreSystemGamma();
break;
case EnterNotify:
// mouse entered window
break;
case LeaveNotify:
// mouse left window
break;
default:
if(vidx11_shmevent >= 0 && event.type == vidx11_shmevent)
--vidx11_shmwait;
break;
}
}
if (dowarp)
{
/* move the mouse to the window center again */
// we'll catch the warp motion by its send_event flag, updating the
// stored mouse position without adding any delta motion
XEvent event;
event.type = MotionNotify;
event.xmotion.display = vidx11_display;
event.xmotion.window = win;
event.xmotion.x = vid.width / 2;
event.xmotion.y = vid.height / 2;
XSendEvent(vidx11_display, win, False, PointerMotionMask, &event);
XWarpPointer(vidx11_display, None, win, 0, 0, 0, 0, vid.width / 2, vid.height / 2);
}
}
void GetEvent(void)
{
XEvent x_event;
int b;
XNextEvent(x_disp, &x_event);
switch(x_event.type) {
case KeyPress:
keyq[keyq_head].key = XLateKey(&x_event.xkey);
keyq[keyq_head].down = true;
keyq_head = (keyq_head + 1) & 63;
break;
case KeyRelease:
/*
* This is a hack in order to avoid disabling key repeat, which
* would cause a lot of problems when changing to other windows
* or when the program crashes.
*
* Whenever a key release event occurs, we check to see if the
* next event in the queue is a press event of the same key
* with the same time stamp. If it is, we simply discard this
* and the next event.
*/
if( XPending( x_disp ) > 0 ) {
XEvent tmp_event;
XPeekEvent( x_disp, &tmp_event );
if( tmp_event.type == KeyPress &&
tmp_event.xkey.keycode == x_event.xkey.keycode &&
tmp_event.xkey.time == x_event.xkey.time ) {
XNextEvent( x_disp, &tmp_event );
break;
}
}
keyq[keyq_head].key = XLateKey(&x_event.xkey);
keyq[keyq_head].down = false;
keyq_head = (keyq_head + 1) & 63;
break;
case MotionNotify:
if( _windowed_mouse->value ) {
int xoffset = ((int)x_event.xmotion.x - (int)(window_width / 2));
int yoffset = ((int)x_event.xmotion.y - (int)(window_height / 2));
if( xoffset != 0 || yoffset != 0 ) {
mx += xoffset;
my += yoffset;
/* move the mouse to the window center again */
XSelectInput( x_disp, x_win, STD_EVENT_MASK & ~PointerMotionMask );
XWarpPointer( x_disp, None, x_win, 0, 0, 0, 0,
(window_width / 2), (window_height / 2) );
XSelectInput( x_disp, x_win, STD_EVENT_MASK );
}
}
else {
mx = ((int)x_event.xmotion.x - (int)p_mouse_x);
my = ((int)x_event.xmotion.y - (int)p_mouse_y);
p_mouse_x = x_event.xmotion.x;
p_mouse_y = x_event.xmotion.y;
}
break;
case ButtonPress:
b = -1;
if( x_event.xbutton.button == 1 ) {
b = 0;
}
else if( x_event.xbutton.button == 2 ) {
b = 2;
}
else if( x_event.xbutton.button == 3 ) {
b = 1;
}
if( b >= 0 ) {
mouse_buttonstate |= 1 << b;
}
break;
case ButtonRelease:
b = -1;
if( x_event.xbutton.button == 1 ) {
b = 0;
}
else if( x_event.xbutton.button == 2 ) {
b = 2;
}
else if( x_event.xbutton.button == 3 ) {
b = 1;
}
if( b >= 0 ) {
mouse_buttonstate &= ~(1 << b);
}
break;
case ConfigureNotify:
config_notify_width = x_event.xconfigure.width;
config_notify_height = x_event.xconfigure.height;
if( xil_keepaspect->value && !force_resize ) {
double aspect = (double)vid.width / vid.height;
if( config_notify_height > config_notify_width / aspect ) {
force_resize = 1;
XResizeWindow( x_disp, x_win,
config_notify_width,
(int)(config_notify_width / aspect) );
}
else if( config_notify_width > config_notify_height * aspect ) {
force_resize = 1;
XResizeWindow( x_disp, x_win,
(int)(config_notify_height * aspect),
config_notify_height );
}
}
else {
force_resize = 0;
}
if( !force_resize ) {
config_notify = 1;
}
break;
case MapNotify:
if( _windowed_mouse->value ) {
XGrabPointer( x_disp, x_win, True, 0, GrabModeAsync,
GrabModeAsync, x_win, None, CurrentTime);
}
break;
case UnmapNotify:
if( _windowed_mouse->value ) {
XUngrabPointer( x_disp, CurrentTime );
}
break;
default:
;
}
if( old_windowed_mouse != _windowed_mouse->value ) {
old_windowed_mouse = _windowed_mouse->value;
if( !_windowed_mouse->value ) {
/* ungrab the pointer */
XUngrabPointer( x_disp, CurrentTime );
} else {
/* grab the pointer */
XGrabPointer( x_disp, x_win, True, 0, GrabModeAsync,
GrabModeAsync, x_win, None, CurrentTime );
}
}
}
static void HandleEvents(void)
{
const int t = 0; // always just use the current time.
SDL_Event e;
const char *p = NULL;
int key = 0;
if (screen == NULL)
return; // no SDL context.
if (cls.keyCatchers == 0)
{
if (sdlrepeatenabled)
{
SDL_EnableKeyRepeat(0, 0);
sdlrepeatenabled = qfalse;
}
}
else
{
if (!sdlrepeatenabled)
{
SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
sdlrepeatenabled = qtrue;
}
}
while (SDL_PollEvent(&e))
{
switch (e.type)
{
case SDL_KEYDOWN:
printkey(&e);
p = XLateKey(&e.key.keysym, &key);
if (key)
{
Sys_QueEvent( t, SE_KEY, key, qtrue, 0, NULL );
}
if (p)
{
while (*p)
{
Sys_QueEvent( t, SE_CHAR, *p++, 0, 0, NULL );
}
}
break;
case SDL_KEYUP:
XLateKey(&e.key.keysym, &key);
Sys_QueEvent( t, SE_KEY, key, qfalse, 0, NULL );
break;
case SDL_MOUSEMOTION:
if (mouse_active)
{
Sys_QueEvent( t, SE_MOUSE, e.motion.xrel, e.motion.yrel, 0, NULL );
}
break;
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
{
unsigned char b;
switch (e.button.button)
{
case 1: b = K_MOUSE1; break;
case 2: b = K_MOUSE3; break;
case 3: b = K_MOUSE2; break;
case 4: b = K_MWHEELUP; break;
case 5: b = K_MWHEELDOWN; break;
case 6: b = K_MOUSE4; break;
case 7: b = K_MOUSE5; break;
default: b = K_AUX1 + (e.button.button - 8)%16; break;
}
Sys_QueEvent( t, SE_KEY, b, (e.type == SDL_MOUSEBUTTONDOWN?qtrue:qfalse), 0, NULL );
}
break;
case SDL_QUIT:
Sys_Quit();
break;
}
}
}
static void HandleEvents(void)
{
int b;
int key;
XEvent event;
qboolean dowarp = qfalse;
int mwx = glConfig.vidWidth/2;
int mwy = glConfig.vidHeight/2;
char *p;
if (!dpy)
return;
while (XPending(dpy)) {
XNextEvent(dpy, &event);
switch(event.type) {
case KeyPress:
p = XLateKey(&event.xkey, &key);
if (key)
Sys_QueEvent( 0, SE_KEY, key, qtrue, 0, NULL );
while (*p)
Sys_QueEvent( 0, SE_CHAR, *p++, 0, 0, NULL );
break;
case KeyRelease:
XLateKey(&event.xkey, &key);
Sys_QueEvent( 0, SE_KEY, key, qfalse, 0, NULL );
break;
#if 0
case KeyPress:
case KeyRelease:
key = XLateKey(&event.xkey);
Sys_QueEvent( 0, SE_KEY, key, event.type == KeyPress, 0, NULL );
if (key == K_SHIFT)
shift_down = (event.type == KeyPress);
if (key < 128 && (event.type == KeyPress)) {
if (shift_down)
key = keyshift[key];
Sys_QueEvent( 0, SE_CHAR, key, 0, 0, NULL );
}
#endif
break;
case MotionNotify:
if (mouse_active) {
if (dgamouse) {
if (abs(event.xmotion.x_root) > 1)
mx += event.xmotion.x_root * 2;
else
mx += event.xmotion.x_root;
if (abs(event.xmotion.y_root) > 1)
my += event.xmotion.y_root * 2;
else
my += event.xmotion.y_root;
// ri.Printf(PRINT_ALL, "mouse (%d,%d) (root=%d,%d)\n", event.xmotion.x + win_x, event.xmotion.y + win_y, event.xmotion.x_root, event.xmotion.y_root);
}
else
{
// ri.Printf(PRINT_ALL, "mouse x=%d,y=%d\n", (int)event.xmotion.x - mwx, (int)event.xmotion.y - mwy);
mx += ((int)event.xmotion.x - mwx);
my += ((int)event.xmotion.y - mwy);
mwx = event.xmotion.x;
mwy = event.xmotion.y;
if (mx || my)
dowarp = qtrue;
}
}
break;
case ButtonPress:
b=-1;
if (event.xbutton.button == 1)
b = 0;
else if (event.xbutton.button == 2)
b = 2;
else if (event.xbutton.button == 3)
b = 1;
Sys_QueEvent( 0, SE_KEY, K_MOUSE1 + b, qtrue, 0, NULL );
break;
case ButtonRelease:
b=-1;
if (event.xbutton.button == 1)
b = 0;
else if (event.xbutton.button == 2)
b = 2;
else if (event.xbutton.button == 3)
b = 1;
Sys_QueEvent( 0, SE_KEY, K_MOUSE1 + b, qfalse, 0, NULL );
break;
case CreateNotify :
win_x = event.xcreatewindow.x;
win_y = event.xcreatewindow.y;
break;
case ConfigureNotify :
win_x = event.xconfigure.x;
win_y = event.xconfigure.y;
break;
}
}
if (dowarp) {
/* move the mouse to the window center again */
XWarpPointer(dpy,None,win,0,0,0,0,
(glConfig.vidWidth/2),(glConfig.vidHeight/2));
}
}
static void HandleEvents(void)
{
int key;
XEvent event;
char *p;
static int dx = 0, dy = 0;
int t = 0; // default to 0 in case we don't set
if (!dpy)
return;
while (XPending(dpy)) {
XNextEvent(dpy, &event);
switch (event.type) {
case KeyPress:
t = Sys_XTimeToSysTime(event.xkey.time);
p = XLateKey(&event.xkey, &key);
if (key) {
Com_QueueEvent(t, SE_KEY, key, qtrue, 0, NULL);
}
if (p) {
while (*p) {
Com_QueueEvent(t, SE_CHAR, *p++, 0, 0,
NULL);
}
}
break;
case KeyRelease:
t = Sys_XTimeToSysTime(event.xkey.time);
#if 0
// bk001206 - handle key repeat w/o XAutRepatOn/Off
// also: not done if console/menu is active.
// From Ryan's Fakk2.
// see game/q_shared.h, KEYCATCH_* . 0 == in 3d game.
if (cls.keyCatchers == 0) { // FIXME: KEYCATCH_NONE
if (repeated_press(&event) == qtrue)
continue;
} // if
#endif
XLateKey(&event.xkey, &key);
Com_QueueEvent(t, SE_KEY, key, qfalse, 0, NULL);
break;
case MotionNotify:
t = Sys_XTimeToSysTime(event.xkey.time);
dx = event.xmotion.x;
dy = event.xmotion.y;
break;
case ButtonPress:
case ButtonRelease:
t = Sys_XTimeToSysTime(event.xkey.time);
motionPressed = (qboolean) (event.type == ButtonPress);
if (Key_GetCatcher() & (KEYCATCH_CGAME | KEYCATCH_UI)) {
Com_QueueEvent(t, SE_KEY, K_MOUSE1,
motionPressed, 0, NULL);
}
break;
case CreateNotify:
win_x = event.xcreatewindow.x;
win_y = event.xcreatewindow.y;
break;
case ConfigureNotify:
win_x = event.xconfigure.x;
win_y = event.xconfigure.y;
break;
}
}
if (motionPressed) {
Com_QueueEvent(t, SE_MOUSE, dx, dy, 0, NULL);
}
Proximity_HandleEvents();
Accelerometer_HandleEvents();
}
static void HandleEvents(void)
{
int b;
int key;
XEvent event;
qboolean dowarp = qfalse;
char *p;
int dx, dy;
int t;
if (!dpy)
return;
while (XPending(dpy)) {
XNextEvent(dpy, &event);
switch(event.type) {
case KeyPress:
p = XLateKey(&event.xkey, &key);
if (key)
Sys_QueEvent( 0, SE_KEY, key, qtrue, 0, NULL );
while (*p)
Sys_QueEvent( 0, SE_CHAR, *p++, 0, 0, NULL );
break;
case KeyRelease:
// bk001206 - handle key repeat w/o XAutRepatOn/Off
// also: not done if console/menu is active.
// From Ryan's Fakk2.
// see game/q_shared.h, KEYCATCH_* . 0 == in 3d game.
if (cls.keyCatchers == 0) { // FIXME: KEYCATCH_NONE
if (repeated_press(&event) == qtrue)
continue;
} // if
XLateKey(&event.xkey, &key);
Sys_QueEvent( 0, SE_KEY, key, qfalse, 0, NULL );
break;
case MotionNotify:
if (mouse_active) {
if (dgamouse) {
if (abs(event.xmotion.x_root) > 1)
mx += event.xmotion.x_root * 2;
else
mx += event.xmotion.x_root;
if (abs(event.xmotion.y_root) > 1)
my += event.xmotion.y_root * 2;
else
my += event.xmotion.y_root;
t = Sys_Milliseconds();
if (t - mouseResetTime > MOUSE_RESET_DELAY ) {
Sys_QueEvent( t, SE_MOUSE, mx, my, 0, NULL );
}
mx = my = 0;
}
else
{
// ri.Printf( PRINT_ALL, "MotionNotify: %d,%d: ", event.xmotion.x, event.xmotion.y );
// If it's a center motion, we've just returned from our warp
if (event.xmotion.x == glConfig.vidWidth/2 &&
event.xmotion.y == glConfig.vidHeight/2) {
mwx = glConfig.vidWidth/2;
mwy = glConfig.vidHeight/2;
// ri.Printf( PRINT_ALL, "SE_MOUSE (%d,%d)\n", mx, my );
t = Sys_Milliseconds();
if (t - mouseResetTime > MOUSE_RESET_DELAY ) {
Sys_QueEvent( t, SE_MOUSE, mx, my, 0, NULL );
}
mx = my = 0;
break;
}
dx = ((int)event.xmotion.x - mwx);
dy = ((int)event.xmotion.y - mwy);
if (abs(dx) > 1)
mx += dx * 2;
else
mx += dx;
if (abs(dy) > 1)
my += dy * 2;
else
my += dy;
// ri.Printf( PRINT_ALL, "mx=%d,my=%d [%d - %d,%d - %d]\n", mx, my, event.xmotion.x, mwx, event.xmotion.y, mwy );
mwx = event.xmotion.x;
mwy = event.xmotion.y;
dowarp = qtrue;
}
}
break;
case ButtonPress:
if (event.xbutton.button == 4) {
Sys_QueEvent( 0, SE_KEY, K_MWHEELUP, qtrue, 0, NULL );
} else if (event.xbutton.button == 5) {
Sys_QueEvent( 0, SE_KEY, K_MWHEELDOWN, qtrue, 0, NULL );
} else {
b=-1;
if (event.xbutton.button == 1) {
b = 0;
} else if (event.xbutton.button == 2) {
b = 2;
} else if (event.xbutton.button == 3) {
b = 1;
}
Sys_QueEvent( 0, SE_KEY, K_MOUSE1 + b, qtrue, 0, NULL );
}
break;
case ButtonRelease:
if (event.xbutton.button == 4) {
Sys_QueEvent( 0, SE_KEY, K_MWHEELUP, qfalse, 0, NULL );
} else if (event.xbutton.button == 5) {
Sys_QueEvent( 0, SE_KEY, K_MWHEELDOWN, qfalse, 0, NULL );
} else {
b=-1;
if (event.xbutton.button == 1) {
b = 0;
} else if (event.xbutton.button == 2) {
b = 2;
} else if (event.xbutton.button == 3) {
b = 1;
}
Sys_QueEvent( 0, SE_KEY, K_MOUSE1 + b, qfalse, 0, NULL );
}
break;
case CreateNotify :
win_x = event.xcreatewindow.x;
win_y = event.xcreatewindow.y;
break;
case ConfigureNotify :
win_x = event.xconfigure.x;
win_y = event.xconfigure.y;
break;
}
}
if (dowarp) {
XWarpPointer(dpy,None,win,0,0,0,0,
(glConfig.vidWidth/2),(glConfig.vidHeight/2));
}
}
static void HandleEvents( void ) {
int b;
int key;
XEvent event;
qboolean dowarp = qfalse;
char *p;
int dx, dy;
int t = 0; // default to 0 in case we don't set
if ( !dpy ) {
return;
}
while ( XPending( dpy ) )
{
XNextEvent( dpy, &event );
switch ( event.type )
{
case KeyPress:
t = Sys_XTimeToSysTime( event.xkey.time );
p = XLateKey( &event.xkey, &key );
if ( key ) {
Sys_QueEvent( t, SE_KEY, key, qtrue, 0, NULL );
}
if ( p ) {
while ( *p )
{
Sys_QueEvent( t, SE_CHAR, *p++, 0, 0, NULL );
}
}
break;
case KeyRelease:
t = Sys_XTimeToSysTime( event.xkey.time );
// bk001206 - handle key repeat w/o XAutRepatOn/Off
// also: not done if console/menu is active.
// From Ryan's Fakk2.
// see game/q_shared.h, KEYCATCH_* . 0 == in 3d game.
if ( cls.keyCatchers == 0 ) { // FIXME: KEYCATCH_NONE
if ( repeated_press( &event ) == qtrue ) {
continue;
}
} // if
XLateKey( &event.xkey, &key );
Sys_QueEvent( t, SE_KEY, key, qfalse, 0, NULL );
break;
case MotionNotify:
t = Sys_XTimeToSysTime( event.xkey.time );
if ( mouse_active ) {
if ( in_dgamouse->value ) {
if ( abs( event.xmotion.x_root ) > 1 ) {
mx += event.xmotion.x_root * 2;
} else {
mx += event.xmotion.x_root;
}
if ( abs( event.xmotion.y_root ) > 1 ) {
my += event.xmotion.y_root * 2;
} else {
my += event.xmotion.y_root;
}
if ( t - mouseResetTime > MOUSE_RESET_DELAY ) {
Sys_QueEvent( t, SE_MOUSE, mx, my, 0, NULL );
}
mx = my = 0;
} else
{
// If it's a center motion, we've just returned from our warp
if ( event.xmotion.x == glConfig.vidWidth / 2 &&
event.xmotion.y == glConfig.vidHeight / 2 ) {
mwx = glConfig.vidWidth / 2;
mwy = glConfig.vidHeight / 2;
if ( t - mouseResetTime > MOUSE_RESET_DELAY ) {
Sys_QueEvent( t, SE_MOUSE, mx, my, 0, NULL );
}
mx = my = 0;
break;
}
dx = ( (int)event.xmotion.x - mwx );
dy = ( (int)event.xmotion.y - mwy );
if ( abs( dx ) > 1 ) {
mx += dx * 2;
} else {
mx += dx;
}
if ( abs( dy ) > 1 ) {
my += dy * 2;
} else {
my += dy;
}
mwx = event.xmotion.x;
mwy = event.xmotion.y;
dowarp = qtrue;
}
}
break;
case ButtonPress:
t = Sys_XTimeToSysTime( event.xkey.time );
if ( event.xbutton.button == 4 ) {
Sys_QueEvent( t, SE_KEY, K_MWHEELUP, qtrue, 0, NULL );
} else if ( event.xbutton.button == 5 ) {
Sys_QueEvent( t, SE_KEY, K_MWHEELDOWN, qtrue, 0, NULL );
} else
{
// NOTE TTimo there seems to be a weird mapping for K_MOUSE1 K_MOUSE2 K_MOUSE3 ..
b = -1;
if ( event.xbutton.button == 1 ) {
b = 0; // K_MOUSE1
} else if ( event.xbutton.button == 2 ) {
b = 2; // K_MOUSE3
} else if ( event.xbutton.button == 3 ) {
b = 1; // K_MOUSE2
} else if ( event.xbutton.button == 6 ) {
b = 3; // K_MOUSE4
} else if ( event.xbutton.button == 7 ) {
b = 4; // K_MOUSE5
}
;
Sys_QueEvent( t, SE_KEY, K_MOUSE1 + b, qtrue, 0, NULL );
}
break;
case ButtonRelease:
t = Sys_XTimeToSysTime( event.xkey.time );
if ( event.xbutton.button == 4 ) {
Sys_QueEvent( t, SE_KEY, K_MWHEELUP, qfalse, 0, NULL );
} else if ( event.xbutton.button == 5 ) {
Sys_QueEvent( t, SE_KEY, K_MWHEELDOWN, qfalse, 0, NULL );
} else
{
b = -1;
if ( event.xbutton.button == 1 ) {
b = 0;
} else if ( event.xbutton.button == 2 ) {
b = 2;
} else if ( event.xbutton.button == 3 ) {
b = 1;
} else if ( event.xbutton.button == 6 ) {
b = 3; // K_MOUSE4
} else if ( event.xbutton.button == 7 ) {
b = 4; // K_MOUSE5
}
;
Sys_QueEvent( t, SE_KEY, K_MOUSE1 + b, qfalse, 0, NULL );
}
break;
case CreateNotify:
win_x = event.xcreatewindow.x;
win_y = event.xcreatewindow.y;
break;
case ConfigureNotify:
win_x = event.xconfigure.x;
win_y = event.xconfigure.y;
break;
}
}
if ( dowarp ) {
XWarpPointer( dpy,None,win,0,0,0,0,
( glConfig.vidWidth / 2 ),( glConfig.vidHeight / 2 ) );
}
}
static void GetEvent(void)
{
XEvent event;
int b;
qbool grab_input;
if (!x_disp)
return;
XNextEvent(x_disp, &event);
switch (event.type)
{
case KeyPress:
case KeyRelease:
Key_Event(XLateKey(&event.xkey), event.type == KeyPress);
break;
case MotionNotify:
if (input_grabbed)
{
#ifdef USE_DGA
if (dgamouse)
{
mouse_x += event.xmotion.x_root;
mouse_y += event.xmotion.y_root;
}
else
#endif
{
mouse_x = (float) ((int)event.xmotion.x - (int)(vid.width/2));
mouse_y = (float) ((int)event.xmotion.y - (int)(vid.height/2));
/* move the mouse to the window center again */
XSelectInput(x_disp, x_win, X_MASK & ~PointerMotionMask);
XWarpPointer(x_disp, None, x_win, 0, 0, 0, 0,
(vid.width/2), (vid.height/2));
XSelectInput(x_disp, x_win, X_MASK);
}
}
break;
case ButtonPress:
b=-1;
if (event.xbutton.button == 1)
b = 0;
else if (event.xbutton.button == 2)
b = 2;
else if (event.xbutton.button == 3)
b = 1;
if (b>=0)
Key_Event(K_MOUSE1 + b, true);
break;
case ButtonRelease:
b=-1;
if (event.xbutton.button == 1)
b = 0;
else if (event.xbutton.button == 2)
b = 2;
else if (event.xbutton.button == 3)
b = 1;
if (b>=0)
Key_Event(K_MOUSE1 + b, false);
break;
}
#ifdef USE_VMODE
grab_input = _windowed_mouse.value != 0 || vidmode_active;
#else
grab_input = _windowed_mouse.value != 0;
#endif
if (grab_input && !input_grabbed) {
/* grab the pointer */
install_grabs();
}
else if (!grab_input && input_grabbed) {
/* ungrab the pointer */
uninstall_grabs();
}
}
static void HandleEvents( void )
{
XEvent event;
qboolean dowarp = qfalse, was_focused = focus;
int mwx = x11display.win_width / 2;
int mwy = x11display.win_height / 2;
char *p;
int key = 0;
int time = 0;
assert( x11display.dpy && x11display.win );
#ifdef WSW_EVDEV
if( mouse_active && m_evdev_num )
{
evdev_read();
}
else
#endif
if( mouse_active && !dgamouse )
{
int root_x, root_y, win_x, win_y;
unsigned int mask;
Window root, child;
if( XQueryPointer( x11display.dpy, x11display.win, &root, &child,
&root_x, &root_y, &win_x, &win_y, &mask ) )
{
mx += ( (int)win_x - mwx );
my += ( (int)win_y - mwy );
mwx = win_x;
mwy = win_y;
if( mx || my )
dowarp = qtrue;
if( ignore_one )
{
mx = my = 0;
ignore_one = qfalse;
}
}
}
while( XPending( x11display.dpy ) )
{
XNextEvent( x11display.dpy, &event );
switch( event.type )
{
case KeyPress:
time = Sys_XTimeToSysTime(event.xkey.time);
p = XLateKey( &event.xkey, &key );
if( key )
Key_Event( key, qtrue, time );
while ( p && *p )
{
qwchar wc = Q_GrabWCharFromUtf8String( (const char **)&p );
Key_CharEvent( key, wc );
}
break;
case KeyRelease:
if( repeated_press( &event ) )
break; // don't send release events when repeating
time = Sys_XTimeToSysTime(event.xkey.time);
XLateKey( &event.xkey, &key );
Key_Event( key, event.type == KeyPress, time );
break;
case MotionNotify:
#ifdef WSW_EVDEV
if( mouse_active && dgamouse && !m_evdev_num )
#else
if( mouse_active && dgamouse )
#endif
{
mx += event.xmotion.x_root;
my += event.xmotion.y_root;
if( ignore_one )
{
mx = my = 0;
ignore_one = qfalse;
}
}
break;
case ButtonPress:
if( ( cls.key_dest == key_console ) && !in_grabinconsole->integer )
break;
#ifdef WSW_EVDEV
if( m_evdev_num )
break;
#endif
time = Sys_XTimeToSysTime(event.xkey.time);
if( event.xbutton.button == 1 ) Key_MouseEvent( K_MOUSE1, 1, time );
else if( event.xbutton.button == 2 ) Key_MouseEvent( K_MOUSE3, 1, time );
else if( event.xbutton.button == 3 ) Key_MouseEvent( K_MOUSE2, 1, time );
else if( event.xbutton.button == 4 ) Key_Event( K_MWHEELUP, 1, time );
else if( event.xbutton.button == 5 ) Key_Event( K_MWHEELDOWN, 1, time );
else if( event.xbutton.button >= 6 && event.xbutton.button <= 10 ) Key_MouseEvent( K_MOUSE4+event.xbutton.button-6, 1, time );
break;
case ButtonRelease:
if( ( cls.key_dest == key_console ) && !in_grabinconsole->integer )
break;
#ifdef WSW_EVDEV
if( m_evdev_num )
break;
#endif
time = Sys_XTimeToSysTime(event.xkey.time);
if( event.xbutton.button == 1 ) Key_MouseEvent( K_MOUSE1, 0, time );
else if( event.xbutton.button == 2 ) Key_MouseEvent( K_MOUSE3, 0, time );
else if( event.xbutton.button == 3 ) Key_MouseEvent( K_MOUSE2, 0, time );
else if( event.xbutton.button == 4 ) Key_Event( K_MWHEELUP, 0, time );
else if( event.xbutton.button == 5 ) Key_Event( K_MWHEELDOWN, 0, time );
else if( event.xbutton.button >= 6 && event.xbutton.button <= 10 ) Key_MouseEvent( K_MOUSE4+event.xbutton.button-6, 0, time );
break;
case FocusIn:
if( x11display.ic )
XSetICFocus(x11display.ic);
if( !focus )
{
focus = qtrue;
}
break;
case FocusOut:
if( x11display.ic )
XUnsetICFocus(x11display.ic);
if( focus )
{
Key_ClearStates();
focus = qfalse;
}
break;
case ClientMessage:
if( event.xclient.data.l[0] == x11display.wmDeleteWindow )
Cbuf_ExecuteText( EXEC_NOW, "quit" );
break;
case MapNotify:
mapped = qtrue;
if( x11display.modeset )
{
if ( x11display.dpy && x11display.win )
{
XSetInputFocus( x11display.dpy, x11display.win, RevertToPointerRoot, CurrentTime );
x11display.modeset = qfalse;
}
}
if( input_active )
{
uninstall_grabs();
install_grabs();
}
break;
case ConfigureNotify:
VID_AppActivate( qtrue, qfalse );
break;
case PropertyNotify:
if( event.xproperty.window == x11display.win )
{
if ( event.xproperty.atom == x11display.wmState )
{
qboolean was_minimized = minimized;
_X11_CheckWMSTATE();
if( minimized != was_minimized )
{
// FIXME: find a better place for this?..
CL_SoundModule_Activate( !minimized );
}
}
}
break;
}
}
if( dowarp )
{
XWarpPointer( x11display.dpy, None, x11display.win, 0, 0, 0, 0,
x11display.win_width/2, x11display.win_height/2 );
}
// set fullscreen or windowed mode upon focus in/out events if:
// a) lost focus in fullscreen -> windowed
// b) received focus -> fullscreen if a)
if( ( focus != was_focused ) )
{
if( x11display.features.wmStateFullscreen )
{
if( !focus && Cvar_Value( "vid_fullscreen" ) )
{
go_fullscreen_on_focus = qtrue;
Cbuf_ExecuteText( EXEC_APPEND, "vid_fullscreen 0\n" );
}
else if( focus && go_fullscreen_on_focus )
{
go_fullscreen_on_focus = qfalse;
Cbuf_ExecuteText( EXEC_APPEND, "vid_fullscreen 1\n" );
}
}
}
}
static void HandleEvents( void )
{
XEvent event;
int b;
_boolean dowarp = false;
int mwx = viddef.width >> 1;
int mwy = viddef.height >> 1;
if( ! display )
{
return;
}
while( XPending( display ) )
{
XNextEvent( display, &event );
switch( event.type )
{
case KeyPress:
case KeyRelease:
Do_Key_Event( XLateKey( &event.xkey ), event.type == KeyPress );
break;
case MotionNotify:
if( mouse_active )
{
if( dgamouse )
{
mx += (event.xmotion.x + win_x) * 2;
my += (event.xmotion.y + win_y) * 2;
}
else
{
mx += ((int)event.xmotion.x - mwx) * 2;
my += ((int)event.xmotion.y - mwy) * 2;
mwx = event.xmotion.x;
mwy = event.xmotion.y;
if( mx || my )
{
dowarp = true;
}
}
}
break;
case ButtonPress:
b = -1;
if( event.xbutton.button == 1 )
{
b = 0;
}
else if( event.xbutton.button == 2 )
{
b = 2;
}
else if( event.xbutton.button == 3 )
{
b = 1;
}
if( b >= 0 )
{
Do_Key_Event( K_MOUSE1 + b, true );
}
break;
case ButtonRelease:
b = -1;
if( event.xbutton.button == 1 )
{
b = 0;
}
else if( event.xbutton.button == 2 )
{
b = 2;
}
else if( event.xbutton.button == 3 )
{
b = 1;
}
if( b >= 0 )
{
Do_Key_Event( K_MOUSE1 + b, false );
}
break;
case CreateNotify :
win_x = event.xcreatewindow.x;
win_y = event.xcreatewindow.y;
break;
case ConfigureNotify :
win_x = event.xconfigure.x;
win_y = event.xconfigure.y;
break;
}
}
if( dowarp )
{
/* move the mouse to the window center again */
XWarpPointer( display, None, mainwin, 0, 0, 0, 0, viddef.width >> 1, viddef.height >> 1 );
}
}
