xref: /external/qemu/distrib/sdl-1.2.12/src/video/riscos/SDL_wimppoll.c

/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997-2004 Sam Lantinga

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 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
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    Sam Lantinga
    slouken@libsdl.org
*/
#include "SDL_config.h"

/*
     File added by Alan Buckley (alan_baa@hotmail.com) for RISC OS compatability
	 27 March 2003

     Implements Pumping of events and WIMP polling
*/

#include "SDL.h"
#include "SDL_syswm.h"
#include "../../events/SDL_sysevents.h"
#include "../../events/SDL_events_c.h"
#include "SDL_riscosvideo.h"
#include "SDL_riscosevents_c.h"
#include "SDL_riscosmouse_c.h"
#include "../../timer/SDL_timer_c.h"

#include "memory.h"
#include "stdlib.h"
#include "ctype.h"

#include "kernel.h"
#include "swis.h"
#include "unixlib/os.h"

#if !SDL_THREADS_DISABLED
#include <pthread.h>
#endif

/* Local functions */
void WIMP_Poll(_THIS, int waitTime);
void WIMP_SetFocus(int win);

/* SDL_riscossprite functions */
void WIMP_PlotSprite(_THIS, int x, int y);
void WIMP_ModeChanged(_THIS);
void WIMP_PaletteChanged(_THIS);


extern void WIMP_PollMouse(_THIS);
extern void RISCOS_PollKeyboard();

#if SDL_THREADS_DISABLED
/* Timer running function */
extern void RISCOS_CheckTimer();
#else
extern int riscos_using_threads;
#endif

/* Mouse cursor handling */
extern void WIMP_ReshowCursor(_THIS);
extern void WIMP_RestoreWimpCursor();

int hasFocus = 0;
int mouseInWindow = 0;

/* Flag to ensure window is correct size after a mode change */
static int resizeOnOpen = 0;

void WIMP_PumpEvents(_THIS)
{
	WIMP_Poll(this, 0);
	if (hasFocus) RISCOS_PollKeyboard();
	if (mouseInWindow) WIMP_PollMouse(this);
#if SDL_THREADS_DISABLED
	if (SDL_timer_running) RISCOS_CheckTimer();
#endif
}


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, &regs, &regs);
		waitTime += regs.r[0];
    }

    while (doPoll)
    {
#if !SDL_THREADS_DISABLED
       /* Stop thread callbacks while program is paged out */
       if (riscos_using_threads) __pthread_stop_ticker();
#endif

        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, &regs, &regs);
        } else
        {
        	regs.r[0] = pollMask;
        	regs.r[1] = (int)message;
        	regs.r[2] = waitTime;
        	_kernel_swi(Wimp_PollIdle, &regs, &regs);
        }

		/* 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, &regs,&regs);
	   if (message[0] == sdlWindow)
	   {
                 while (regs.r[0])
                 {
           	    WIMP_PlotSprite(this, message[1], message[2]);
           	    _kernel_swi(Wimp_GetRectangle, &regs, &regs);
                 }
	   } else
	  {
	/* TODO: Currently we just eat them - we may need to pass them on */
        	while (regs.r[0])
        	{
                        _kernel_swi(Wimp_GetRectangle, &regs, &regs);
        	}
	  }
          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, &regs, &regs);
       	    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, &regs, &regs);
				** 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 */
				 WIMP_RestoreWimpCursor();
				 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, &regs, &regs);
			}
			*/
			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;
			SDL_memcpy(wmmsg.pollBlock, message, 64 * sizeof(int));

			/* Fall out of polling loop if message is successfully posted */
			if (SDL_PrivateSysWMEvent(&wmmsg)) doPoll = 0;
		}
#if !SDL_THREADS_DISABLED
		if (riscos_using_threads)
		{
                   /* Restart ticker here so other thread can not interfere
                      with the Redraw processing */
		   if (riscos_using_threads) __pthread_start_ticker();
                   /* Give other threads a better chance of running */
		   pthread_yield();
		}
#endif
    }
}

/* Set focus to specified window */
void WIMP_SetFocus(int win)
{
	_kernel_swi_regs regs;

	regs.r[0] = win;
	regs.r[1] = -1; /* Icon handle */
	regs.r[2] = 0;  /* X-offset we just put it at position 0 */
	regs.r[3] = 0;  /* Y-offset as above */
	regs.r[4] = 1 << 25; /* Caret is invisible */
	regs.r[5] = 0;  /* index into string */

	_kernel_swi(Wimp_SetCaretPosition, &regs, &regs);
}

/** Run background task while in a sleep command */
void RISCOS_BackgroundTasks(void)
{
	if (current_video && current_video->hidden->window_handle)
	{
		WIMP_Poll(current_video, 0);
	}
#if SDL_THREADS_DISABLED
	if (SDL_timer_running) RISCOS_CheckTimer();
#endif
}