/* The main Win32 event handler */
LRESULT DIB_HandleMessage(_THIS, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
extern int posted;
switch (msg) {
case WM_SYSKEYDOWN:
case WM_KEYDOWN: {
SDL_keysym keysym;
#ifdef _WIN32_WCE
// Drop GAPI artefacts
if (wParam == 0x84 || wParam == 0x5B)
return 0;
// Rotate key if necessary
if (this->hidden->orientation != SDL_ORIENTATION_UP)
wParam = rotateKey(wParam, this->hidden->orientation);
#endif
/* Ignore repeated keys */
if ( lParam&REPEATED_KEYMASK ) {
return(0);
}
switch (wParam) {
case VK_CONTROL:
if ( lParam&EXTENDED_KEYMASK )
wParam = VK_RCONTROL;
else
wParam = VK_LCONTROL;
break;
case VK_SHIFT:
/* EXTENDED trick doesn't work here */
{
Uint8 *state = SDL_GetKeyState(NULL);
if (state[SDLK_LSHIFT] == SDL_RELEASED && (GetKeyState(VK_LSHIFT) & 0x8000)) {
wParam = VK_LSHIFT;
} else if (state[SDLK_RSHIFT] == SDL_RELEASED && (GetKeyState(VK_RSHIFT) & 0x8000)) {
wParam = VK_RSHIFT;
} else {
/* Win9x */
int sc = HIWORD(lParam) & 0xFF;
if (sc == 0x2A)
wParam = VK_LSHIFT;
else
if (sc == 0x36)
wParam = VK_RSHIFT;
else
wParam = VK_LSHIFT;
}
}
break;
case VK_MENU:
if ( lParam&EXTENDED_KEYMASK )
wParam = VK_RMENU;
else
wParam = VK_LMENU;
break;
}
#ifdef NO_GETKEYBOARDSTATE
/* this is the workaround for the missing ToAscii() and ToUnicode() in CE (not necessary at KEYUP!) */
if ( SDL_TranslateUNICODE ) {
MSG m;
m.hwnd = hwnd;
m.message = msg;
m.wParam = wParam;
m.lParam = lParam;
m.time = 0;
if ( TranslateMessage(&m) && PeekMessage(&m, hwnd, 0, WM_USER, PM_NOREMOVE) && (m.message == WM_CHAR) ) {
GetMessage(&m, hwnd, 0, WM_USER);
wParam = m.wParam;
}
}
#endif /* NO_GETKEYBOARDSTATE */
posted = SDL_PrivateKeyboard(SDL_PRESSED,
TranslateKey(wParam,HIWORD(lParam),&keysym,1));
}
return(0);
case WM_SYSKEYUP:
case WM_KEYUP: {
SDL_keysym keysym;
#ifdef _WIN32_WCE
// Drop GAPI artifacts
if (wParam == 0x84 || wParam == 0x5B)
return 0;
// Rotate key if necessary
if (this->hidden->orientation != SDL_ORIENTATION_UP)
wParam = rotateKey(wParam, this->hidden->orientation);
#endif
switch (wParam) {
case VK_CONTROL:
if ( lParam&EXTENDED_KEYMASK )
wParam = VK_RCONTROL;
else
wParam = VK_LCONTROL;
break;
case VK_SHIFT:
/* EXTENDED trick doesn't work here */
{
Uint8 *state = SDL_GetKeyState(NULL);
if (state[SDLK_LSHIFT] == SDL_PRESSED && !(GetKeyState(VK_LSHIFT) & 0x8000)) {
wParam = VK_LSHIFT;
} else if (state[SDLK_RSHIFT] == SDL_PRESSED && !(GetKeyState(VK_RSHIFT) & 0x8000)) {
wParam = VK_RSHIFT;
} else {
/* Win9x */
int sc = HIWORD(lParam) & 0xFF;
if (sc == 0x2A)
wParam = VK_LSHIFT;
else
if (sc == 0x36)
wParam = VK_RSHIFT;
else
wParam = VK_LSHIFT;
}
}
break;
case VK_MENU:
if ( lParam&EXTENDED_KEYMASK )
wParam = VK_RMENU;
else
wParam = VK_LMENU;
break;
}
/* Windows only reports keyup for print screen */
if ( wParam == VK_SNAPSHOT && SDL_GetKeyState(NULL)[SDLK_PRINT] == SDL_RELEASED ) {
posted = SDL_PrivateKeyboard(SDL_PRESSED,
TranslateKey(wParam,HIWORD(lParam),&keysym,1));
}
posted = SDL_PrivateKeyboard(SDL_RELEASED,
TranslateKey(wParam,HIWORD(lParam),&keysym,0));
}
return(0);
#if defined(SC_SCREENSAVE) && defined(SC_MONITORPOWER)
case WM_SYSCOMMAND: {
if ((wParam&0xFFF0)==SC_SCREENSAVE ||
(wParam&0xFFF0)==SC_MONITORPOWER)
return(0);
}
/* Fall through to default processing */
#endif /* SC_SCREENSAVE && SC_MONITORPOWER */
default: {
/* Only post the event if we're watching for it */
if ( SDL_ProcessEvents[SDL_SYSWMEVENT] == SDL_ENABLE ) {
SDL_SysWMmsg wmmsg;
SDL_VERSION(&wmmsg.version);
wmmsg.hwnd = hwnd;
wmmsg.msg = msg;
wmmsg.wParam = wParam;
wmmsg.lParam = lParam;
posted = SDL_PrivateSysWMEvent(&wmmsg);
/* DJM: If the user isn't watching for private
messages in her SDL event loop, then pass it
along to any win32 specific window proc.
*/
} else if (userWindowProc) {
return CallWindowProc(userWindowProc, hwnd, msg, wParam, lParam);
}
}
break;
}
return(DefWindowProc(hwnd, msg, wParam, lParam));
}
LRESULT DIB_HandleMessage(_THIS, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
extern int posted;
switch (msg) {
case WM_SYSKEYDOWN:
case WM_KEYDOWN: {
SDL_keysym keysym;
#ifdef SDL_VIDEO_DRIVER_GAPI
if(this->hidden->gapiInfo)
{
if (wParam == 0x84 || wParam == 0x5B)
return 0;
wParam = rotateKey(wParam, this->hidden->gapiInfo->coordinateTransform);
}
#endif
if ( lParam&REPEATED_KEYMASK ) {
return(0);
}
switch (wParam) {
case VK_CONTROL:
if ( lParam&EXTENDED_KEYMASK )
wParam = VK_RCONTROL;
else
wParam = VK_LCONTROL;
break;
case VK_SHIFT:
{
Uint8 *state = SDL_GetKeyState(NULL);
if (state[SDLK_LSHIFT] == SDL_RELEASED && (GetKeyState(VK_LSHIFT) & 0x8000)) {
wParam = VK_LSHIFT;
} else if (state[SDLK_RSHIFT] == SDL_RELEASED && (GetKeyState(VK_RSHIFT) & 0x8000)) {
wParam = VK_RSHIFT;
} else {
int sc = HIWORD(lParam) & 0xFF;
if (sc == 0x2A)
wParam = VK_LSHIFT;
else
if (sc == 0x36)
wParam = VK_RSHIFT;
else
wParam = VK_LSHIFT;
}
}
break;
case VK_MENU:
if ( lParam&EXTENDED_KEYMASK )
wParam = VK_RMENU;
else
wParam = VK_LMENU;
break;
}
#ifdef NO_GETKEYBOARDSTATE
if ( SDL_TranslateUNICODE ) {
MSG m;
m.hwnd = hwnd;
m.message = msg;
m.wParam = wParam;
m.lParam = lParam;
m.time = 0;
if ( TranslateMessage(&m) && PeekMessage(&m, hwnd, 0, WM_USER, PM_NOREMOVE) && (m.message == WM_CHAR) ) {
GetMessage(&m, hwnd, 0, WM_USER);
wParam = m.wParam;
}
}
#endif
posted = SDL_PrivateKeyboard(SDL_PRESSED,
TranslateKey(wParam,HIWORD(lParam),&keysym,1));
}
return(0);
case WM_SYSKEYUP:
case WM_KEYUP: {
SDL_keysym keysym;
#ifdef SDL_VIDEO_DRIVER_GAPI
if(this->hidden->gapiInfo)
{
if (wParam == 0x84 || wParam == 0x5B)
return 0;
wParam = rotateKey(wParam, this->hidden->gapiInfo->coordinateTransform);
}
#endif
switch (wParam) {
case VK_CONTROL:
if ( lParam&EXTENDED_KEYMASK )
wParam = VK_RCONTROL;
else
wParam = VK_LCONTROL;
break;
case VK_SHIFT:
{
Uint8 *state = SDL_GetKeyState(NULL);
if (state[SDLK_LSHIFT] == SDL_PRESSED && !(GetKeyState(VK_LSHIFT) & 0x8000)) {
wParam = VK_LSHIFT;
} else if (state[SDLK_RSHIFT] == SDL_PRESSED && !(GetKeyState(VK_RSHIFT) & 0x8000)) {
wParam = VK_RSHIFT;
} else {
int sc = HIWORD(lParam) & 0xFF;
if (sc == 0x2A)
wParam = VK_LSHIFT;
else
if (sc == 0x36)
wParam = VK_RSHIFT;
else
wParam = VK_LSHIFT;
}
}
break;
case VK_MENU:
if ( lParam&EXTENDED_KEYMASK )
wParam = VK_RMENU;
else
wParam = VK_LMENU;
break;
}
if ( wParam == VK_SNAPSHOT && SDL_GetKeyState(NULL)[SDLK_PRINT] == SDL_RELEASED ) {
posted = SDL_PrivateKeyboard(SDL_PRESSED,
TranslateKey(wParam,HIWORD(lParam),&keysym,1));
}
posted = SDL_PrivateKeyboard(SDL_RELEASED,
TranslateKey(wParam,HIWORD(lParam),&keysym,0));
}
return(0);
#if defined(SC_SCREENSAVE) && defined(SC_MONITORPOWER)
case WM_SYSCOMMAND: {
const DWORD val = (DWORD) (wParam & 0xFFF0);
if ((val == SC_SCREENSAVE) || (val == SC_MONITORPOWER)) {
if (this->hidden->dibInfo && !allow_screensaver) {
return(0);
}
}
}
#endif
default: {
if ( SDL_ProcessEvents[SDL_SYSWMEVENT] == SDL_ENABLE ) {
SDL_SysWMmsg wmmsg;
SDL_VERSION(&wmmsg.version);
wmmsg.hwnd = hwnd;
wmmsg.msg = msg;
wmmsg.wParam = wParam;
wmmsg.lParam = lParam;
posted = SDL_PrivateSysWMEvent(&wmmsg);
} else if (userWindowProc) {
return CallWindowProc(userWindowProc, hwnd, msg, wParam, lParam);
}
}
break;
}
return(DefWindowProc(hwnd, msg, wParam, lParam));
}
LRESULT DX5_HandleMessage(_THIS, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg) {
#ifdef WM_ACTIVATEAPP
case WM_ACTIVATEAPP: {
int i, active;
active = (wParam && (GetForegroundWindow() == hwnd));
if ( active ) {
for ( i=0; i<MAX_INPUTS; ++i ) {
if (SDL_DIdev[i] != NULL)
IDirectInputDevice2_Acquire(
SDL_DIdev[i]);
}
} else {
for ( i=0; i<MAX_INPUTS; ++i ) {
if (SDL_DIdev[i] != NULL)
IDirectInputDevice2_Unacquire(
SDL_DIdev[i]);
}
mouse_lost = 1;
}
}
break;
#endif
#ifdef WM_DISPLAYCHANGE
case WM_DISPLAYCHANGE: {
WPARAM BitsPerPixel;
WORD SizeX, SizeY;
SizeX = LOWORD(lParam);
SizeY = HIWORD(lParam);
BitsPerPixel = wParam;
}
break;
#endif
case WM_SYSKEYUP:
case WM_SYSKEYDOWN:
case WM_KEYUP:
case WM_KEYDOWN: {
;
}
return(0);
#if defined(SC_SCREENSAVE) || defined(SC_MONITORPOWER)
case WM_SYSCOMMAND: {
if ((wParam&0xFFF0)==SC_SCREENSAVE ||
(wParam&0xFFF0)==SC_MONITORPOWER)
return(0);
}
#endif
default: {
if ( SDL_ProcessEvents[SDL_SYSWMEVENT] == SDL_ENABLE ) {
SDL_SysWMmsg wmmsg;
SDL_VERSION(&wmmsg.version);
wmmsg.hwnd = hwnd;
wmmsg.msg = msg;
wmmsg.wParam = wParam;
wmmsg.lParam = lParam;
posted = SDL_PrivateSysWMEvent(&wmmsg);
} else if (userWindowProc) {
return CallWindowProc(userWindowProc, hwnd, msg, wParam, lParam);
}
}
break;
}
return(DefWindowProc(hwnd, msg, wParam, lParam));
}
/* The main Win32 event handler */
LONG
DIB_HandleMessage(_THIS, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
extern int posted;
switch (msg) {
case WM_SYSKEYDOWN:
case WM_KEYDOWN: {
SDL_keysym keysym;
/* Ignore repeated keys */
if ( lParam&REPEATED_KEYMASK ) {
return(0);
}
switch (wParam) {
case VK_CONTROL:
if ( lParam&EXTENDED_KEYMASK )
wParam = VK_RCONTROL;
else
wParam = VK_LCONTROL;
break;
case VK_SHIFT:
/* EXTENDED trick doesn't work here */
if (!prev_shiftstates[0] && (GetKeyState(VK_LSHIFT) & 0x8000)) {
wParam = VK_LSHIFT;
prev_shiftstates[0] = TRUE;
} else if (!prev_shiftstates[1] && (GetKeyState(VK_RSHIFT) & 0x8000)) {
wParam = VK_RSHIFT;
prev_shiftstates[1] = TRUE;
} else {
/* Huh? */
}
break;
case VK_MENU:
if ( lParam&EXTENDED_KEYMASK )
wParam = VK_RMENU;
else
wParam = VK_LMENU;
break;
}
#ifdef NO_GETKEYBOARDSTATE
/* this is the workaround for the missing ToAscii() and ToUnicode() in CE (not necessary at KEYUP!) */
if ( SDL_TranslateUNICODE ) {
MSG m;
m.hwnd = hwnd;
m.message = msg;
m.wParam = wParam;
m.lParam = lParam;
m.time = 0;
if ( TranslateMessage(&m) && PeekMessage(&m, hwnd, 0, WM_USER, PM_NOREMOVE) && (m.message == WM_CHAR) ) {
GetMessage(&m, hwnd, 0, WM_USER);
wParam = m.wParam;
} else {
wParam = 0;
}
} else {
wParam = 0;
}
#endif /* NO_GETKEYBOARDSTATE */
posted = SDL_PrivateKeyboard(SDL_PRESSED,
TranslateKey(wParam,HIWORD(lParam),&keysym,1));
}
return(0);
case WM_SYSKEYUP:
case WM_KEYUP: {
SDL_keysym keysym;
switch (wParam) {
case VK_CONTROL:
if ( lParam&EXTENDED_KEYMASK )
wParam = VK_RCONTROL;
else
wParam = VK_LCONTROL;
break;
case VK_SHIFT:
/* EXTENDED trick doesn't work here */
if (prev_shiftstates[0] && !(GetKeyState(VK_LSHIFT) & 0x8000)) {
wParam = VK_LSHIFT;
prev_shiftstates[0] = FALSE;
} else if (prev_shiftstates[1] && !(GetKeyState(VK_RSHIFT) & 0x8000)) {
wParam = VK_RSHIFT;
prev_shiftstates[1] = FALSE;
} else {
/* Huh? */
}
break;
case VK_MENU:
if ( lParam&EXTENDED_KEYMASK )
wParam = VK_RMENU;
else
wParam = VK_LMENU;
break;
}
posted = SDL_PrivateKeyboard(SDL_RELEASED,
TranslateKey(wParam,HIWORD(lParam),&keysym,0));
}
return(0);
#if defined(SC_SCREENSAVE) && defined(SC_MONITORPOWER)
case WM_SYSCOMMAND: {
if ((wParam&0xFFF0)==SC_SCREENSAVE ||
(wParam&0xFFF0)==SC_MONITORPOWER)
return(0);
}
/* Fall through to default processing */
#endif /* SC_SCREENSAVE && SC_MONITORPOWER */
default: {
/* Only post the event if we're watching for it */
if ( SDL_ProcessEvents[SDL_SYSWMEVENT] == SDL_ENABLE ) {
SDL_SysWMmsg wmmsg;
SDL_VERSION(&wmmsg.version);
wmmsg.hwnd = hwnd;
wmmsg.msg = msg;
wmmsg.wParam = wParam;
wmmsg.lParam = lParam;
posted = SDL_PrivateSysWMEvent(&wmmsg);
/* DJM: If the user isn't watching for private
messages in her SDL event loop, then pass it
along to any win32 specific window proc.
*/
} else if (userWindowProc) {
return CallWindowProc(userWindowProc, hwnd, msg, wParam, lParam);
}
}
break;
}
return(DefWindowProc(hwnd, msg, wParam, lParam));
}
void WIMP_Poll(_THIS, int waitTime)
{
_kernel_swi_regs regs;
int message[64];
unsigned int code;
int pollMask = 0;
int doPoll = 1;
int sysEvent;
int sdlWindow = this->hidden->window_handle;
if (this->PumpEvents != WIMP_PumpEvents) return;
if (waitTime > 0)
{
_kernel_swi(OS_ReadMonotonicTime, ®s, ®s);
waitTime += regs.r[0];
}
while (doPoll)
{
if (waitTime <= 0)
{
regs.r[0] = pollMask; /* Poll Mask */
/* For no wait time mask out null event so we wait until something happens */
if (waitTime < 0) regs.r[0] |= 1;
regs.r[1] = (int)message;
_kernel_swi(Wimp_Poll, ®s, ®s);
} else
{
regs.r[0] = pollMask;
regs.r[1] = (int)message;
regs.r[2] = waitTime;
_kernel_swi(Wimp_PollIdle, ®s, ®s);
}
/* Flag to specify if we post a SDL_SysWMEvent */
sysEvent = 0;
code = (unsigned int)regs.r[0];
switch(code)
{
case 0: /* Null Event - drop out for standard processing*/
doPoll = 0;
break;
case 1: /* Redraw window */
_kernel_swi(Wimp_RedrawWindow, ®s,®s);
if (message[0] == sdlWindow)
{
while (regs.r[0])
{
WIMP_PlotSprite(this, message[1], message[2]);
_kernel_swi(Wimp_GetRectangle, ®s, ®s);
}
} else
{
/* TODO: Currently we just eat them - we may need to pass them on */
while (regs.r[0])
{
_kernel_swi(Wimp_GetRectangle, ®s, ®s);
}
}
break;
case 2: /* Open window */
if ( resizeOnOpen && message[0] == sdlWindow)
{
/* Ensure window is correct size */
resizeOnOpen = 0;
message[3] = message[1] + (this->screen->w << this->hidden->xeig);
message[4] = message[2] + (this->screen->h << this->hidden->yeig);
}
_kernel_swi(Wimp_OpenWindow, ®s, ®s);
break;
case 3: /* Close window */
if (message[0] == sdlWindow)
{
/* Documentation makes it looks as if the following line is correct:
** if (SDL_PrivateQuit() == 1) _kernel_swi(Wimp_CloseWindow, ®s, ®s);
** However some programs don't process this message and so sit there invisibly
** in the background so I just post the quit message and hope the application
** does the correct thing.
*/
SDL_PrivateQuit();
} else
sysEvent = 1;
doPoll = 0;
break;
case 4: /* Pointer_Leaving_Window */
if (message[0] == sdlWindow)
{
mouseInWindow = 0;
//TODO: Lose buttons / dragging
/* Reset to default pointer */
regs.r[0] = 106;
regs.r[1] = 1;
regs.r[2] = 0;
_kernel_swi(OS_Byte, ®s, ®s);
SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS);
} else
sysEvent = 1;
break;
case 5: /* Pointer_Entering_Window */
if (message[0] == sdlWindow)
{
mouseInWindow = 1;
WIMP_ReshowCursor(this);
SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS);
} else sysEvent = 1;
break;
case 6: /* Mouse_Click */
if (hasFocus == 0)
{
/* First click gives focus if it's not a menu */
/* we only count non-menu clicks on a window that has the focus */
WIMP_SetFocus(message[3]);
} else
doPoll = 0; // So PollMouse gets a chance to pick it up
break;
case 7: /* User_Drag_Box - Used for mouse release */
//TODO: May need to implement this in the future
sysEvent = 1;
break;
case 8: /* Keypressed */
doPoll = 0; /* PollKeyboard should pick it up */
if (message[0] != sdlWindow) sysEvent = 1;
/*TODO: May want to always pass F12 etc to the wimp
{
regs.r[0] = message[6];
_kernel_swi(Wimp_ProcessKey, ®s, ®s);
}
*/
break;
case 11: /* Lose Caret */
hasFocus = 0;
if (message[0] == sdlWindow) SDL_PrivateAppActive(0, SDL_APPINPUTFOCUS);
else sysEvent = 1;
break;
case 12: /* Gain Caret */
hasFocus = 1;
if (message[0] == sdlWindow) SDL_PrivateAppActive(1, SDL_APPINPUTFOCUS);
else sysEvent = 1;
break;
case 17:
case 18:
sysEvent = 1; /* All messages are passed on */
switch(message[4])
{
case 0: /* Quit Event */
/* No choice - have to quit */
SDL_Quit();
exit(0);
break;
case 8: /* Pre Quit */
SDL_PrivateQuit();
break;
case 0x400c1: /* Mode change */
WIMP_ModeChanged(this);
resizeOnOpen = 1;
break;
case 9: /* Palette changed */
WIMP_PaletteChanged(this);
break;
}
break;
default:
/* Pass unknown events on */
sysEvent = 1;
break;
}
if (sysEvent)
{
SDL_SysWMmsg wmmsg;
SDL_VERSION(&wmmsg.version);
wmmsg.eventCode = code;
memcpy(wmmsg.pollBlock, message, 64 * sizeof(int));
/* Fall out of polling loop if message is successfully posted */
if (SDL_PrivateSysWMEvent(&wmmsg)) doPoll = 0;
}
}
}
static int X11_DispatchEvent(_THIS)
{
int posted;
XEvent xevent;
XNextEvent(SDL_Display, &xevent);
posted = 0;
switch (xevent.type) {
/* Gaining mouse coverage? */
case EnterNotify: {
#ifdef DEBUG_XEVENTS
printf("EnterNotify! (%d,%d)\n", xevent.xcrossing.x, xevent.xcrossing.y);
if ( xevent.xcrossing.mode == NotifyGrab )
printf("Mode: NotifyGrab\n");
if ( xevent.xcrossing.mode == NotifyUngrab )
printf("Mode: NotifyUngrab\n");
#endif
if ( (xevent.xcrossing.mode != NotifyGrab) &&
(xevent.xcrossing.mode != NotifyUngrab) ) {
if ( this->input_grab == SDL_GRAB_OFF ) {
posted = SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS);
} else {
posted = SDL_PrivateMouseMotion(0, 0,
xevent.xcrossing.x,
xevent.xcrossing.y);
}
}
}
break;
/* Losing mouse coverage? */
case LeaveNotify: {
#ifdef DEBUG_XEVENTS
printf("LeaveNotify! (%d,%d)\n", xevent.xcrossing.x, xevent.xcrossing.y);
if ( xevent.xcrossing.mode == NotifyGrab )
printf("Mode: NotifyGrab\n");
if ( xevent.xcrossing.mode == NotifyUngrab )
printf("Mode: NotifyUngrab\n");
#endif
if ( (xevent.xcrossing.mode != NotifyGrab) &&
(xevent.xcrossing.mode != NotifyUngrab) &&
(xevent.xcrossing.detail != NotifyInferior) ) {
if ( this->input_grab == SDL_GRAB_OFF ) {
posted = SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS);
} else {
posted = SDL_PrivateMouseMotion(0, 0,
xevent.xcrossing.x,
xevent.xcrossing.y);
}
}
}
break;
/* Gaining input focus? */
case FocusIn: {
#ifdef DEBUG_XEVENTS
printf("FocusIn!\n");
#endif
posted = SDL_PrivateAppActive(1, SDL_APPINPUTFOCUS);
/* Queue entry into fullscreen mode */
switch_waiting = 0x01 | SDL_FULLSCREEN;
switch_time = SDL_GetTicks() + 1500;
}
break;
/* Losing input focus? */
case FocusOut: {
#ifdef DEBUG_XEVENTS
printf("FocusOut!\n");
#endif
posted = SDL_PrivateAppActive(0, SDL_APPINPUTFOCUS);
/* Queue leaving fullscreen mode */
switch_waiting = 0x01;
switch_time = SDL_GetTicks() + 200;
}
break;
/* Generated upon EnterWindow and FocusIn */
case KeymapNotify: {
#ifdef DEBUG_XEVENTS
printf("KeymapNotify!\n");
#endif
X11_SetKeyboardState(SDL_Display, xevent.xkeymap.key_vector);
}
break;
/* Mouse motion? */
case MotionNotify: {
if ( SDL_VideoSurface ) {
if ( mouse_relative ) {
if ( using_dga & DGA_MOUSE ) {
#ifdef DEBUG_MOTION
printf("DGA motion: %d,%d\n", xevent.xmotion.x_root, xevent.xmotion.y_root);
#endif
posted = SDL_PrivateMouseMotion(0, 1,
xevent.xmotion.x_root,
xevent.xmotion.y_root);
} else {
posted = X11_WarpedMotion(this,&xevent);
}
} else {
#ifdef DEBUG_MOTION
printf("X11 motion: %d,%d\n", xevent.xmotion.x, xevent.xmotion.y);
#endif
posted = SDL_PrivateMouseMotion(0, 0,
xevent.xmotion.x,
xevent.xmotion.y);
}
}
}
break;
/* Mouse button press? */
case ButtonPress: {
posted = SDL_PrivateMouseButton(SDL_PRESSED,
xevent.xbutton.button, 0, 0);
}
break;
/* Mouse button release? */
case ButtonRelease: {
posted = SDL_PrivateMouseButton(SDL_RELEASED,
xevent.xbutton.button, 0, 0);
}
break;
/* Key press? */
case KeyPress: {
SDL_keysym keysym;
#ifdef DEBUG_XEVENTS
printf("KeyPress (X11 keycode = 0x%X)\n", xevent.xkey.keycode);
#endif
posted = SDL_PrivateKeyboard(SDL_PRESSED,
X11_TranslateKey(SDL_Display, &xevent.xkey,
xevent.xkey.keycode,
&keysym));
}
break;
/* Key release? */
case KeyRelease: {
SDL_keysym keysym;
#ifdef DEBUG_XEVENTS
printf("KeyRelease (X11 keycode = 0x%X)\n", xevent.xkey.keycode);
#endif
/* Check to see if this is a repeated key */
if ( ! X11_KeyRepeat(SDL_Display, &xevent) ) {
posted = SDL_PrivateKeyboard(SDL_RELEASED,
X11_TranslateKey(SDL_Display, &xevent.xkey,
xevent.xkey.keycode,
&keysym));
}
}
break;
/* Have we been iconified? */
case UnmapNotify: {
#ifdef DEBUG_XEVENTS
printf("UnmapNotify!\n");
#endif
/* If we're active, make ourselves inactive */
if ( SDL_GetAppState() & SDL_APPACTIVE ) {
/* Swap out the gamma before we go inactive */
X11_SwapVidModeGamma(this);
/* Send an internal deactivate event */
posted = SDL_PrivateAppActive(0,
SDL_APPACTIVE|SDL_APPINPUTFOCUS);
}
}
break;
/* Have we been restored? */
case MapNotify: {
#ifdef DEBUG_XEVENTS
printf("MapNotify!\n");
#endif
/* If we're not active, make ourselves active */
if ( !(SDL_GetAppState() & SDL_APPACTIVE) ) {
/* Send an internal activate event */
posted = SDL_PrivateAppActive(1, SDL_APPACTIVE);
/* Now that we're active, swap the gamma back */
X11_SwapVidModeGamma(this);
}
if ( SDL_VideoSurface &&
(SDL_VideoSurface->flags & SDL_FULLSCREEN) ) {
X11_EnterFullScreen(this);
} else {
X11_GrabInputNoLock(this, this->input_grab);
}
X11_CheckMouseModeNoLock(this);
if ( SDL_VideoSurface ) {
X11_RefreshDisplay(this);
}
}
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
if ( SDL_VideoSurface ) {
if ((xevent.xconfigure.width != SDL_VideoSurface->w) ||
(xevent.xconfigure.height != SDL_VideoSurface->h)) {
/* FIXME: Find a better fix for the bug with KDE 1.2 */
if ( ! ((xevent.xconfigure.width == 32) &&
(xevent.xconfigure.height == 32)) ) {
SDL_PrivateResize(xevent.xconfigure.width,
xevent.xconfigure.height);
}
} else {
/* OpenGL windows need to know about the change */
if ( SDL_VideoSurface->flags & (SDL_OPENGL | SDL_OPENGLES) ) {
SDL_PrivateExpose();
}
}
}
}
break;
/* Have we been requested to quit (or another client message?) */
case ClientMessage: {
if ( (xevent.xclient.format == 32) &&
(xevent.xclient.data.l[0] == WM_DELETE_WINDOW) )
{
posted = SDL_PrivateQuit();
} else
if ( SDL_ProcessEvents[SDL_SYSWMEVENT] == SDL_ENABLE ) {
SDL_SysWMmsg wmmsg;
SDL_VERSION(&wmmsg.version);
wmmsg.subsystem = SDL_SYSWM_X11;
wmmsg.event.xevent = xevent;
posted = SDL_PrivateSysWMEvent(&wmmsg);
}
}
break;
/* Do we need to refresh ourselves? */
case Expose: {
#ifdef DEBUG_XEVENTS
printf("Expose (count = %d)\n", xevent.xexpose.count);
#endif
if ( SDL_VideoSurface && (xevent.xexpose.count == 0) ) {
X11_RefreshDisplay(this);
}
}
break;
default: {
#ifdef DEBUG_XEVENTS
printf("Unhandled event %d\n", xevent.type);
#endif
/* Only post the event if we're watching for it */
if ( SDL_ProcessEvents[SDL_SYSWMEVENT] == SDL_ENABLE ) {
SDL_SysWMmsg wmmsg;
SDL_VERSION(&wmmsg.version);
wmmsg.subsystem = SDL_SYSWM_X11;
wmmsg.event.xevent = xevent;
posted = SDL_PrivateSysWMEvent(&wmmsg);
}
}
break;
}
return(posted);
}
/* The main Win32 event handler */
LONG
DX5_HandleMessage(_THIS, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg) {
#ifdef WM_ACTIVATEAPP
case WM_ACTIVATEAPP: {
int i, active;
active = (wParam && (GetForegroundWindow() == hwnd));
if ( active ) {
for ( i=0; SDL_DIdev[i]; ++i ) {
IDirectInputDevice2_Acquire(
SDL_DIdev[i]);
}
} else {
for ( i=0; SDL_DIdev[i]; ++i ) {
IDirectInputDevice2_Unacquire(
SDL_DIdev[i]);
}
mouse_lost = 1;
}
}
break;
#endif /* WM_ACTIVATEAPP */
#ifdef WM_DISPLAYCHANGE
case WM_DISPLAYCHANGE: {
WORD BitsPerPixel;
WORD SizeX, SizeY;
/* Ack! The display changed size and/or depth! */
SizeX = LOWORD(lParam);
SizeY = HIWORD(lParam);
BitsPerPixel = wParam;
/* We cause this message when we go fullscreen */
}
break;
#endif /* WM_DISPLAYCHANGE */
/* The keyboard is handled via DirectInput */
case WM_SYSKEYUP:
case WM_SYSKEYDOWN:
case WM_KEYUP:
case WM_KEYDOWN: {
/* Ignore windows keyboard messages */;
}
return(0);
#if defined(SC_SCREENSAVE) || defined(SC_MONITORPOWER)
/* Don't allow screen savers or monitor power downs.
This is because they quietly clear DirectX surfaces.
It would be better to allow the application to
decide whether or not to blow these off, but the
semantics of SDL_PrivateSysWMEvent() don't allow
the application that choice.
*/
case WM_SYSCOMMAND: {
if ((wParam&0xFFF0)==SC_SCREENSAVE ||
(wParam&0xFFF0)==SC_MONITORPOWER)
return(0);
}
/* Fall through to default processing */
#endif /* SC_SCREENSAVE || SC_MONITORPOWER */
default: {
/* Only post the event if we're watching for it */
if ( SDL_ProcessEvents[SDL_SYSWMEVENT] == SDL_ENABLE ) {
SDL_SysWMmsg wmmsg;
SDL_VERSION(&wmmsg.version);
wmmsg.hwnd = hwnd;
wmmsg.msg = msg;
wmmsg.wParam = wParam;
wmmsg.lParam = lParam;
posted = SDL_PrivateSysWMEvent(&wmmsg);
/* DJM: If the user isn't watching for private
messages in her SDL event loop, then pass it
along to any win32 specific window proc.
*/
} else if (userWindowProc) {
return CallWindowProc(userWindowProc, hwnd, msg, wParam, lParam);
}
}
break;
}
return(DefWindowProc(hwnd, msg, wParam, lParam));
}
