/*

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

*/

/*

File added by Alan Buckley (alan_baa@hotmail.com) for RISC OS compatability

27 March 2003

Implements mouse cursor shape definitions and positioning

*/

#include <stdio.h>

#include <stdlib.h>

#include "SDL_error.h"

#include "SDL_mouse.h"

#include "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)

{

free(cursor->data);

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 *)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 = malloc(w/4 * h);

if (cursor_data == NULL)

{

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);

}