--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/symbian-qemu-0.9.1-12/libsdl-trunk/src/video/riscos/SDL_riscosFullScreenVideo.c Fri Jul 31 15:01:17 2009 +0100
@@ -0,0 +1,777 @@
+/*
+ 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 RISC OS full screen display.
+*/
+
+#include "SDL_video.h"
+#include "SDL_mouse.h"
+#include "../SDL_sysvideo.h"
+#include "../SDL_pixels_c.h"
+#include "../../events/SDL_events_c.h"
+
+#include "SDL_riscostask.h"
+#include "SDL_riscosvideo.h"
+#include "SDL_riscosevents_c.h"
+#include "SDL_riscosmouse_c.h"
+
+#include "kernel.h"
+#include "swis.h"
+#include "unixlib/os.h"
+#include "unixlib/local.h"
+
+/* Private structures */
+typedef struct tagScreenModeBlock
+{
+ int flags; // mode selector flags, bit 0 = 1, bit 1-7 format specifier, 8-31 reserved
+ int x_pixels;
+ int y_pixels;
+ int pixel_depth; // 2^pixel_depth = bpp,i.e. 0 = 1, 1 = 2, 4 = 16, 5 = 32
+ int frame_rate; // -1 use first match
+ int mode_vars[5]; // array of index, value pairs terminated by -1
+} SCREENMODEBLOCK;
+
+
+/* Helper functions */
+void FULLSCREEN_SetDeviceMode(_THIS);
+int FULLSCREEN_SetMode(int width, int height, int bpp);
+void FULLSCREEN_SetupBanks(_THIS);
+
+/* SDL video device functions for fullscreen mode */
+static int FULLSCREEN_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors);
+static int FULLSCREEN_FlipHWSurface(_THIS, SDL_Surface *surface);
+void FULLSCREEN_SetWMCaption(_THIS, const char *title, const char *icon);
+extern int RISCOS_GetWmInfo(_THIS, SDL_SysWMinfo *info);
+
+/* UpdateRects variants */
+static void FULLSCREEN_UpdateRects(_THIS, int numrects, SDL_Rect *rects);
+static void FULLSCREEN_UpdateRectsMemCpy(_THIS, int numrects, SDL_Rect *rects);
+static void FULLSCREEN_UpdateRects8bpp(_THIS, int numrects, SDL_Rect *rects);
+static void FULLSCREEN_UpdateRects16bpp(_THIS, int numrects, SDL_Rect *rects);
+static void FULLSCREEN_UpdateRects32bpp(_THIS, int numrects, SDL_Rect *rects);
+static void FULLSCREEN_UpdateRectsOS(_THIS, int numrects, SDL_Rect *rects);
+
+/* Local helper functions */
+static int cmpmodes(const void *va, const void *vb);
+static int FULLSCREEN_AddMode(_THIS, int bpp, int w, int h);
+void FULLSCREEN_SetWriteBank(int bank);
+void FULLSCREEN_SetDisplayBank(int bank);
+static void FULLSCREEN_DisableEscape();
+static void FULLSCREEN_EnableEscape();
+void FULLSCREEN_BuildModeList(_THIS);
+
+/* Following variable is set up in riskosTask.c */
+extern int riscos_backbuffer; /* Create a back buffer in system memory for full screen mode */
+
+/* Following is used to create a sprite back buffer */
+extern unsigned char *WIMP_CreateBuffer(int width, int height, int bpp);
+
+/* Fast assembler copy */
+extern void RISCOS_Put32(void *to, int pixels, int pitch, int rows, void *from, int src_skip_bytes);
+
+SDL_Surface *FULLSCREEN_SetVideoMode(_THIS, SDL_Surface *current,
+ int width, int height, int bpp, Uint32 flags)
+{
+ _kernel_swi_regs regs;
+ Uint32 Rmask = 0;
+ Uint32 Gmask = 0;
+ Uint32 Bmask = 0;
+ int create_back_buffer = riscos_backbuffer;
+
+ switch(bpp)
+ {
+ case 8:
+ flags |= SDL_HWPALETTE;
+ break;
+
+ case 15:
+ case 16:
+ Bmask = 0x00007c00;
+ Gmask = 0x000003e0;
+ Rmask = 0x0000001f;
+ break;
+
+ case 32:
+ Bmask = 0x00ff0000;
+ Gmask = 0x0000ff00;
+ Rmask = 0x000000ff;
+ break;
+
+ default:
+ SDL_SetError("Pixel depth not supported");
+ return NULL;
+ break;
+ }
+
+ if (FULLSCREEN_SetMode(width, height, bpp) == 0)
+ {
+ SDL_SetError("Couldn't set requested mode");
+ return (NULL);
+ }
+
+/* printf("Setting mode %dx%d\n", width, height); */
+
+ /* Allocate the new pixel format for the screen */
+ if ( ! SDL_ReallocFormat(current, bpp, Rmask, Gmask, Bmask, 0) ) {
+ RISCOS_RestoreWimpMode();
+ SDL_SetError("Couldn't allocate new pixel format for requested mode");
+ return(NULL);
+ }
+
+ /* Set up the new mode framebuffer */
+ current->w = width;
+ this->hidden->height = current->h = height;
+
+ regs.r[0] = -1; /* -1 for current screen mode */
+
+ /* Get screen width in bytes */
+ regs.r[1] = 6; // Screen Width in bytes
+ _kernel_swi(OS_ReadModeVariable, ®s, ®s);
+
+ current->pitch = regs.r[2];
+
+ if (flags & SDL_DOUBLEBUF)
+ {
+ regs.r[0] = 2; /* Screen area */
+ _kernel_swi(OS_ReadDynamicArea, ®s, ®s);
+
+ /* Reg 1 has amount of memory currently used for display */
+ regs.r[0] = 2; /* Screen area */
+ regs.r[1] = (current->pitch * height * 2) - regs.r[1];
+ if (_kernel_swi(OS_ChangeDynamicArea, ®s, ®s) != NULL)
+ {
+ /* Can't allocate enough screen memory for double buffer */
+ flags &= ~SDL_DOUBLEBUF;
+ }
+ }
+
+ current->flags = flags | SDL_FULLSCREEN | SDL_HWSURFACE | SDL_PREALLOC;
+
+
+ /* Need to set display banks here for double buffering */
+ if (flags & SDL_DOUBLEBUF)
+ {
+ FULLSCREEN_SetWriteBank(0);
+ FULLSCREEN_SetDisplayBank(1);
+
+ create_back_buffer = 0; /* Don't need a back buffer for a double buffered display */
+ }
+
+ FULLSCREEN_SetupBanks(this);
+
+ if (create_back_buffer)
+ {
+ /* If not double buffered we may need to create a memory
+ ** back buffer to simulate processing on other OSes.
+ ** This is turned on by setting the enviromental variable
+ ** SDL$<name>$BackBuffer >= 1
+ */
+ if (riscos_backbuffer == 3)
+ this->hidden->bank[0] = WIMP_CreateBuffer(width, height, bpp);
+ else
+ this->hidden->bank[0] = SDL_malloc(height * current->pitch);
+ if (this->hidden->bank[0] == 0)
+ {
+ RISCOS_RestoreWimpMode();
+ SDL_SetError("Couldnt allocate memory for back buffer");
+ return (NULL);
+ }
+ /* Surface updated in programs is now a software surface */
+ current->flags &= ~SDL_HWSURFACE;
+ }
+
+ /* Store address of allocated screen bank to be freed later */
+ if (this->hidden->alloc_bank) SDL_free(this->hidden->alloc_bank);
+ if (create_back_buffer)
+ {
+ this->hidden->alloc_bank = this->hidden->bank[0];
+ if (riscos_backbuffer == 3)
+ {
+ this->hidden->bank[0] += 60; /* Start of sprite data */
+ if (bpp == 8) this->hidden->bank[0] += 2048; /* 8bpp sprite have palette first */
+ }
+ } else
+ this->hidden->alloc_bank = 0;
+
+ // Clear both banks to black
+ SDL_memset(this->hidden->bank[0], 0, height * current->pitch);
+ SDL_memset(this->hidden->bank[1], 0, height * current->pitch);
+
+ this->hidden->current_bank = 0;
+ current->pixels = this->hidden->bank[0];
+
+ /* Have to set the screen here, so SetDeviceMode will pick it up */
+ this->screen = current;
+
+ /* Reset device functions for the wimp */
+ FULLSCREEN_SetDeviceMode(this);
+
+/* FULLSCREEN_DisableEscape(); */
+
+ /* We're done */
+ return(current);
+}
+
+/* Reset any device functions that have been changed because we have run in WIMP mode */
+void FULLSCREEN_SetDeviceMode(_THIS)
+{
+ /* Update rects is different if we have a backbuffer */
+
+ if (riscos_backbuffer && (this->screen->flags & SDL_DOUBLEBUF) == 0)
+ {
+ switch(riscos_backbuffer)
+ {
+ case 2: /* ARM code full word copy */
+ switch(this->screen->format->BytesPerPixel)
+ {
+ case 1: /* 8bpp modes */
+ this->UpdateRects = FULLSCREEN_UpdateRects8bpp;
+ break;
+ case 2: /* 15/16bpp modes */
+ this->UpdateRects = FULLSCREEN_UpdateRects16bpp;
+ break;
+ case 4: /* 32 bpp modes */
+ this->UpdateRects = FULLSCREEN_UpdateRects32bpp;
+ break;
+
+ default: /* Just default to the memcpy routine */
+ this->UpdateRects = FULLSCREEN_UpdateRectsMemCpy;
+ break;
+ }
+ break;
+
+ case 3: /* Use OS sprite plot routine */
+ this->UpdateRects = FULLSCREEN_UpdateRectsOS;
+ break;
+
+ default: /* Old but safe memcpy */
+ this->UpdateRects = FULLSCREEN_UpdateRectsMemCpy;
+ break;
+ }
+ } else
+ this->UpdateRects = FULLSCREEN_UpdateRects; /* Default do nothing implementation */
+
+ this->SetColors = FULLSCREEN_SetColors;
+
+ this->FlipHWSurface = FULLSCREEN_FlipHWSurface;
+
+ this->SetCaption = FULLSCREEN_SetWMCaption;
+ this->SetIcon = NULL;
+ this->IconifyWindow = NULL;
+
+ this->ShowWMCursor = RISCOS_ShowWMCursor;
+ this->WarpWMCursor = FULLSCREEN_WarpWMCursor;
+
+ this->PumpEvents = FULLSCREEN_PumpEvents;
+}
+
+/* Query for the list of available video modes */
+void FULLSCREEN_BuildModeList(_THIS)
+{
+ _kernel_swi_regs regs;
+ char *enumInfo = NULL;
+ char *enum_ptr;
+ int *blockInfo;
+ int j;
+ int num_modes;
+
+ /* Find out how much space we need */
+ regs.r[0] = 2; /* Reason code */
+ regs.r[2] = 0; /* Number of modes to skip */
+ regs.r[6] = 0; /* pointer to block or 0 for count */
+ regs.r[7] = 0; /* Size of block in bytes */
+ _kernel_swi(OS_ScreenMode, ®s, ®s);
+
+ num_modes = -regs.r[2];
+
+ /* Video memory should be in r[5] */
+ this->info.video_mem = regs.r[5]/1024;
+
+ enumInfo = (unsigned char *)SDL_malloc(-regs.r[7]);
+ if (enumInfo == NULL)
+ {
+ SDL_OutOfMemory();
+ return;
+ }
+ /* Read mode information into block */
+ regs.r[2] = 0;
+ regs.r[6] = (int)enumInfo;
+ regs.r[7] = -regs.r[7];
+ _kernel_swi(OS_ScreenMode, ®s, ®s);
+
+ enum_ptr = enumInfo;
+
+ for (j =0; j < num_modes;j++)
+ {
+ blockInfo = (int *)enum_ptr;
+ if ((blockInfo[1] & 255) == 1) /* We understand this format */
+ {
+ switch(blockInfo[4])
+ {
+ case 3: /* 8 bits per pixel */
+ FULLSCREEN_AddMode(this, 8, blockInfo[2], blockInfo[3]);
+ break;
+ case 4: /* 15 bits per pixel */
+ FULLSCREEN_AddMode(this, 15, blockInfo[2], blockInfo[3]);
+ break;
+ case 5: /* 32 bits per pixel */
+ FULLSCREEN_AddMode(this, 32, blockInfo[2], blockInfo[3]);
+ break;
+ }
+ }
+
+ enum_ptr += blockInfo[0];
+ }
+
+ SDL_free(enumInfo);
+
+ /* Sort the mode lists */
+ for ( j=0; j<NUM_MODELISTS; ++j ) {
+ if ( SDL_nummodes[j] > 0 ) {
+ SDL_qsort(SDL_modelist[j], SDL_nummodes[j], sizeof *SDL_modelist[j], cmpmodes);
+ }
+ }
+}
+
+static int FULLSCREEN_FlipHWSurface(_THIS, SDL_Surface *surface)
+{
+ _kernel_swi_regs regs;
+ regs.r[0] = 19;
+
+ FULLSCREEN_SetDisplayBank(this->hidden->current_bank);
+ this->hidden->current_bank ^= 1;
+ FULLSCREEN_SetWriteBank(this->hidden->current_bank);
+ surface->pixels = this->hidden->bank[this->hidden->current_bank];
+
+ /* Wait for Vsync */
+ _kernel_swi(OS_Byte, ®s, ®s);
+
+ return(0);
+}
+
+/* Nothing to do if we are writing direct to hardware */
+static void FULLSCREEN_UpdateRects(_THIS, int numrects, SDL_Rect *rects)
+{
+}
+
+/* Safe but slower Memory copy from our allocated back buffer */
+static void FULLSCREEN_UpdateRectsMemCpy(_THIS, int numrects, SDL_Rect *rects)
+{
+ int j;
+ char *to, *from;
+ int pitch = this->screen->pitch;
+ int row;
+ int xmult = this->screen->format->BytesPerPixel;
+ for (j = 0; j < numrects; j++)
+ {
+ from = this->hidden->bank[0] + rects->x * xmult + rects->y * pitch;
+ to = this->hidden->bank[1] + rects->x * xmult + rects->y * pitch;
+ for (row = 0; row < rects->h; row++)
+ {
+ SDL_memcpy(to, from, rects->w * xmult);
+ from += pitch;
+ to += pitch;
+ }
+ rects++;
+ }
+}
+
+/* Use optimized assembler memory copy. Deliberately copies extra columns if
+ necessary to ensure the rectangle is word aligned. */
+static void FULLSCREEN_UpdateRects8bpp(_THIS, int numrects, SDL_Rect *rects)
+{
+ int j;
+ char *to, *from;
+ int pitch = this->screen->pitch;
+ int width_bytes;
+ int src_skip_bytes;
+
+ for (j = 0; j < numrects; j++)
+ {
+ from = this->hidden->bank[0] + rects->x + rects->y * pitch;
+ to = this->hidden->bank[1] + rects->x + rects->y * pitch;
+ width_bytes = rects->w;
+ if ((int)from & 3)
+ {
+ int extra = ((int)from & 3);
+ from -= extra;
+ to -= extra;
+ width_bytes += extra;
+ }
+ if (width_bytes & 3) width_bytes += 4 - (width_bytes & 3);
+ src_skip_bytes = pitch - width_bytes;
+
+ RISCOS_Put32(to, (width_bytes >> 2), pitch, (int)rects->h, from, src_skip_bytes);
+ rects++;
+ }
+}
+
+/* Use optimized assembler memory copy. Deliberately copies extra columns if
+ necessary to ensure the rectangle is word aligned. */
+static void FULLSCREEN_UpdateRects16bpp(_THIS, int numrects, SDL_Rect *rects)
+{
+ int j;
+ char *to, *from;
+ int pitch = this->screen->pitch;
+ int width_bytes;
+ int src_skip_bytes;
+
+ for (j = 0; j < numrects; j++)
+ {
+ from = this->hidden->bank[0] + (rects->x << 1) + rects->y * pitch;
+ to = this->hidden->bank[1] + (rects->x << 1) + rects->y * pitch;
+ width_bytes = (((int)rects->w) << 1);
+ if ((int)from & 3)
+ {
+ from -= 2;
+ to -= 2;
+ width_bytes += 2;
+ }
+ if (width_bytes & 3) width_bytes += 2;
+ src_skip_bytes = pitch - width_bytes;
+
+ RISCOS_Put32(to, (width_bytes >> 2), pitch, (int)rects->h, from, src_skip_bytes);
+ rects++;
+ }
+}
+
+/* Use optimized assembler memory copy. 32 bpp modes are always word aligned */
+static void FULLSCREEN_UpdateRects32bpp(_THIS, int numrects, SDL_Rect *rects)
+{
+ int j;
+ char *to, *from;
+ int pitch = this->screen->pitch;
+ int width;
+
+ for (j = 0; j < numrects; j++)
+ {
+ from = this->hidden->bank[0] + (rects->x << 2) + rects->y * pitch;
+ to = this->hidden->bank[1] + (rects->x << 2) + rects->y * pitch;
+ width = (int)rects->w ;
+
+ RISCOS_Put32(to, width, pitch, (int)rects->h, from, pitch - (width << 2));
+ rects++;
+ }
+}
+
+/* Use operating system sprite plots. Currently this is much slower than the
+ other variants however accelerated sprite plotting can be seen on the horizon
+ so this prepares for it. */
+static void FULLSCREEN_UpdateRectsOS(_THIS, int numrects, SDL_Rect *rects)
+{
+ _kernel_swi_regs regs;
+ _kernel_oserror *err;
+ int j;
+ int y;
+
+ regs.r[0] = 28 + 512;
+ regs.r[1] = (unsigned int)this->hidden->alloc_bank;
+ regs.r[2] = (unsigned int)this->hidden->alloc_bank+16;
+ regs.r[5] = 0;
+
+ for (j = 0; j < numrects; j++)
+ {
+ y = this->screen->h - rects->y; /* top of clipping region */
+ _kernel_oswrch(24); /* Set graphics clip region */
+ _kernel_oswrch((rects->x << this->hidden->xeig) & 0xFF); /* left */
+ _kernel_oswrch(((rects->x << this->hidden->xeig) >> 8) & 0xFF);
+ _kernel_oswrch(((y - rects->h) << this->hidden->yeig) & 0xFF); /* bottom */
+ _kernel_oswrch((((y - rects->h) << this->hidden->yeig)>> 8) & 0xFF);
+ _kernel_oswrch(((rects->x + rects->w - 1) << this->hidden->xeig) & 0xFF); /* right */
+ _kernel_oswrch((((rects->x + rects->w - 1)<< this->hidden->xeig) >> 8) & 0xFF);
+ _kernel_oswrch(((y-1) << this->hidden->yeig) & 0xFF); /* top */
+ _kernel_oswrch((((y-1) << this->hidden->yeig) >> 8) & 0xFF);
+
+ regs.r[3] = 0;
+ regs.r[4] = 0;
+
+ if ((err = _kernel_swi(OS_SpriteOp, ®s, ®s)) != 0)
+ {
+ printf("OS_SpriteOp failed \n%s\n",err->errmess);
+ }
+
+ rects++;
+
+ /* Reset to full screen clipping */
+ _kernel_oswrch(24); /* Set graphics clip region */
+ _kernel_oswrch(0); /* left */
+ _kernel_oswrch(0);
+ _kernel_oswrch(0); /* bottom */
+ _kernel_oswrch(0);
+ _kernel_oswrch(((this->screen->w-1) << this->hidden->xeig) & 0xFF); /* right */
+ _kernel_oswrch((((this->screen->w-1) << this->hidden->xeig) >> 8) & 0xFF);
+ _kernel_oswrch(((this->screen->h-1) << this->hidden->yeig) & 0xFF); /* top */
+ _kernel_oswrch((((this->screen->h-1) << this->hidden->yeig) >> 8) & 0xFF);
+ }
+}
+
+
+int FULLSCREEN_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
+{
+ _kernel_swi_regs regs;
+ int palette[256];
+
+ regs.r[0] = -1;
+ regs.r[1] = -1;
+ regs.r[2] = (int)palette;
+ regs.r[3] = 1024;
+ regs.r[4] = 0;
+ _kernel_swi(ColourTrans_ReadPalette, ®s, ®s);
+
+ while(ncolors--)
+ {
+ palette[firstcolor] = ((colors->b) << 24) | ((colors->g) << 16) | ((colors->r) << 8);
+ firstcolor++;
+ colors++;
+ }
+
+ regs.r[0] = -1;
+ regs.r[1] = -1;
+ regs.r[2] = (int)palette;
+ regs.r[3] = 0;
+ regs.r[4] = 0;
+ _kernel_swi(ColourTrans_WritePalette, ®s, ®s);
+
+ return(1);
+}
+
+
+static int cmpmodes(const void *va, const void *vb)
+{
+ SDL_Rect *a = *(SDL_Rect **)va;
+ SDL_Rect *b = *(SDL_Rect **)vb;
+ if(a->w == b->w)
+ return b->h - a->h;
+ else
+ return b->w - a->w;
+}
+
+static int FULLSCREEN_AddMode(_THIS, int bpp, int w, int h)
+{
+ SDL_Rect *mode;
+ int i, index;
+ int next_mode;
+
+ /* Check to see if we already have this mode */
+ if ( bpp < 8 ) { /* Not supported */
+ return(0);
+ }
+ index = ((bpp+7)/8)-1;
+ for ( i=0; i<SDL_nummodes[index]; ++i ) {
+ mode = SDL_modelist[index][i];
+ if ( (mode->w == w) && (mode->h == h) ) {
+ return(0);
+ }
+ }
+
+ /* Set up the new video mode rectangle */
+ mode = (SDL_Rect *)SDL_malloc(sizeof *mode);
+ if ( mode == NULL ) {
+ SDL_OutOfMemory();
+ return(-1);
+ }
+ mode->x = 0;
+ mode->y = 0;
+ mode->w = w;
+ mode->h = h;
+
+ /* Allocate the new list of modes, and fill in the new mode */
+ next_mode = SDL_nummodes[index];
+ SDL_modelist[index] = (SDL_Rect **)
+ SDL_realloc(SDL_modelist[index], (1+next_mode+1)*sizeof(SDL_Rect *));
+ if ( SDL_modelist[index] == NULL ) {
+ SDL_OutOfMemory();
+ SDL_nummodes[index] = 0;
+ SDL_free(mode);
+ return(-1);
+ }
+ SDL_modelist[index][next_mode] = mode;
+ SDL_modelist[index][next_mode+1] = NULL;
+ SDL_nummodes[index]++;
+
+ return(0);
+}
+
+void FULLSCREEN_SetWriteBank(int bank)
+{
+ _kernel_swi_regs regs;
+ regs.r[0] = 112;
+ regs.r[1] = bank+1;
+ _kernel_swi(OS_Byte, ®s, ®s);
+}
+
+void FULLSCREEN_SetDisplayBank(int bank)
+{
+ _kernel_swi_regs regs;
+ regs.r[0] = 113;
+ regs.r[1] = bank+1;
+ _kernel_swi(OS_Byte, ®s, ®s);
+}
+
+
+/** Disable special escape key processing */
+static void FULLSCREEN_DisableEscape()
+{
+ _kernel_swi_regs regs;
+ regs.r[0] = 229;
+ regs.r[1] = 1;
+ regs.r[2] = 0;
+ _kernel_swi(OS_Byte, ®s, ®s);
+
+}
+
+/** Enable special escape key processing */
+static void FULLSCREEN_EnableEscape()
+{
+ _kernel_swi_regs regs;
+ regs.r[0] = 229;
+ regs.r[1] = 0;
+ regs.r[2] = 0;
+ _kernel_swi(OS_Byte, ®s, ®s);
+
+}
+
+/** Store caption in case this is called before we create a window */
+void FULLSCREEN_SetWMCaption(_THIS, const char *title, const char *icon)
+{
+ SDL_strlcpy(this->hidden->title, title, SDL_arraysize(this->hidden->title));
+}
+
+/* Set screen mode
+*
+* Returns 1 if mode is set ok, otherwise 0
+*/
+
+int FULLSCREEN_SetMode(int width, int height, int bpp)
+{
+ SCREENMODEBLOCK smb;
+ _kernel_swi_regs regs;
+
+ smb.flags = 1;
+ smb.x_pixels = width;
+ smb.y_pixels = height;
+ smb.mode_vars[0] = -1;
+
+ switch(bpp)
+ {
+ case 8:
+ smb.pixel_depth = 3;
+ /* Note: Need to set ModeFlags to 128 and NColour variables to 255 get full 8 bit palette */
+ smb.mode_vars[0] = 0; smb.mode_vars[1] = 128; /* Mode flags */
+ smb.mode_vars[2] = 3; smb.mode_vars[3] = 255; /* NColour (number of colours -1) */
+ smb.mode_vars[4] = -1; /* End of list */
+ break;
+
+ case 15:
+ case 16:
+ smb.pixel_depth = 4;
+ break;
+
+ case 32:
+ smb.pixel_depth = 5;
+ break;
+
+ default:
+ SDL_SetError("Pixel depth not supported");
+ return 0;
+ break;
+ }
+
+ smb.frame_rate = -1;
+
+ regs.r[0] = 0;
+ regs.r[1] = (int)&smb;
+
+ if (_kernel_swi(OS_ScreenMode, ®s, ®s) != 0)
+ {
+ SDL_SetError("Couldn't set requested mode");
+ return 0;
+ }
+
+ /* Turn cursor off*/
+ _kernel_oswrch(23);_kernel_oswrch(1);_kernel_oswrch(0);
+ _kernel_oswrch(0);_kernel_oswrch(0);_kernel_oswrch(0);
+ _kernel_oswrch(0);_kernel_oswrch(0);_kernel_oswrch(0);
+ _kernel_oswrch(0);_kernel_oswrch(0);
+
+ return 1;
+}
+
+/* Get Start addresses for the screen banks */
+void FULLSCREEN_SetupBanks(_THIS)
+{
+ _kernel_swi_regs regs;
+ int block[5];
+ block[0] = 148; /* Write screen start */
+ block[1] = 149; /* Display screen start */
+ block[2] = 4; /* X eig factor */
+ block[3] = 5; /* Y eig factor */
+ block[4] = -1; /* End of list of variables to request */
+
+ regs.r[0] = (int)block;
+ regs.r[1] = (int)block;
+ _kernel_swi(OS_ReadVduVariables, ®s, ®s);
+
+ this->hidden->bank[0] = (void *)block[0];
+ this->hidden->bank[1] = (void *)block[1];
+ this->hidden->xeig = block[2];
+ this->hidden->yeig = block[3];
+}
+
+/* Toggle to full screen mode from the WIMP */
+
+int FULLSCREEN_ToggleFromWimp(_THIS)
+{
+ int width = this->screen->w;
+ int height = this->screen->h;
+ int bpp = this->screen->format->BitsPerPixel;
+
+ RISCOS_StoreWimpMode();
+ if (FULLSCREEN_SetMode(width, height, bpp))
+ {
+ char *buffer = this->hidden->alloc_bank; /* This is start of sprite data */
+ /* Support back buffer mode only */
+ if (riscos_backbuffer == 0) riscos_backbuffer = 1;
+
+ FULLSCREEN_SetupBanks(this);
+
+ this->hidden->bank[0] = buffer + 60; /* Start of sprite data */
+ if (bpp == 8) this->hidden->bank[0] += 2048; /* 8bpp sprite have palette first */
+
+ this->hidden->current_bank = 0;
+ this->screen->pixels = this->hidden->bank[0];
+
+ /* Copy back buffer to screen memory */
+ SDL_memcpy(this->hidden->bank[1], this->hidden->bank[0], width * height * this->screen->format->BytesPerPixel);
+
+ FULLSCREEN_SetDeviceMode(this);
+ return 1;
+ } else
+ RISCOS_RestoreWimpMode();
+
+ return 0;
+}