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

    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"

/*
     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_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
}

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