--- a/src/video/riscos/SDL_riscosFullScreenVideo.c	Sun May 21 17:27:13 2006 +0000
+++ b/src/video/riscos/SDL_riscosFullScreenVideo.c	Sun May 28 13:04:16 2006 +0000
@@ -47,618 +47,631 @@
 /* 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
+    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);
+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);
+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);
+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);
+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 */
+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);
+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);
+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)
+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;
+    _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;
+    switch (bpp) {
+    case 8:
+        flags |= SDL_HWPALETTE;
+        break;
 
-	case 15:
-	case 16:
-		Bmask = 0x00007c00;
-		Gmask = 0x000003e0;
-		Rmask = 0x0000001f;
-		break;
+    case 15:
+    case 16:
+        Bmask = 0x00007c00;
+        Gmask = 0x000003e0;
+        Rmask = 0x0000001f;
+        break;
 
-	case 32:
-		Bmask = 0x00ff0000;
-		Gmask = 0x0000ff00;
-		Rmask = 0x000000ff;
-		break;
+    case 32:
+        Bmask = 0x00ff0000;
+        Gmask = 0x0000ff00;
+        Rmask = 0x000000ff;
+        break;
 
-	default:
-		SDL_SetError("Pixel depth not supported");
-		return NULL;
-		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);
-   }
+    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, &regs, &regs);
-
-   current->pitch = regs.r[2];
-
-   if (flags & SDL_DOUBLEBUF)
-   {
-	   regs.r[0] = 2; /* Screen area */
-	   _kernel_swi(OS_ReadDynamicArea, &regs, &regs);
-	   
-	   /* 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, &regs, &regs) != 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 */
+    /* 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);
     }
 
-    FULLSCREEN_SetupBanks(this);
+    /* 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, &regs, &regs);
+
+    current->pitch = regs.r[2];
+
+    if (flags & SDL_DOUBLEBUF) {
+        regs.r[0] = 2;          /* Screen area */
+        _kernel_swi (OS_ReadDynamicArea, &regs, &regs);
 
-    if (create_back_buffer)
-    {
-       /* If not double buffered we may need to create a memory
+        /* 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, &regs, &regs) != 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;
+        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)
-    {
+    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 */
+        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;
+        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);
+    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];
+    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);
+    /* Reset device functions for the wimp */
+    FULLSCREEN_SetDeviceMode (this);
 
 /*	FULLSCREEN_DisableEscape(); */
 
-	/* We're done */
-	return(current);
+    /* We're done */
+    return (current);
 }
 
 /* Reset any device functions that have been changed because we have run in WIMP mode */
-void FULLSCREEN_SetDeviceMode(_THIS)
+void
+FULLSCREEN_SetDeviceMode (_THIS)
 {
-	/* Update rects is different if we have a backbuffer */
+    /* 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;
+    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;
+            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;
+        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 */
+        default:               /* Old but safe memcpy */
+            this->UpdateRects = FULLSCREEN_UpdateRectsMemCpy;
+            break;
+        }
+    } else
+        this->UpdateRects = FULLSCREEN_UpdateRects;     /* Default do nothing implementation */
 
-	this->SetColors   = FULLSCREEN_SetColors;
+    this->SetColors = FULLSCREEN_SetColors;
 
-	this->FlipHWSurface = FULLSCREEN_FlipHWSurface;
+    this->FlipHWSurface = FULLSCREEN_FlipHWSurface;
 
-	this->SetCaption = FULLSCREEN_SetWMCaption;
-	this->SetIcon = NULL;
-	this->IconifyWindow = NULL;
-	
-	this->ShowWMCursor = RISCOS_ShowWMCursor;
-	this->WarpWMCursor = FULLSCREEN_WarpWMCursor;
+    this->SetCaption = FULLSCREEN_SetWMCaption;
+    this->SetIcon = NULL;
+    this->IconifyWindow = NULL;
 
-	this->PumpEvents = FULLSCREEN_PumpEvents;	
+    this->ShowWMCursor = RISCOS_ShowWMCursor;
+    this->WarpWMCursor = FULLSCREEN_WarpWMCursor;
+
+    this->PumpEvents = FULLSCREEN_PumpEvents;
 }
 
 /* Query for the list of available video modes */
-void FULLSCREEN_BuildModeList(_THIS)
+void
+FULLSCREEN_BuildModeList (_THIS)
 {
-	_kernel_swi_regs regs;
-	char *enumInfo = NULL;
-	char *enum_ptr;
-	int *blockInfo;
-	int j;
-	int num_modes;
+    _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, &regs, &regs);
+    /* 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, &regs, &regs);
 
     num_modes = -regs.r[2];
 
-	/* Video memory should be in r[5] */
-	this->info.video_mem = regs.r[5]/1024;
+    /* 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, &regs, &regs);
+    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, &regs, &regs);
 
-	enum_ptr = enumInfo;
+    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;
-			}
-		}
+    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];
-	}
+        enum_ptr += blockInfo[0];
+    }
+
+    SDL_free (enumInfo);
 
-	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);
-		}
-	}
+    /* 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)
+static int
+FULLSCREEN_FlipHWSurface (_THIS, SDL_Surface * surface)
 {
-   _kernel_swi_regs regs;
-   regs.r[0] = 19;
+    _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];
+    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, &regs, &regs);
+    /* Wait for Vsync */
+    _kernel_swi (OS_Byte, &regs, &regs);
 
-	return(0);
+    return (0);
 }
 
 /* Nothing to do if we are writing direct to hardware */
-static void FULLSCREEN_UpdateRects(_THIS, int numrects, SDL_Rect *rects)
+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)
+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++;
-      }
+    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)
+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;
+    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++;
-   }
+    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)
+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;
+    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++;
-   }
+    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)
+static void
+FULLSCREEN_UpdateRects32bpp (_THIS, int numrects, SDL_Rect * rects)
 {
-   int j;
-   char *to, *from;
-   int pitch = this->screen->pitch;
-   int width;
+    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++;
-   }
+    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)
+static void
+FULLSCREEN_UpdateRectsOS (_THIS, int numrects, SDL_Rect * rects)
 {
-   _kernel_swi_regs regs;
-   _kernel_oserror *err;
-   int j;
-   int y;
+    _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;
+    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);
+    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;
+        regs.r[3] = 0;
+        regs.r[4] = 0;
 
-      if ((err = _kernel_swi(OS_SpriteOp, &regs, &regs)) != 0)
-      {
-         printf("OS_SpriteOp failed \n%s\n",err->errmess);
-      }
+        if ((err = _kernel_swi (OS_SpriteOp, &regs, &regs)) != 0) {
+            printf ("OS_SpriteOp failed \n%s\n", err->errmess);
+        }
 
-      rects++;
+        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);
-   }
+        /* 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)
+int
+FULLSCREEN_SetColors (_THIS, int firstcolor, int ncolors, SDL_Color * colors)
 {
-	_kernel_swi_regs regs;
-	int palette[256];
+    _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, &regs, &regs);
+    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, &regs, &regs);
 
-	while(ncolors--)
-	{
-		palette[firstcolor] = ((colors->b) << 24) | ((colors->g) << 16) | ((colors->r) << 8);
-		firstcolor++;
-		colors++;
-	}
+    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, &regs, &regs);
+    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, &regs, &regs);
 
-	return(1);
+    return (1);
 }
 
 
-static int cmpmodes(const void *va, const void *vb)
+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)
+    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)
+static int
+FULLSCREEN_AddMode (_THIS, int bpp, int w, int h)
 {
-	SDL_Rect *mode;
-	int i, index;
-	int next_mode;
+    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);
-		}
-	}
+    /* 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;
+    /* 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]++;
+    /* 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);
+    return (0);
 }
 
-void FULLSCREEN_SetWriteBank(int bank)
+void
+FULLSCREEN_SetWriteBank (int bank)
 {
-   _kernel_swi_regs regs;
-   regs.r[0] = 112;
-   regs.r[1] = bank+1;
-   _kernel_swi(OS_Byte, &regs, &regs);
+    _kernel_swi_regs regs;
+    regs.r[0] = 112;
+    regs.r[1] = bank + 1;
+    _kernel_swi (OS_Byte, &regs, &regs);
 }
 
-void FULLSCREEN_SetDisplayBank(int bank)
+void
+FULLSCREEN_SetDisplayBank (int bank)
 {
-   _kernel_swi_regs regs;
-   regs.r[0] = 113;
-   regs.r[1] = bank+1;
-   _kernel_swi(OS_Byte, &regs, &regs);
+    _kernel_swi_regs regs;
+    regs.r[0] = 113;
+    regs.r[1] = bank + 1;
+    _kernel_swi (OS_Byte, &regs, &regs);
 }
 
 
 /** Disable special escape key processing */
-static void FULLSCREEN_DisableEscape()
+static void
+FULLSCREEN_DisableEscape ()
 {
-   _kernel_swi_regs regs;
-   regs.r[0] = 229;
-   regs.r[1] = 1;
-   regs.r[2] = 0;
-   _kernel_swi(OS_Byte, &regs, &regs);
-  
+    _kernel_swi_regs regs;
+    regs.r[0] = 229;
+    regs.r[1] = 1;
+    regs.r[2] = 0;
+    _kernel_swi (OS_Byte, &regs, &regs);
+
 }
 
 /** Enable special escape key processing */
-static void FULLSCREEN_EnableEscape()
+static void
+FULLSCREEN_EnableEscape ()
 {
-   _kernel_swi_regs regs;
-   regs.r[0] = 229;
-   regs.r[1] = 0;
-   regs.r[2] = 0;
-   _kernel_swi(OS_Byte, &regs, &regs);
-  
+    _kernel_swi_regs regs;
+    regs.r[0] = 229;
+    regs.r[1] = 0;
+    regs.r[2] = 0;
+    _kernel_swi (OS_Byte, &regs, &regs);
+
 }
 
 /** Store caption in case this is called before we create a window */
-void FULLSCREEN_SetWMCaption(_THIS, const char *title, const char *icon)
+void
+FULLSCREEN_SetWMCaption (_THIS, const char *title, const char *icon)
 {
-	SDL_strlcpy(this->hidden->title, title, SDL_arraysize(this->hidden->title));
+    SDL_strlcpy (this->hidden->title, title,
+                 SDL_arraysize (this->hidden->title));
 }
 
 /* Set screen mode
@@ -666,112 +679,126 @@
 *  Returns 1 if mode is set ok, otherwise 0
 */
 
-int FULLSCREEN_SetMode(int width, int height, int bpp)
+int
+FULLSCREEN_SetMode (int width, int height, int bpp)
 {
-   SCREENMODEBLOCK smb;
-   _kernel_swi_regs regs;
+    SCREENMODEBLOCK smb;
+    _kernel_swi_regs regs;
 
-   smb.flags = 1;
-   smb.x_pixels = width;
-   smb.y_pixels = height;
-   smb.mode_vars[0] = -1;
+    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;
+    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 15:
+    case 16:
+        smb.pixel_depth = 4;
+        break;
+
+    case 32:
+        smb.pixel_depth = 5;
+        break;
 
-	case 32:
-		smb.pixel_depth = 5;
-		break;
+    default:
+        SDL_SetError ("Pixel depth not supported");
+        return 0;
+        break;
+    }
 
-	default:
-		SDL_SetError("Pixel depth not supported");
-		return 0;
-		break;
-   }
-   
-   smb.frame_rate = -1;
+    smb.frame_rate = -1;
+
+    regs.r[0] = 0;
+    regs.r[1] = (int) &smb;
 
-   regs.r[0] = 0;
-   regs.r[1] = (int)&smb;
+    if (_kernel_swi (OS_ScreenMode, &regs, &regs) != 0) {
+        SDL_SetError ("Couldn't set requested mode");
+        return 0;
+    }
 
-   if (_kernel_swi(OS_ScreenMode, &regs, &regs) != 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);
 
-    /* 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;
+    return 1;
 }
 
 /* Get Start addresses for the screen banks */
-void FULLSCREEN_SetupBanks(_THIS)
+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 */
+    _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, &regs, &regs);
+    regs.r[0] = (int) block;
+    regs.r[1] = (int) block;
+    _kernel_swi (OS_ReadVduVariables, &regs, &regs);
 
-   this->hidden->bank[0] = (void *)block[0];
-   this->hidden->bank[1] = (void *)block[1];
-   this->hidden->xeig = block[2];
-   this->hidden->yeig = block[3];
+    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
+FULLSCREEN_ToggleFromWimp (_THIS)
 {
-   int width = this->screen->w;
-   int height = this->screen->h;
-   int bpp = this->screen->format->BitsPerPixel;
+    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;
+    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);
+        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->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];
+        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);
+        /* 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();
+        FULLSCREEN_SetDeviceMode (this);
+        return 1;
+    } else
+        RISCOS_RestoreWimpMode ();
 
-   return 0;
+    return 0;
 }
+
+/* vi: set ts=4 sw=4 expandtab: */