/*

    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 mouse cursor shape definitions and positioning

*/

#include "SDL_mouse.h"

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

#include "SDL_riscosmouse_c.h"

#include "kernel.h"

#include "swis.h"

static WMcursor *current_cursor = NULL;

static WMcursor *defined_cursor = NULL;

extern int mouseInWindow;

/* Area to save cursor palette colours changed by SDL.

   Actual values will be read before we change to the SDL cursor */

static Uint8 wimp_cursor_palette[2][5] = {

  {1, 25, 255, 255, 255},

  {3, 25, 255, 255, 255}

};

static int cursor_palette_saved = 0;

void WIMP_SaveCursorPalette();

void WIMP_RestoreWimpCursor();

void WIMP_SetSDLCursorPalette();

void RISCOS_FreeWMCursor(_THIS, WMcursor *cursor)

{

    SDL_free(cursor->data);

	SDL_free(cursor);

}

WMcursor *RISCOS_CreateWMCursor(_THIS,

		Uint8 *data, Uint8 *mask, int w, int h, int hot_x, int hot_y)

{

	WMcursor *cursor;

	Uint8 *cursor_data;

	Uint8 *ptr;

	int i,j,k;

	int data_byte, mask_byte;

	/* Check to make sure the cursor size is okay */

	if ( (w > 32) || (h > 32) ) {

		SDL_SetError("Only with width and height <= 32 pixels are allowed");

		return(NULL);

	}

	/* Allocate the cursor */

	cursor = (WMcursor *)SDL_malloc(sizeof(*cursor));

	if ( cursor == NULL ) {

		SDL_SetError("Out of memory");

		return(NULL);

	}

	/* Note: SDL says width must be a multiple of 8 */

	cursor_data = SDL_malloc(w/4 * h);

	if (cursor_data == NULL)

	{

		SDL_free(cursor);

		SDL_SetError("Out of memory");

		return(NULL);

	}

	cursor->w = w;

	cursor->h = h;

	cursor->hot_x = hot_x;

	cursor->hot_y = hot_y;

	cursor->data = cursor_data;

/* Data / Mask Resulting pixel on screen 

   0 / 1 White 

   1 / 1 Black 

   0 / 0 Transparent 

   1 / 0 Inverted color if possible, black if not. 

*/

	ptr = cursor_data;

	for ( i=0; i<h; ++i )

	{

		for (j = 0; j < w/8; ++j)

		{

			data_byte = *data;

			mask_byte = *mask;

			*ptr++ = 0; /* Sets whole byte transparent */

			*ptr = 0;

			for (k = 0; k < 8; k++)

			{

				(*ptr) <<= 2;

				if (data_byte & 1) *ptr |= 3; /* Black or inverted */

				else if(mask_byte & 1) *ptr |= 1; /* White */

				if ((k&3) == 3) ptr--;

				data_byte >>= 1;

				mask_byte >>= 1;

			}

            ptr+=3;

		    data++;

		    mask++;

		}

	}

	return(cursor);

}

int RISCOS_ShowWMCursor(_THIS, WMcursor *cursor)

{

	current_cursor = cursor;

	if (cursor == NULL)

	{

		_kernel_osbyte(106,0,0);

		defined_cursor = NULL;

	} else

	{

        WMcursor *old_cursor = defined_cursor;

		if (cursor != defined_cursor)

		{

			Uint8 cursor_def[10];

			cursor_def[0] = 0;

			cursor_def[1] = 2; /* Use shape number 2 */

			cursor_def[2] = cursor->w/4; /* Width in bytes */

			cursor_def[3] = cursor->h; /* Height (h) in pixels */

			cursor_def[4] = cursor->hot_x; /* ActiveX in pixels from left */

			cursor_def[5] = cursor->hot_y; /* ActiveY in pixels from top */

			cursor_def[6] = ((int)(cursor->data) & 0xFF);       /* Least significant byte of pointer to data */

			cursor_def[7] = ((int)(cursor->data) >> 8) & 0xFF;  /* ... */

			cursor_def[8] = ((int)(cursor->data) >> 16) & 0xFF; /* ... */

			cursor_def[9] = ((int)(cursor->data) >> 24) & 0xFF; /* Most significant byte of pointer to data */

			if (_kernel_osword(21, (int *)cursor_def) != 0)

			{

				SDL_SetError("RISCOS couldn't create the cursor to show");

				return(0);

			}

			defined_cursor = cursor;

		}

        if (old_cursor == NULL)

        {

            /* First time or reshow in window, so save/setup palette */

            if (!cursor_palette_saved)

            {

                WIMP_SaveCursorPalette();

            }

            WIMP_SetSDLCursorPalette();

        }

        _kernel_osbyte(106, 2, 0);        

	}

	return(1);

}

void FULLSCREEN_WarpWMCursor(_THIS, Uint16 x, Uint16 y)

{

	Uint8 move_block[5];

	int eig_block[3];

	_kernel_swi_regs regs;

	int os_x, os_y;

	eig_block[0] = 4;  /* X eig factor */

	eig_block[1] = 5;  /* Y eig factor */

	eig_block[2] = -1;  /* End of list of variables to request */

    regs.r[0] = (int)eig_block;

    regs.r[1] = (int)eig_block;

    _kernel_swi(OS_ReadVduVariables, &regs, &regs);

	os_x = x << eig_block[0];

	os_y = y << eig_block[1];

	move_block[0] = 3; /* Move cursor */

	move_block[1] = os_x & 0xFF;

	move_block[2] = (os_x >> 8) & 0xFF;

	move_block[3] = os_y & 0xFF;

	move_block[4] = (os_y >> 8) & 0xFF;

	_kernel_osword(21, (int *)move_block);

	SDL_PrivateMouseMotion(0, 0, x, y);

}

/* Reshow cursor when mouse re-enters the window */

void WIMP_ReshowCursor(_THIS)

{

	defined_cursor = NULL;

    cursor_palette_saved = 0;

	RISCOS_ShowWMCursor(this, current_cursor);

}

void WIMP_WarpWMCursor(_THIS, Uint16 x, Uint16 y)

{

	_kernel_swi_regs regs;

	int window_state[9];

	char block[5];

	int osX, osY;

	window_state[0] = this->hidden->window_handle;

	regs.r[1] = (unsigned int)window_state;

	_kernel_swi(Wimp_GetWindowState, &regs, &regs);

	 osX = (x << this->hidden->xeig) + window_state[1];

	 osY = window_state[4] - (y << this->hidden->yeig);

	block[0] = 3;

	block[1] = osX & 0xFF;

	block[2] = (osX >> 8) & 0xFF;

	block[3] = osY & 0xFF;

	block[4] = (osY >> 8) & 0xFF;

	regs.r[0] = 21;

	regs.r[1] = (int)block;

	_kernel_swi(OS_Word, &regs, &regs);

	SDL_PrivateMouseMotion(0, 0, x, y);

}

int WIMP_ShowWMCursor(_THIS, WMcursor *cursor)

{

	if (mouseInWindow) return RISCOS_ShowWMCursor(this, cursor);

	else current_cursor = cursor;

	return 1;

}

SDL_GrabMode RISCOS_GrabInput(_THIS, SDL_GrabMode mode)

{

   /* In fullscreen mode we don't need to do anything */

   if (mode < SDL_GRAB_FULLSCREEN)

   {

      _kernel_swi_regs regs;

      unsigned char block[9];

      block[0] = 1; /* Define mouse cursor bounding block */

      if ( mode == SDL_GRAB_OFF )

      {

         /* Clip to whole screen */

         int r = (this->hidden->screen_width << this->hidden->xeig) - 1;

         int t = (this->hidden->screen_height << this->hidden->yeig) - 1;

	 block[1] = 0; block[2] = 0; /* Left*/

         block[3] = 0; block[4] = 0; /* Bottom */

         block[5] = r & 0xFF; block[6] = (r >> 8) & 0xFF; /* Right */

         block[7] = t & 0xFF; block[8] = (t >> 8) & 0xFF; /* Top */

      } else

      {

        /* Clip to window */

       	unsigned char window_state[36];

	*((int *)window_state) = this->hidden->window_handle;

	regs.r[1] = (unsigned int)window_state;

	_kernel_swi(Wimp_GetWindowState, &regs, &regs);

        block[1] = window_state[4];

        block[2] = window_state[5];

        block[3] = window_state[8];

        block[4] = window_state[9];

        block[5] = window_state[12];

        block[6] = window_state[13];

        block[7] = window_state[16];

        block[8] = window_state[17];

      }

      regs.r[0] = 21; /* OS word code */

      regs.r[1] = (int)block;

      _kernel_swi(OS_Word, &regs, &regs);

   }

   return mode;

}

/* Save mouse cursor palette to be restore when we are no longer

   defining a cursor */

void WIMP_SaveCursorPalette()

{

    _kernel_swi_regs regs;

    int colour;

    for (colour = 0; colour < 2; colour++)

    {

      regs.r[0] = (int)wimp_cursor_palette[colour][0];

      regs.r[1] = 25;

      /* Read settings with OS_ReadPalette */

      if (_kernel_swi(0x2f, &regs, &regs) == NULL)

      {

        wimp_cursor_palette[colour][2] = (unsigned char)((regs.r[2] >> 8) & 0xFF);

        wimp_cursor_palette[colour][3] = (unsigned char)((regs.r[2] >> 16) & 0xFF);

        wimp_cursor_palette[colour][4] = (unsigned char)((regs.r[2] >> 24) & 0xFF);

      }

    }

    cursor_palette_saved = 1;

}

/* Restore the WIMP's cursor when we leave the SDL window */

void WIMP_RestoreWimpCursor()

{

    int colour;

    /* Reset to pointer shape 1 */

    _kernel_osbyte(106, 1, 0);

    /* Reset pointer colours */

    if (cursor_palette_saved)

    {

      for (colour = 0; colour < 2; colour++)

      {

        _kernel_osword(12, (int *)wimp_cursor_palette[colour]);

      }

    }

    cursor_palette_saved = 0;

}

/* Set palette used for SDL mouse cursors */

void WIMP_SetSDLCursorPalette()

{

  /* First time set up the mouse colours */

  Uint8 block[5];

  /* Set up colour 1 as white */

  block[0] = 1;   /* Colour to change 1 - 3 */

  block[1] = 25;  /* Set pointer colour */

  block[2] = 255; /* red component*/

  block[3] = 255; /* green component */

  block[4] = 255; /* blue component*/

 _kernel_osword(12, (int *)block);

 /* Set colour 3 to back */

 block[0] = 3;   /* Colour to change 1 - 3 */

 block[1] = 25;  /* Set pointer colour*/

 block[2] = 0; /* red component*/

 block[3] = 0; /* green component */

 block[4] = 0; /* blue component*/

 _kernel_osword(12, (int *)block);

}