--- a/src/video/cybergfx/SDL_cgxvideo.c	Sun May 21 17:27:13 2006 +0000
+++ b/src/video/cybergfx/SDL_cgxvideo.c	Sun May 28 13:04:16 2006 +0000
@@ -43,1333 +43,1407 @@
 #include "SDL_cgximage_c.h"
 
 /* Initialization/Query functions */
-static int CGX_VideoInit(_THIS, SDL_PixelFormat *vformat);
-static SDL_Surface *CGX_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags);
-static int CGX_ToggleFullScreen(_THIS, int on);
-static void CGX_UpdateMouse(_THIS);
-static int CGX_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors);
-static void CGX_VideoQuit(_THIS);
+static int CGX_VideoInit (_THIS, SDL_PixelFormat * vformat);
+static SDL_Surface *CGX_SetVideoMode (_THIS, SDL_Surface * current, int width,
+                                      int height, int bpp, Uint32 flags);
+static int CGX_ToggleFullScreen (_THIS, int on);
+static void CGX_UpdateMouse (_THIS);
+static int CGX_SetColors (_THIS, int firstcolor, int ncolors,
+                          SDL_Color * colors);
+static void CGX_VideoQuit (_THIS);
 
 /* CGX driver bootstrap functions */
 
-struct Library *CyberGfxBase=NULL;
-struct IntuitionBase *IntuitionBase=NULL;
-struct GfxBase *GfxBase=NULL;
+struct Library *CyberGfxBase = NULL;
+struct IntuitionBase *IntuitionBase = NULL;
+struct GfxBase *GfxBase = NULL;
 
-int CGX_SetGamma(_THIS, float red, float green, float blue)
+int
+CGX_SetGamma (_THIS, float red, float green, float blue)
 {
-    SDL_SetError("Gamma correction not supported");
+    SDL_SetError ("Gamma correction not supported");
     return -1;
 }
 
-int CGX_GetGamma(_THIS, float red, float green, float blue)
+int
+CGX_GetGamma (_THIS, float red, float green, float blue)
 {
-    SDL_SetError("Gamma correction not supported");
+    SDL_SetError ("Gamma correction not supported");
     return -1;
 }
 
-int CGX_SetGammaRamp(_THIS, Uint16 *ramp)
+int
+CGX_SetGammaRamp (_THIS, Uint16 * ramp)
 {
 #if 0
-	Int i, ncolors;
-	XColor xcmap[256];
+    Int i, ncolors;
+    XColor xcmap[256];
 
-	/* See if actually setting the gamma is supported */
-	if ( SDL_Visual->class != DirectColor ) {
-	    SDL_SetError("Gamma correction not supported on this visual");
-	    return(-1);
-	}
+    /* See if actually setting the gamma is supported */
+    if (SDL_Visual->class != DirectColor) {
+        SDL_SetError ("Gamma correction not supported on this visual");
+        return (-1);
+    }
 
-	/* Calculate the appropriate palette for the given gamma ramp */
-	ncolors = SDL_Visual->map_entries;
-	for ( i=0; i<ncolors; ++i ) {
-		Uint8 c = (256 * i / ncolors);
-		xcmap[i].pixel = SDL_MapRGB(this->screen->format, c, c, c);
-		xcmap[i].red   = ramp[0*256+c];
-		xcmap[i].green = ramp[1*256+c];
-		xcmap[i].blue  = ramp[2*256+c];
-		xcmap[i].flags = (DoRed|DoGreen|DoBlue);
-	}
-	XStoreColors(GFX_Display, SDL_XColorMap, xcmap, ncolors);
-	XSync(GFX_Display, False);
+    /* Calculate the appropriate palette for the given gamma ramp */
+    ncolors = SDL_Visual->map_entries;
+    for (i = 0; i < ncolors; ++i) {
+        Uint8 c = (256 * i / ncolors);
+        xcmap[i].pixel = SDL_MapRGB (this->screen->format, c, c, c);
+        xcmap[i].red = ramp[0 * 256 + c];
+        xcmap[i].green = ramp[1 * 256 + c];
+        xcmap[i].blue = ramp[2 * 256 + c];
+        xcmap[i].flags = (DoRed | DoGreen | DoBlue);
+    }
+    XStoreColors (GFX_Display, SDL_XColorMap, xcmap, ncolors);
+    XSync (GFX_Display, False);
 
-	return(0);
+    return (0);
 
 #else
-    SDL_SetError("Gamma correction not supported on this visual");
-    return(-1);
+    SDL_SetError ("Gamma correction not supported on this visual");
+    return (-1);
 
 #endif
 }
 
-static void DestroyScreen(_THIS)
+static void
+DestroyScreen (_THIS)
 {
-  	if(currently_fullscreen)
-	{
-		if(this->hidden->dbuffer)
-		{
-			extern struct MsgPort *safeport,*dispport;
+    if (currently_fullscreen) {
+        if (this->hidden->dbuffer) {
+            extern struct MsgPort *safeport, *dispport;
 
-			this->hidden->dbuffer=0;
+            this->hidden->dbuffer = 0;
 
-			if(safeport)
-			{
-				while(GetMsg(safeport)!=NULL);
-				DeleteMsgPort(safeport);
-			}
-			if(dispport)
-			{
-				while(GetMsg(dispport)!=NULL);
-				DeleteMsgPort(dispport);
-			}
+            if (safeport) {
+                while (GetMsg (safeport) != NULL);
+                DeleteMsgPort (safeport);
+            }
+            if (dispport) {
+                while (GetMsg (dispport) != NULL);
+                DeleteMsgPort (dispport);
+            }
 
-			this->hidden->SB[0]->sb_DBufInfo->dbi_SafeMessage.mn_ReplyPort=this->hidden->SB[0]->sb_DBufInfo->dbi_DispMessage.mn_ReplyPort=NULL;
-			this->hidden->SB[1]->sb_DBufInfo->dbi_SafeMessage.mn_ReplyPort=this->hidden->SB[1]->sb_DBufInfo->dbi_DispMessage.mn_ReplyPort=NULL;
+            this->hidden->SB[0]->sb_DBufInfo->dbi_SafeMessage.
+                mn_ReplyPort =
+                this->hidden->SB[0]->sb_DBufInfo->dbi_DispMessage.
+                mn_ReplyPort = NULL;
+            this->hidden->SB[1]->sb_DBufInfo->dbi_SafeMessage.
+                mn_ReplyPort =
+                this->hidden->SB[1]->sb_DBufInfo->dbi_DispMessage.
+                mn_ReplyPort = NULL;
 
-			if(this->hidden->SB[1])
-				FreeScreenBuffer(SDL_Display,this->hidden->SB[1]);
-			if(this->hidden->SB[0])
-				FreeScreenBuffer(SDL_Display,this->hidden->SB[0]);
+            if (this->hidden->SB[1])
+                FreeScreenBuffer (SDL_Display, this->hidden->SB[1]);
+            if (this->hidden->SB[0])
+                FreeScreenBuffer (SDL_Display, this->hidden->SB[0]);
 
 
-			this->hidden->SB[0]=this->hidden->SB[1]=NULL;
+            this->hidden->SB[0] = this->hidden->SB[1] = NULL;
 
-			if(SDL_RastPort && SDL_RastPort != &SDL_Display->RastPort)
-				SDL_free(SDL_RastPort);
+            if (SDL_RastPort && SDL_RastPort != &SDL_Display->RastPort)
+                SDL_free (SDL_RastPort);
 
-			SDL_RastPort=NULL;
-		}
-		CloseScreen(GFX_Display);
-		currently_fullscreen=0;
-	}
-	else if(GFX_Display)
-		UnlockPubScreen(NULL,GFX_Display);
+            SDL_RastPort = NULL;
+        }
+        CloseScreen (GFX_Display);
+        currently_fullscreen = 0;
+    } else if (GFX_Display)
+        UnlockPubScreen (NULL, GFX_Display);
 
-	GFX_Display = NULL;
+    GFX_Display = NULL;
 }
 
-static int CGX_Available(void)
+static int
+CGX_Available (void)
 {
-	struct Library *l;
+    struct Library *l;
 
-	l = OpenLibrary("cybergraphics.library",0L);
+    l = OpenLibrary ("cybergraphics.library", 0L);
 
-	if ( l != NULL ) {
-		D(bug("CGX video device AVAILABLE\n"));
-		CloseLibrary(l);
-	}
-	D(else bug("**CGX video device UNAVAILABLE\n"));
+    if (l != NULL) {
+        D (bug ("CGX video device AVAILABLE\n"));
+        CloseLibrary (l);
+    }
+    D (
+          else
+          bug ("**CGX video device UNAVAILABLE\n"));
 
-	return(l != NULL);
+    return (l != NULL);
 }
 
-static void CGX_DeleteDevice(SDL_VideoDevice *device)
+static void
+CGX_DeleteDevice (SDL_VideoDevice * device)
 {
-	if ( device ) {
-		if ( device->hidden ) {
-			SDL_free(device->hidden);
-		}
-		if ( device->gl_data ) {
-			SDL_free(device->gl_data);
-		}
-		SDL_free(device);
-	}
+    if (device) {
+        if (device->hidden) {
+            SDL_free (device->hidden);
+        }
+        if (device->gl_data) {
+            SDL_free (device->gl_data);
+        }
+        SDL_free (device);
+    }
 }
 
-static SDL_VideoDevice *CGX_CreateDevice(int devindex)
+static SDL_VideoDevice *
+CGX_CreateDevice (int devindex)
 {
-	SDL_VideoDevice *device;
+    SDL_VideoDevice *device;
 
-	/* Initialize all variables that we clean on shutdown */
-	device = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice));
-	if ( device ) {
-		SDL_memset(device, 0, (sizeof *device));
-		device->hidden = (struct SDL_PrivateVideoData *)
-				SDL_malloc((sizeof *device->hidden));
-		device->gl_data = (struct SDL_PrivateGLData *)
-				SDL_malloc((sizeof *device->gl_data));
-	}
-	if ( (device == NULL) || (device->hidden == NULL) ||
-	                         (device->gl_data == NULL) ) {
-		D(bug("Unable to create video device!\n"));
-		SDL_OutOfMemory();
-		CGX_DeleteDevice(device);
-		return(0);
-	}
-	SDL_memset(device->hidden, 0, sizeof(*device->hidden));
-	SDL_memset(device->gl_data, 0, sizeof(*device->gl_data));
+    /* Initialize all variables that we clean on shutdown */
+    device = (SDL_VideoDevice *) SDL_malloc (sizeof (SDL_VideoDevice));
+    if (device) {
+        SDL_memset (device, 0, (sizeof *device));
+        device->hidden = (struct SDL_PrivateVideoData *)
+            SDL_malloc ((sizeof *device->hidden));
+        device->gl_data = (struct SDL_PrivateGLData *)
+            SDL_malloc ((sizeof *device->gl_data));
+    }
+    if ((device == NULL) || (device->hidden == NULL) ||
+        (device->gl_data == NULL)) {
+        D (bug ("Unable to create video device!\n"));
+        SDL_OutOfMemory ();
+        CGX_DeleteDevice (device);
+        return (0);
+    }
+    SDL_memset (device->hidden, 0, sizeof (*device->hidden));
+    SDL_memset (device->gl_data, 0, sizeof (*device->gl_data));
 
-	/* Set the driver flags */
-	device->handles_any_size = 1;
+    /* Set the driver flags */
+    device->handles_any_size = 1;
 
-	/* Set the function pointers */
-	device->VideoInit = CGX_VideoInit;
-	device->ListModes = CGX_ListModes;
-	device->SetVideoMode = CGX_SetVideoMode;
-	device->ToggleFullScreen = CGX_ToggleFullScreen;
-	device->UpdateMouse = CGX_UpdateMouse;
-	device->SetColors = CGX_SetColors;
-	device->UpdateRects = NULL;
-	device->VideoQuit = CGX_VideoQuit;
-	device->AllocHWSurface = CGX_AllocHWSurface;
-	device->CheckHWBlit = CGX_CheckHWBlit;
-	device->FillHWRect = CGX_FillHWRect;
-	device->SetHWColorKey = CGX_SetHWColorKey;
-	device->SetHWAlpha = NULL;
-	device->LockHWSurface = CGX_LockHWSurface;
-	device->UnlockHWSurface = CGX_UnlockHWSurface;
-	device->FlipHWSurface = CGX_FlipHWSurface;
-	device->FreeHWSurface = CGX_FreeHWSurface;
-	device->SetGamma = CGX_SetGamma;
-	device->GetGamma = CGX_GetGamma;
-	device->SetGammaRamp = CGX_SetGammaRamp;
-	device->GetGammaRamp = NULL;
+    /* Set the function pointers */
+    device->VideoInit = CGX_VideoInit;
+    device->ListModes = CGX_ListModes;
+    device->SetVideoMode = CGX_SetVideoMode;
+    device->ToggleFullScreen = CGX_ToggleFullScreen;
+    device->UpdateMouse = CGX_UpdateMouse;
+    device->SetColors = CGX_SetColors;
+    device->UpdateRects = NULL;
+    device->VideoQuit = CGX_VideoQuit;
+    device->AllocHWSurface = CGX_AllocHWSurface;
+    device->CheckHWBlit = CGX_CheckHWBlit;
+    device->FillHWRect = CGX_FillHWRect;
+    device->SetHWColorKey = CGX_SetHWColorKey;
+    device->SetHWAlpha = NULL;
+    device->LockHWSurface = CGX_LockHWSurface;
+    device->UnlockHWSurface = CGX_UnlockHWSurface;
+    device->FlipHWSurface = CGX_FlipHWSurface;
+    device->FreeHWSurface = CGX_FreeHWSurface;
+    device->SetGamma = CGX_SetGamma;
+    device->GetGamma = CGX_GetGamma;
+    device->SetGammaRamp = CGX_SetGammaRamp;
+    device->GetGammaRamp = NULL;
 #if SDL_VIDEO_OPENGL
-	device->GL_LoadLibrary = CGX_GL_LoadLibrary;
-	device->GL_GetProcAddress = CGX_GL_GetProcAddress;
-	device->GL_GetAttribute = CGX_GL_GetAttribute;
-	device->GL_MakeCurrent = CGX_GL_MakeCurrent;
-	device->GL_SwapBuffers = CGX_GL_SwapBuffers;
+    device->GL_LoadLibrary = CGX_GL_LoadLibrary;
+    device->GL_GetProcAddress = CGX_GL_GetProcAddress;
+    device->GL_GetAttribute = CGX_GL_GetAttribute;
+    device->GL_MakeCurrent = CGX_GL_MakeCurrent;
+    device->GL_SwapBuffers = CGX_GL_SwapBuffers;
 #endif
-	device->SetIcon = CGX_SetIcon;
-	device->SetCaption = CGX_SetCaption;
-	device->IconifyWindow = NULL; /* CGX_IconifyWindow; */
-	device->GrabInput = NULL /* CGX_GrabInput*/;
-	device->GetWMInfo = CGX_GetWMInfo;
-	device->FreeWMCursor = amiga_FreeWMCursor;
-	device->CreateWMCursor = amiga_CreateWMCursor;
-	device->ShowWMCursor = amiga_ShowWMCursor;
-	device->WarpWMCursor = amiga_WarpWMCursor;
-	device->CheckMouseMode = amiga_CheckMouseMode;
-	device->InitOSKeymap = amiga_InitOSKeymap;
-	device->PumpEvents = amiga_PumpEvents;
+    device->SetIcon = CGX_SetIcon;
+    device->SetCaption = CGX_SetCaption;
+    device->IconifyWindow = NULL;       /* CGX_IconifyWindow; */
+    device->GrabInput = NULL /* CGX_GrabInput */ ;
+    device->GetWMInfo = CGX_GetWMInfo;
+    device->FreeWMCursor = amiga_FreeWMCursor;
+    device->CreateWMCursor = amiga_CreateWMCursor;
+    device->ShowWMCursor = amiga_ShowWMCursor;
+    device->WarpWMCursor = amiga_WarpWMCursor;
+    device->CheckMouseMode = amiga_CheckMouseMode;
+    device->InitOSKeymap = amiga_InitOSKeymap;
+    device->PumpEvents = amiga_PumpEvents;
 
-	device->free = CGX_DeleteDevice;
+    device->free = CGX_DeleteDevice;
 
-	return device;
+    return device;
 }
 
 VideoBootStrap CGX_bootstrap = {
-	"CGX", "AmigaOS CyberGraphics", CGX_Available, CGX_CreateDevice
+    "CGX", "AmigaOS CyberGraphics", CGX_Available, CGX_CreateDevice
 };
 
-Uint32 MakeBitMask(_THIS,int type,int format,int *bpp)
+Uint32
+MakeBitMask (_THIS, int type, int format, int *bpp)
 {
-	D(if(type==0)bug("REAL pixel format: "));
+    D (if (type == 0) bug ("REAL pixel format: "));
 
-	if(this->hidden->depth==*bpp)
-	{
+    if (this->hidden->depth == *bpp) {
 
-	switch(format)
-    	{
-		case PIXFMT_LUT8:
-			D(if(type==0)bug("LUT8\n"));
-			return 0;
-		case PIXFMT_BGR15:
-		case PIXFMT_RGB15PC:
-			switch(type)
-			{
-				case 0:
-					D(bug("RGB15PC/BGR15\n"));
-					return 31;
-				case 1:
-					return 992;
-				case 2:
-					return 31744;
-			}
-		case PIXFMT_RGB15:
-		case PIXFMT_BGR15PC:
-			switch(type)
-			{
-				case 0:
-					D(bug("RGB15/BGR15PC\n"));
-					return 31744;
-				case 1:
-					return 992;
-				case 2:
-					return 31;
-			}
-		case PIXFMT_BGR16PC:
-		case PIXFMT_RGB16:
-			switch(type)
-			{
-				case 0:
-					D(bug("RGB16PC\n"));
-					return 63488;
-				case 1:
-					return 2016;
-				case 2:
-					return 31;
-			}
-		case PIXFMT_BGR16:
-		case PIXFMT_RGB16PC:
-			switch(type)
-			{
-				case 0:
-					D(bug("RGB16PC/BGR16\n"));
-					return 31;
-				case 1:
-					return 2016;
-				case 2:
-					return 63488;
-			}
+        switch (format) {
+        case PIXFMT_LUT8:
+            D (if (type == 0) bug ("LUT8\n"));
+            return 0;
+        case PIXFMT_BGR15:
+        case PIXFMT_RGB15PC:
+            switch (type) {
+            case 0:
+                D (bug ("RGB15PC/BGR15\n"));
+                return 31;
+            case 1:
+                return 992;
+            case 2:
+                return 31744;
+            }
+        case PIXFMT_RGB15:
+        case PIXFMT_BGR15PC:
+            switch (type) {
+            case 0:
+                D (bug ("RGB15/BGR15PC\n"));
+                return 31744;
+            case 1:
+                return 992;
+            case 2:
+                return 31;
+            }
+        case PIXFMT_BGR16PC:
+        case PIXFMT_RGB16:
+            switch (type) {
+            case 0:
+                D (bug ("RGB16PC\n"));
+                return 63488;
+            case 1:
+                return 2016;
+            case 2:
+                return 31;
+            }
+        case PIXFMT_BGR16:
+        case PIXFMT_RGB16PC:
+            switch (type) {
+            case 0:
+                D (bug ("RGB16PC/BGR16\n"));
+                return 31;
+            case 1:
+                return 2016;
+            case 2:
+                return 63488;
+            }
 
-		case PIXFMT_RGB24:
-			switch(type)
-			{
-				case 0:
-					D(bug("RGB24/BGR24\n"));
-					return 0xff0000;
-				case 1:
-					return 0xff00;
-				case 2:
-					return 0xff;
-			}
-		case PIXFMT_BGR24:
-			switch(type)
-			{
-				case 0:
-					D(bug("BGR24\n"));
-					return 0xff;
-				case 1:
-					return 0xff00;
-				case 2:
-					return 0xff0000;
-			}
-		case PIXFMT_ARGB32:
-			switch(type)
-			{
-				case 0:
-					D(bug("ARGB32\n"));
-					return 0xff0000;
-				case 1:
-					return 0xff00;
-				case 2:
-					return 0xff;
-			}
-		case PIXFMT_BGRA32:
-			switch(type)
-			{
-				case 0:
-					D(bug("BGRA32\n"));
-					return 0xff00;
-				case 1:
-					return 0xff0000;
-				case 2:
-					return 0xff000000;
-			}
-		case PIXFMT_RGBA32:
-			switch(type)
-			{
-				case 0:
-					D(bug("RGBA32\n"));
-					return 0xff000000;
-				case 1:
-					return 0xff0000;
-				case 2:
-					return 0xff00;
-			}
-		default:
-			D(bug("Unknown pixel format! Default to 24bit\n"));
-			return (Uint32) (255<<(type*8));
-	}
-	}
-	else
-	{
-		D(if(type==0)bug("DIFFERENT from screen.\nAllocated screen format: "));
+        case PIXFMT_RGB24:
+            switch (type) {
+            case 0:
+                D (bug ("RGB24/BGR24\n"));
+                return 0xff0000;
+            case 1:
+                return 0xff00;
+            case 2:
+                return 0xff;
+            }
+        case PIXFMT_BGR24:
+            switch (type) {
+            case 0:
+                D (bug ("BGR24\n"));
+                return 0xff;
+            case 1:
+                return 0xff00;
+            case 2:
+                return 0xff0000;
+            }
+        case PIXFMT_ARGB32:
+            switch (type) {
+            case 0:
+                D (bug ("ARGB32\n"));
+                return 0xff0000;
+            case 1:
+                return 0xff00;
+            case 2:
+                return 0xff;
+            }
+        case PIXFMT_BGRA32:
+            switch (type) {
+            case 0:
+                D (bug ("BGRA32\n"));
+                return 0xff00;
+            case 1:
+                return 0xff0000;
+            case 2:
+                return 0xff000000;
+            }
+        case PIXFMT_RGBA32:
+            switch (type) {
+            case 0:
+                D (bug ("RGBA32\n"));
+                return 0xff000000;
+            case 1:
+                return 0xff0000;
+            case 2:
+                return 0xff00;
+            }
+        default:
+            D (bug ("Unknown pixel format! Default to 24bit\n"));
+            return (Uint32) (255 << (type * 8));
+        }
+    } else {
+        D (if (type == 0)
+           bug ("DIFFERENT from screen.\nAllocated screen format: "));
 
-		switch(*bpp)
-		{
-			case 32:
-				D(if(type==0) bug("RGBA32\n"));
-				switch(type)
-				{
-					case 0:
-						return 0xff000000;
-					case 1:
-						return 0xff0000;
-					case 2:
-						return 0xff00;
-				}
-				break;
-			case 24:
-use_truecolor:
-				switch(type)
-				{
-					case 0:
-						D(bug("RGB24\n"));
-						return 0xff0000;
-					case 1:
-						return 0xff00;
-					case 2:
-						return 0xff;
-				}
-			case 16:
-			case 15:
-				D(if(type==0) bug("Not supported, switching to 24bit!\n"));
-				*bpp=24;
-				goto use_truecolor;
-				break;
-			default:
-				D(if(type==0)bug("This is a chunky display\n"));
+        switch (*bpp) {
+        case 32:
+            D (if (type == 0) bug ("RGBA32\n"));
+            switch (type) {
+            case 0:
+                return 0xff000000;
+            case 1:
+                return 0xff0000;
+            case 2:
+                return 0xff00;
+            }
+            break;
+        case 24:
+          use_truecolor:
+            switch (type) {
+            case 0:
+                D (bug ("RGB24\n"));
+                return 0xff0000;
+            case 1:
+                return 0xff00;
+            case 2:
+                return 0xff;
+            }
+        case 16:
+        case 15:
+            D (if (type == 0)
+               bug ("Not supported, switching to 24bit!\n"));
+            *bpp = 24;
+            goto use_truecolor;
+            break;
+        default:
+            D (if (type == 0) bug ("This is a chunky display\n"));
 // For chunky display mask is always 0;
-				return 0;
-		}
-	}
-	return 0;
+            return 0;
+        }
+    }
+    return 0;
 }
 
-static int CGX_VideoInit(_THIS, SDL_PixelFormat *vformat)
+static int
+CGX_VideoInit (_THIS, SDL_PixelFormat * vformat)
 {
-	int i;
-	struct Library *RTGBase;
+    int i;
+    struct Library *RTGBase;
 
-	D(bug("VideoInit... Opening libraries\n"));
+    D (bug ("VideoInit... Opening libraries\n"));
 
-	if(!IntuitionBase) {
-		if( !(IntuitionBase=(struct IntuitionBase *)OpenLibrary("intuition.library",39L))) {
-			SDL_SetError("Couldn't open intuition V39+");
-			return -1;
-		}
-	}
+    if (!IntuitionBase) {
+        if (!
+            (IntuitionBase =
+             (struct IntuitionBase *) OpenLibrary ("intuition.library",
+                                                   39L))) {
+            SDL_SetError ("Couldn't open intuition V39+");
+            return -1;
+        }
+    }
 
-	if(!GfxBase) {
-		if( !(GfxBase=(struct GfxBase *)OpenLibrary("graphics.library",39L))) {
-			SDL_SetError("Couldn't open graphics V39+");
-			return -1;
-		}
-	}
+    if (!GfxBase) {
+        if (!
+            (GfxBase =
+             (struct GfxBase *) OpenLibrary ("graphics.library", 39L))) {
+            SDL_SetError ("Couldn't open graphics V39+");
+            return -1;
+        }
+    }
 
-	if(!CyberGfxBase) {
-		if( !(CyberGfxBase=OpenLibrary("cybergraphics.library",40L))) {
-			SDL_SetError("Couldn't open cybergraphics.");
-			return(-1);
-		}
-	}
+    if (!CyberGfxBase) {
+        if (!(CyberGfxBase = OpenLibrary ("cybergraphics.library", 40L))) {
+            SDL_SetError ("Couldn't open cybergraphics.");
+            return (-1);
+        }
+    }
 
-	if(RTGBase=OpenLibrary("libs:picasso96/rtg.library",0L)) {
-		extern int use_picasso96;
+    if (RTGBase = OpenLibrary ("libs:picasso96/rtg.library", 0L)) {
+        extern int use_picasso96;
 
-		CloseLibrary(RTGBase);
-		use_picasso96=1;
-	}
+        CloseLibrary (RTGBase);
+        use_picasso96 = 1;
+    }
 
-	D(bug("Library intialized, locking screen...\n"));
-
-	SDL_Display = LockPubScreen(NULL);
+    D (bug ("Library intialized, locking screen...\n"));
 
-	if ( SDL_Display == NULL ) {
-		D(bug("Cannot lock display...\n"));
-		SDL_SetError("Couldn't lock the display");
-		return(-1);
-	}
-	this->info.current_w = SDL_Display->Width;
-	this->info.current_h = SDL_Display->Height;
+    SDL_Display = LockPubScreen (NULL);
 
-	D(bug("Checking if we are using a CGX native display...\n"));
+    if (SDL_Display == NULL) {
+        D (bug ("Cannot lock display...\n"));
+        SDL_SetError ("Couldn't lock the display");
+        return (-1);
+    }
+    this->info.current_w = SDL_Display->Width;
+    this->info.current_h = SDL_Display->Height;
 
-	if(!IsCyberModeID(GetVPModeID(&SDL_Display->ViewPort)))
-	{
-		Uint32 okid=BestCModeIDTags(CYBRBIDTG_NominalWidth,SDL_Display->Width,
-				CYBRBIDTG_NominalHeight,SDL_Display->Height,
-				CYBRBIDTG_Depth,8,
-				TAG_DONE);
+    D (bug ("Checking if we are using a CGX native display...\n"));
 
-		D(bug("Default visual is not CGX native!\n"));
+    if (!IsCyberModeID (GetVPModeID (&SDL_Display->ViewPort))) {
+        Uint32 okid =
+            BestCModeIDTags (CYBRBIDTG_NominalWidth, SDL_Display->Width,
+                             CYBRBIDTG_NominalHeight, SDL_Display->Height,
+                             CYBRBIDTG_Depth, 8,
+                             TAG_DONE);
 
-		UnlockPubScreen(NULL,SDL_Display);
+        D (bug ("Default visual is not CGX native!\n"));
 
-		GFX_Display=NULL;
+        UnlockPubScreen (NULL, SDL_Display);
+
+        GFX_Display = NULL;
 
-		if(okid!=INVALID_ID)
-		{
-			GFX_Display=OpenScreenTags(NULL,
-									SA_Width,SDL_Display->Width,
-									SA_Height,SDL_Display->Height,
-									SA_Depth,8,SA_Quiet,TRUE,
-									SA_ShowTitle,FALSE,
-									SA_DisplayID,okid,
-									TAG_DONE);
-		}
+        if (okid != INVALID_ID) {
+            GFX_Display = OpenScreenTags (NULL,
+                                          SA_Width, SDL_Display->Width,
+                                          SA_Height, SDL_Display->Height,
+                                          SA_Depth, 8, SA_Quiet, TRUE,
+                                          SA_ShowTitle, FALSE,
+                                          SA_DisplayID, okid, TAG_DONE);
+        }
 
-		if(!GFX_Display)
-		{
-			SDL_SetError("Unable to open a suited CGX display");
-			return -1;
-		}
-		else SDL_Display=GFX_Display;
+        if (!GFX_Display) {
+            SDL_SetError ("Unable to open a suited CGX display");
+            return -1;
+        } else
+            SDL_Display = GFX_Display;
 
-	}
-	else GFX_Display = SDL_Display;
+    } else
+        GFX_Display = SDL_Display;
 
 
-	/* See whether or not we need to swap pixels */
+    /* See whether or not we need to swap pixels */
 
-	swap_pixels = 0;
+    swap_pixels = 0;
 
 // Non e' detto che sia cosi' pero', alcune schede potrebbero gestire i modi in modo differente
 
-	if ( SDL_BYTEORDER == SDL_LIL_ENDIAN ) {
-		swap_pixels = 1;
-	}
+    if (SDL_BYTEORDER == SDL_LIL_ENDIAN) {
+        swap_pixels = 1;
+    }
 
-	D(bug("Before GetVideoModes....\n"));
+    D (bug ("Before GetVideoModes....\n"));
 
-	/* Get the available video modes */
-	if(CGX_GetVideoModes(this) < 0)
-	    return -1;
+    /* Get the available video modes */
+    if (CGX_GetVideoModes (this) < 0)
+        return -1;
 
-	/* Determine the default screen depth:
-	   Use the default visual (or at least one with the same depth) */
+    /* Determine the default screen depth:
+       Use the default visual (or at least one with the same depth) */
 
-	for(i = 0; i < this->hidden->nvisuals; i++)
-	    if(this->hidden->visuals[i].depth == GetCyberMapAttr(SDL_Display->RastPort.BitMap,CYBRMATTR_DEPTH))
-					break;
-	if(i == this->hidden->nvisuals) {
-	    /* default visual was useless, take the deepest one instead */
-	    i = 0;
-	}
-	SDL_Visual = this->hidden->visuals[i].visual;
+    for (i = 0; i < this->hidden->nvisuals; i++)
+        if (this->hidden->visuals[i].depth ==
+            GetCyberMapAttr (SDL_Display->RastPort.BitMap, CYBRMATTR_DEPTH))
+            break;
+    if (i == this->hidden->nvisuals) {
+        /* default visual was useless, take the deepest one instead */
+        i = 0;
+    }
+    SDL_Visual = this->hidden->visuals[i].visual;
 
-//	SDL_XColorMap = SDL_DisplayColormap;
+//      SDL_XColorMap = SDL_DisplayColormap;
 
-	this->hidden->depth = this->hidden->visuals[i].depth;
-	D(bug("Init: Setting screen depth to: %ld\n",this->hidden->depth));
-	vformat->BitsPerPixel = this->hidden->visuals[i].depth; /* this->hidden->visuals[i].bpp; */
+    this->hidden->depth = this->hidden->visuals[i].depth;
+    D (bug ("Init: Setting screen depth to: %ld\n", this->hidden->depth));
+    vformat->BitsPerPixel = this->hidden->visuals[i].depth;     /* this->hidden->visuals[i].bpp; */
 
-	{
-		int form;
-		APTR handle;
-		struct DisplayInfo info;
+    {
+        int form;
+        APTR handle;
+        struct DisplayInfo info;
 
-		if(!(handle=FindDisplayInfo(this->hidden->visuals[i].visual)))
-		{
-			D(bug("Unable to get visual info...\n"));
-			return -1;
-		}
+        if (!(handle = FindDisplayInfo (this->hidden->visuals[i].visual))) {
+            D (bug ("Unable to get visual info...\n"));
+            return -1;
+        }
 
-		if(!GetDisplayInfoData(handle,(char *)&info,sizeof(struct DisplayInfo),DTAG_DISP,NULL)) {
-			D(bug("Unable to get visual info data...\n"));
-			return -1;
-		}
+        if (!GetDisplayInfoData
+            (handle, (char *) &info, sizeof (struct DisplayInfo), DTAG_DISP,
+             NULL)) {
+            D (bug ("Unable to get visual info data...\n"));
+            return -1;
+        }
 
-		form=GetCyberIDAttr(CYBRIDATTR_PIXFMT,SDL_Visual);
+        form = GetCyberIDAttr (CYBRIDATTR_PIXFMT, SDL_Visual);
 
 // In this case I use makebitmask in a way that I'm sure I'll get PIXFMT pixel mask
 
-		if ( vformat->BitsPerPixel > 8 )
-		{
-			vformat->Rmask = MakeBitMask(this,0,form,&this->hidden->depth);
-	  		vformat->Gmask = MakeBitMask(this,1,form,&this->hidden->depth);
-		  	vformat->Bmask = MakeBitMask(this,2,form,&this->hidden->depth);
-		}
-	}
+        if (vformat->BitsPerPixel > 8) {
+            vformat->Rmask =
+                MakeBitMask (this, 0, form, &this->hidden->depth);
+            vformat->Gmask =
+                MakeBitMask (this, 1, form, &this->hidden->depth);
+            vformat->Bmask =
+                MakeBitMask (this, 2, form, &this->hidden->depth);
+        }
+    }
 
-	/* See if we have been passed a window to use */
+    /* See if we have been passed a window to use */
 /*	SDL_windowid = SDL_getenv("SDL_WINDOWID"); */
-	SDL_windowid=NULL;
-
-	/* Create the blank cursor */
-	SDL_BlankCursor = AllocMem(16,MEMF_CHIP|MEMF_CLEAR);
+    SDL_windowid = NULL;
 
-	/* Fill in some window manager capabilities */
-	this->info.wm_available = 1;
-	this->info.blit_hw = 1;
-	this->info.blit_hw_CC = 1;
-	this->info.blit_sw = 1;
-	this->info.blit_fill = 1;
-	this->info.video_mem=2000000; // Not always true but almost any Amiga card has this memory!
+    /* Create the blank cursor */
+    SDL_BlankCursor = AllocMem (16, MEMF_CHIP | MEMF_CLEAR);
 
-	this->hidden->same_format=0;
-	SDL_RastPort=&SDL_Display->RastPort;
-	/* We're done! */
-	D(bug("End of CGX_VideoInit\n"));
+    /* Fill in some window manager capabilities */
+    this->info.wm_available = 1;
+    this->info.blit_hw = 1;
+    this->info.blit_hw_CC = 1;
+    this->info.blit_sw = 1;
+    this->info.blit_fill = 1;
+    this->info.video_mem = 2000000;     // Not always true but almost any Amiga card has this memory!
 
-	return(0);
+    this->hidden->same_format = 0;
+    SDL_RastPort = &SDL_Display->RastPort;
+    /* We're done! */
+    D (bug ("End of CGX_VideoInit\n"));
+
+    return (0);
 }
 
-void CGX_DestroyWindow(_THIS, SDL_Surface *screen)
+void
+CGX_DestroyWindow (_THIS, SDL_Surface * screen)
 {
-	D(bug("Destroy Window...\n"));
+    D (bug ("Destroy Window...\n"));
 
-	if ( ! SDL_windowid ) {
-		/* Hide the managed window */
-		int was_fullscreen=0;
+    if (!SDL_windowid) {
+        /* Hide the managed window */
+        int was_fullscreen = 0;
 
-		/* Clean up OpenGL */
-		if ( screen ) {
-		screen->flags &= ~SDL_INTERNALOPENGL;
-		}
+        /* Clean up OpenGL */
+        if (screen) {
+            screen->flags &= ~SDL_INTERNALOPENGL;
+        }
 
-		if ( screen && (screen->flags & SDL_FULLSCREEN) ) {
-			was_fullscreen=1;
-			screen->flags &= ~SDL_FULLSCREEN;
-//			CGX_LeaveFullScreen(this); tolto x crash
-		}
-
-		/* Destroy the output window */
-		if ( SDL_Window ) {
-			CloseWindow(SDL_Window);
-			SDL_Window=NULL;
-		}
+        if (screen && (screen->flags & SDL_FULLSCREEN)) {
+            was_fullscreen = 1;
+            screen->flags &= ~SDL_FULLSCREEN;
+//                      CGX_LeaveFullScreen(this); tolto x crash
+        }
 
-		/* Free the colormap entries */
-		if ( SDL_XPixels ) {
-			int numcolors;
-			unsigned long pixel;
+        /* Destroy the output window */
+        if (SDL_Window) {
+            CloseWindow (SDL_Window);
+            SDL_Window = NULL;
+        }
 
-			if(this->screen->format&&this->hidden->depth==8&&!was_fullscreen)
-			{
-				numcolors = 1<<this->screen->format->BitsPerPixel;
+        /* Free the colormap entries */
+        if (SDL_XPixels) {
+            int numcolors;
+            unsigned long pixel;
 
-				if(numcolors>256)
-					numcolors=256;
+            if (this->screen->format && this->hidden->depth == 8
+                && !was_fullscreen) {
+                numcolors = 1 << this->screen->format->BitsPerPixel;
 
-				if(!was_fullscreen&&this->hidden->depth==8)
-				{
-					for ( pixel=0; pixel<numcolors; pixel++ )
-					{
-						if(SDL_XPixels[pixel]>=0)
-							ReleasePen(GFX_Display->ViewPort.ColorMap,SDL_XPixels[pixel]);
-					}
-				}
-			}
-			SDL_free(SDL_XPixels);
-			SDL_XPixels = NULL;
-		}
-	}
+                if (numcolors > 256)
+                    numcolors = 256;
+
+                if (!was_fullscreen && this->hidden->depth == 8) {
+                    for (pixel = 0; pixel < numcolors; pixel++) {
+                        if (SDL_XPixels[pixel] >= 0)
+                            ReleasePen (GFX_Display->ViewPort.
+                                        ColorMap, SDL_XPixels[pixel]);
+                    }
+                }
+            }
+            SDL_free (SDL_XPixels);
+            SDL_XPixels = NULL;
+        }
+    }
 }
 
-static void CGX_SetSizeHints(_THIS, int w, int h, Uint32 flags)
+static void
+CGX_SetSizeHints (_THIS, int w, int h, Uint32 flags)
 {
-	if ( flags & SDL_RESIZABLE ) {
-		WindowLimits(SDL_Window, 32, 32,4096,4096);
-	} else {
-		WindowLimits(SDL_Window, w,h,w,h);
-	}
-	if ( flags & SDL_FULLSCREEN ) {
-		flags&=~SDL_RESIZABLE;
-	} else if ( SDL_getenv("SDL_VIDEO_CENTERED") ) {
-		int display_w, display_h;
+    if (flags & SDL_RESIZABLE) {
+        WindowLimits (SDL_Window, 32, 32, 4096, 4096);
+    } else {
+        WindowLimits (SDL_Window, w, h, w, h);
+    }
+    if (flags & SDL_FULLSCREEN) {
+        flags &= ~SDL_RESIZABLE;
+    } else if (SDL_getenv ("SDL_VIDEO_CENTERED")) {
+        int display_w, display_h;
 
-		display_w = SDL_Display->Width;
-		display_h = SDL_Display->Height;
-		ChangeWindowBox(SDL_Window,(display_w - w - SDL_Window->BorderLeft-SDL_Window->BorderRight)/2,
-					(display_h - h - SDL_Window->BorderTop-SDL_Window->BorderBottom)/2,
-					w+SDL_Window->BorderLeft+SDL_Window->BorderRight,
-					h+SDL_Window->BorderTop+SDL_Window->BorderBottom);
-	}
+        display_w = SDL_Display->Width;
+        display_h = SDL_Display->Height;
+        ChangeWindowBox (SDL_Window,
+                         (display_w - w - SDL_Window->BorderLeft -
+                          SDL_Window->BorderRight) / 2,
+                         (display_h - h - SDL_Window->BorderTop -
+                          SDL_Window->BorderBottom) / 2,
+                         w + SDL_Window->BorderLeft +
+                         SDL_Window->BorderRight,
+                         h + SDL_Window->BorderTop +
+                         SDL_Window->BorderBottom);
+    }
 }
 
-int CGX_CreateWindow(_THIS, SDL_Surface *screen,
-			    int w, int h, int bpp, Uint32 flags)
+int
+CGX_CreateWindow (_THIS, SDL_Surface * screen,
+                  int w, int h, int bpp, Uint32 flags)
 {
 #if 0
-	int i, depth;
-	Uint32 vis;
+    int i, depth;
+    Uint32 vis;
 #endif
-	D(bug("CGX_CreateWindow\n"));
+    D (bug ("CGX_CreateWindow\n"));
 
-	/* If a window is already present, destroy it and start fresh */
-	if ( SDL_Window ) {
-		CGX_DestroyWindow(this, screen);
-	}
+    /* If a window is already present, destroy it and start fresh */
+    if (SDL_Window) {
+        CGX_DestroyWindow (this, screen);
+    }
 
-	/* See if we have been given a window id */
-	if ( SDL_windowid ) {
-		SDL_Window = (struct Window *)atol(SDL_windowid);
-	} else {
-		SDL_Window = 0;
-	}
+    /* See if we have been given a window id */
+    if (SDL_windowid) {
+        SDL_Window = (struct Window *) atol (SDL_windowid);
+    } else {
+        SDL_Window = 0;
+    }
 
-	/* find out which visual we are going to use */
+    /* find out which visual we are going to use */
 #if 0
 /* questo l'ho spostato nell'apertura dello schermo, in quanto su Amiga le finestre
    hanno il pixel mode degli schermi.
  */
-	/*if ( flags & SDL_INTERNALOPENGL ) {
-		SDL_SetError("OpenGL not supported by the Amiga SDL!");
-		return -1;
-	}
-	else {*/
-		for ( i = 0; i < this->hidden->nvisuals; i++ ) {
-			if ( this->hidden->visuals[i].depth == bpp ) /* era .depth */
-				break;
-		}
-		if ( i == this->hidden->nvisuals ) {
-			SDL_SetError("No matching visual for requested depth");
-			return -1;	/* should never happen */
-		}
-		vis = this->hidden->visuals[i].visual;
-		depth = this->hidden->visuals[i].depth;
-//	}
-	SDL_Visual = vis;
-	this->hidden->depth = depth;
-	D(bug("Setting screen depth to: %ld\n",this->hidden->depth));
+    /*if ( flags & SDL_INTERNALOPENGL ) {
+       SDL_SetError("OpenGL not supported by the Amiga SDL!");
+       return -1;
+       }
+       else { */
+    for (i = 0; i < this->hidden->nvisuals; i++) {
+        if (this->hidden->visuals[i].depth == bpp)      /* era .depth */
+            break;
+    }
+    if (i == this->hidden->nvisuals) {
+        SDL_SetError ("No matching visual for requested depth");
+        return -1;              /* should never happen */
+    }
+    vis = this->hidden->visuals[i].visual;
+    depth = this->hidden->visuals[i].depth;
+//      }
+    SDL_Visual = vis;
+    this->hidden->depth = depth;
+    D (bug ("Setting screen depth to: %ld\n", this->hidden->depth));
 #endif
 
-	/* Allocate the new pixel format for this video mode */
-	{
-		Uint32 form;
-		APTR handle;
-		struct DisplayInfo info;
+    /* Allocate the new pixel format for this video mode */
+    {
+        Uint32 form;
+        APTR handle;
+        struct DisplayInfo info;
 
-		if(!(handle=FindDisplayInfo(SDL_Visual)))
-			return -1;
-
-		if(!GetDisplayInfoData(handle,(char *)&info,sizeof(struct DisplayInfo),DTAG_DISP,NULL))
-			return -1;
+        if (!(handle = FindDisplayInfo (SDL_Visual)))
+            return -1;
 
-		form=GetCyberIDAttr(CYBRIDATTR_PIXFMT,SDL_Visual);
+        if (!GetDisplayInfoData
+            (handle, (char *) &info, sizeof (struct DisplayInfo), DTAG_DISP,
+             NULL))
+            return -1;
+
+        form = GetCyberIDAttr (CYBRIDATTR_PIXFMT, SDL_Visual);
 
-		if(flags&SDL_HWSURFACE)
-		{
-			if(bpp!=this->hidden->depth)
-			{
-				bpp=this->hidden->depth;
-				D(bug("Accel forces bpp to be equal (%ld)\n",bpp));
-			}
-		}
+        if (flags & SDL_HWSURFACE) {
+            if (bpp != this->hidden->depth) {
+                bpp = this->hidden->depth;
+                D (bug ("Accel forces bpp to be equal (%ld)\n", bpp));
+            }
+        }
 
-		D(bug("BEFORE screen allocation: bpp:%ld (real:%ld)\n",bpp,this->hidden->depth));
+        D (bug
+           ("BEFORE screen allocation: bpp:%ld (real:%ld)\n", bpp,
+            this->hidden->depth));
 
 /* With this call if needed I'll revert the wanted bpp to a bpp best suited for the display, actually occurs
    only with requested format 15/16bit and display format != 15/16bit
  */
 
-		if ( ! SDL_ReallocFormat(screen, bpp,
-				MakeBitMask(this,0,form,&bpp), MakeBitMask(this,1,form,&bpp), MakeBitMask(this,2,form,&bpp), 0) )
-			return -1;
+        if (!SDL_ReallocFormat (screen, bpp,
+                                MakeBitMask (this, 0, form, &bpp),
+                                MakeBitMask (this, 1, form, &bpp),
+                                MakeBitMask (this, 2, form, &bpp), 0))
+            return -1;
 
-		D(bug("AFTER screen allocation: bpp:%ld (real:%ld)\n",bpp,this->hidden->depth));
+        D (bug
+           ("AFTER screen allocation: bpp:%ld (real:%ld)\n", bpp,
+            this->hidden->depth));
 
-	}
+    }
 
-	/* Create the appropriate colormap */
+    /* Create the appropriate colormap */
 /*
 	if ( SDL_XColorMap != SDL_DisplayColormap ) {
 		XFreeColormap(SDL_Display, SDL_XColorMap);
 	}
 */
-	if ( GetCyberMapAttr(SDL_Display->RastPort.BitMap,CYBRMATTR_PIXFMT)==PIXFMT_LUT8 || bpp==8 ) {
-	    int ncolors,i;
-	    D(bug("XPixels palette allocation...\n"));
+    if (GetCyberMapAttr (SDL_Display->RastPort.BitMap, CYBRMATTR_PIXFMT) ==
+        PIXFMT_LUT8 || bpp == 8) {
+        int ncolors, i;
+        D (bug ("XPixels palette allocation...\n"));
 
-	    /* Allocate the pixel flags */
+        /* Allocate the pixel flags */
 
-	    if(bpp==8)
-		ncolors=256;
-	    else
-		ncolors = 1 << screen->format->BitsPerPixel;
+        if (bpp == 8)
+            ncolors = 256;
+        else
+            ncolors = 1 << screen->format->BitsPerPixel;
 
-	    SDL_XPixels = (Sint32 *)SDL_malloc(ncolors * sizeof(Sint32));
+        SDL_XPixels = (Sint32 *) SDL_malloc (ncolors * sizeof (Sint32));
 
-	    if(SDL_XPixels == NULL) {
-		SDL_OutOfMemory();
-		return -1;
-	    }
+        if (SDL_XPixels == NULL) {
+            SDL_OutOfMemory ();
+            return -1;
+        }
 
 
-	    for(i=0;i<ncolors;i++)
-		    SDL_XPixels[i]=-1;
+        for (i = 0; i < ncolors; i++)
+            SDL_XPixels[i] = -1;
 
-	    /* always allocate a private colormap on non-default visuals */
-	    if(bpp==8)
-		flags |= SDL_HWPALETTE;
+        /* always allocate a private colormap on non-default visuals */
+        if (bpp == 8)
+            flags |= SDL_HWPALETTE;
 
-	    if ( flags & SDL_HWPALETTE )
-			screen->flags |= SDL_HWPALETTE;
-	} 
+        if (flags & SDL_HWPALETTE)
+            screen->flags |= SDL_HWPALETTE;
+    }
 
-	/* resize the (possibly new) window manager window */
+    /* resize the (possibly new) window manager window */
 
-	/* Create (or use) the X11 display window */
+    /* Create (or use) the X11 display window */
 
-	if ( !SDL_windowid ) {
-			if( flags & SDL_FULLSCREEN )
-			{
-				SDL_Window = OpenWindowTags(NULL,WA_Width,w,WA_Height,h,
-											WA_Flags,WFLG_ACTIVATE|WFLG_RMBTRAP|WFLG_BORDERLESS|WFLG_BACKDROP|WFLG_REPORTMOUSE,
-											WA_IDCMP,IDCMP_RAWKEY|IDCMP_MOUSEBUTTONS|IDCMP_MOUSEMOVE,
-											WA_CustomScreen,(ULONG)SDL_Display,
-											TAG_DONE);
+    if (!SDL_windowid) {
+        if (flags & SDL_FULLSCREEN) {
+            SDL_Window = OpenWindowTags (NULL, WA_Width, w, WA_Height, h,
+                                         WA_Flags,
+                                         WFLG_ACTIVATE | WFLG_RMBTRAP |
+                                         WFLG_BORDERLESS | WFLG_BACKDROP |
+                                         WFLG_REPORTMOUSE, WA_IDCMP,
+                                         IDCMP_RAWKEY | IDCMP_MOUSEBUTTONS
+                                         | IDCMP_MOUSEMOVE,
+                                         WA_CustomScreen,
+                                         (ULONG) SDL_Display, TAG_DONE);
 
-				D(bug("Opening backdrop window %ldx%ld on display %lx!\n",w,h,SDL_Display));
-			}
-			else
-			{
-				/* Create GimmeZeroZero window when OpenGL is used */
-				unsigned long gzz = FALSE;
-				if( flags & SDL_INTERNALOPENGL ) {
-					gzz = TRUE;
-				}
+            D (bug
+               ("Opening backdrop window %ldx%ld on display %lx!\n", w, h,
+                SDL_Display));
+        } else {
+            /* Create GimmeZeroZero window when OpenGL is used */
+            unsigned long gzz = FALSE;
+            if (flags & SDL_INTERNALOPENGL) {
+                gzz = TRUE;
+            }
 
-				SDL_Window = OpenWindowTags(NULL,WA_InnerWidth,w,WA_InnerHeight,h,
-											WA_Flags,WFLG_REPORTMOUSE|WFLG_ACTIVATE|WFLG_RMBTRAP | ((flags&SDL_NOFRAME) ? 0 : (WFLG_DEPTHGADGET|WFLG_CLOSEGADGET|WFLG_DRAGBAR | ((flags&SDL_RESIZABLE) ? WFLG_SIZEGADGET|WFLG_SIZEBBOTTOM : 0))),
-											WA_IDCMP,IDCMP_RAWKEY|IDCMP_CLOSEWINDOW|IDCMP_MOUSEBUTTONS|IDCMP_NEWSIZE|IDCMP_MOUSEMOVE,
-											WA_PubScreen,(ULONG)SDL_Display,
-											WA_GimmeZeroZero, gzz,
-														TAG_DONE);
-				D(bug("Opening WB window of size: %ldx%ld!\n",w,h));
-			}
-
-		if(!SDL_Window)
-			return -1;
-	}
-
-	this->hidden->BytesPerPixel=GetCyberMapAttr(SDL_Window->RPort->BitMap,CYBRMATTR_BPPIX);
+            SDL_Window =
+                OpenWindowTags (NULL, WA_InnerWidth, w, WA_InnerHeight, h,
+                                WA_Flags,
+                                WFLG_REPORTMOUSE | WFLG_ACTIVATE |
+                                WFLG_RMBTRAP | ((flags & SDL_NOFRAME) ? 0
+                                                : (WFLG_DEPTHGADGET |
+                                                   WFLG_CLOSEGADGET |
+                                                   WFLG_DRAGBAR |
+                                                   ((flags &
+                                                     SDL_RESIZABLE) ?
+                                                    WFLG_SIZEGADGET |
+                                                    WFLG_SIZEBBOTTOM :
+                                                    0))), WA_IDCMP,
+                                IDCMP_RAWKEY | IDCMP_CLOSEWINDOW |
+                                IDCMP_MOUSEBUTTONS | IDCMP_NEWSIZE |
+                                IDCMP_MOUSEMOVE, WA_PubScreen,
+                                (ULONG) SDL_Display, WA_GimmeZeroZero,
+                                gzz, TAG_DONE);
+            D (bug ("Opening WB window of size: %ldx%ld!\n", w, h));
+        }
 
-	if(screen->flags & SDL_DOUBLEBUF)
-	{
-		if(SDL_RastPort=SDL_malloc(sizeof(struct RastPort)))
-		{
-			InitRastPort(SDL_RastPort);
-			SDL_RastPort->BitMap=this->hidden->SB[1]->sb_BitMap;
-		}
-		else
-			return -1;
-	}
-	else SDL_RastPort=SDL_Window->RPort;
+        if (!SDL_Window)
+            return -1;
+    }
+
+    this->hidden->BytesPerPixel =
+        GetCyberMapAttr (SDL_Window->RPort->BitMap, CYBRMATTR_BPPIX);
 
-	if(flags&SDL_HWSURFACE)
-		screen->flags|=SDL_HWSURFACE;
+    if (screen->flags & SDL_DOUBLEBUF) {
+        if (SDL_RastPort = SDL_malloc (sizeof (struct RastPort))) {
+            InitRastPort (SDL_RastPort);
+            SDL_RastPort->BitMap = this->hidden->SB[1]->sb_BitMap;
+        } else
+            return -1;
+    } else
+        SDL_RastPort = SDL_Window->RPort;
 
-	if( !SDL_windowid ) {
-	    CGX_SetSizeHints(this, w, h, flags);
-	}
+    if (flags & SDL_HWSURFACE)
+        screen->flags |= SDL_HWSURFACE;
 
-	/* Set our colormaps when not setting a GL mode */
+    if (!SDL_windowid) {
+        CGX_SetSizeHints (this, w, h, flags);
+    }
+
+    /* Set our colormaps when not setting a GL mode */
 /*
 	if ( ! (flags & SDL_INTERNALOPENGL) ) {
 		XSetWindowColormap(SDL_Display, SDL_Window, SDL_XColorMap);
 	}
 */
 
-	/* Map them both and go fullscreen, if requested */
-	if ( ! SDL_windowid ) {
-		if ( flags & SDL_FULLSCREEN ) {
-			screen->flags |= SDL_FULLSCREEN;
-			currently_fullscreen=1;
-//			CGX_EnterFullScreen(this); Ci siamo gia'!
-		} else {
-			screen->flags &= ~SDL_FULLSCREEN;
-		}
-	}
-	screen->w = w;
-	screen->h = h;
-	screen->pitch = SDL_CalculatePitch(screen);
-	CGX_ResizeImage(this, screen, flags);
+    /* Map them both and go fullscreen, if requested */
+    if (!SDL_windowid) {
+        if (flags & SDL_FULLSCREEN) {
+            screen->flags |= SDL_FULLSCREEN;
+            currently_fullscreen = 1;
+//                      CGX_EnterFullScreen(this); Ci siamo gia'!
+        } else {
+            screen->flags &= ~SDL_FULLSCREEN;
+        }
+    }
+    screen->w = w;
+    screen->h = h;
+    screen->pitch = SDL_CalculatePitch (screen);
+    CGX_ResizeImage (this, screen, flags);
 
-	/* Make OpenGL Context if needed*/
-	if(flags & SDL_INTERNALOPENGL) {
-		if(this->gl_data->gl_active == 0) {
-			if(CGX_GL_Init(this) < 0)
-				return -1;
-			else
-				screen->flags |= SDL_INTERNALOPENGL;
-		}
-		else {
-			if(CGX_GL_Update(this) < 0)
-				return -1;
-			else
-				screen->flags |= SDL_INTERNALOPENGL;
-		}
-	}
+    /* Make OpenGL Context if needed */
+    if (flags & SDL_INTERNALOPENGL) {
+        if (this->gl_data->gl_active == 0) {
+            if (CGX_GL_Init (this) < 0)
+                return -1;
+            else
+                screen->flags |= SDL_INTERNALOPENGL;
+        } else {
+            if (CGX_GL_Update (this) < 0)
+                return -1;
+            else
+                screen->flags |= SDL_INTERNALOPENGL;
+        }
+    }
 }
 
-int CGX_ResizeWindow(_THIS,
-			SDL_Surface *screen, int w, int h, Uint32 flags)
+int
+CGX_ResizeWindow (_THIS, SDL_Surface * screen, int w, int h, Uint32 flags)
 {
-	D(bug("CGX_ResizeWindow\n"));
+    D (bug ("CGX_ResizeWindow\n"));
 
-	if ( ! SDL_windowid ) {
-		/* Resize the window manager window */
-		CGX_SetSizeHints(this, w, h, flags);
+    if (!SDL_windowid) {
+        /* Resize the window manager window */
+        CGX_SetSizeHints (this, w, h, flags);
 
-		ChangeWindowBox(SDL_Window,SDL_Window->LeftEdge,SDL_Window->TopEdge, w+SDL_Window->BorderLeft+SDL_Window->BorderRight,
-					h+SDL_Window->BorderTop+SDL_Window->BorderBottom);
+        ChangeWindowBox (SDL_Window, SDL_Window->LeftEdge,
+                         SDL_Window->TopEdge,
+                         w + SDL_Window->BorderLeft +
+                         SDL_Window->BorderRight,
+                         h + SDL_Window->BorderTop +
+                         SDL_Window->BorderBottom);
 
-		screen->w = w;
-		screen->h = h;
-		screen->pitch = SDL_CalculatePitch(screen);
-		CGX_ResizeImage(this, screen, flags);
-	}
-	return(0);
+        screen->w = w;
+        screen->h = h;
+        screen->pitch = SDL_CalculatePitch (screen);
+        CGX_ResizeImage (this, screen, flags);
+    }
+    return (0);
 }
 
-static SDL_Surface *CGX_SetVideoMode(_THIS, SDL_Surface *current,
-				int width, int height, int bpp, Uint32 flags)
+static SDL_Surface *
+CGX_SetVideoMode (_THIS, SDL_Surface * current,
+                  int width, int height, int bpp, Uint32 flags)
 {
-	Uint32 saved_flags;
-	int needcreate=0;
+    Uint32 saved_flags;
+    int needcreate = 0;
 
-	D(bug("CGX_SetVideoMode current:%lx\n",current));
+    D (bug ("CGX_SetVideoMode current:%lx\n", current));
 
-	/* Lock the event thread, in multi-threading environments */
-	SDL_Lock_EventThread();
+    /* Lock the event thread, in multi-threading environments */
+    SDL_Lock_EventThread ();
 
 // Check if the window needs to be closed or can be resized
 
-	if( (flags&SDL_FULLSCREEN) || (current && current->flags&SDL_FULLSCREEN && !(flags&SDL_FULLSCREEN)))
-		needcreate=1;
+    if ((flags & SDL_FULLSCREEN)
+        || (current && current->flags & SDL_FULLSCREEN
+            && !(flags & SDL_FULLSCREEN)))
+        needcreate = 1;
 
 // Check if we need to close an already existing videomode...
 
-	if(current && current->flags&SDL_FULLSCREEN && !(flags&SDL_FULLSCREEN)) {
-		unsigned long i;
-		D(bug("Destroying image, window & screen!\n"));
+    if (current && current->flags & SDL_FULLSCREEN
+        && !(flags & SDL_FULLSCREEN)) {
+        unsigned long i;
+        D (bug ("Destroying image, window & screen!\n"));
 
-		CGX_DestroyImage(this,current);
-		CGX_DestroyWindow(this,current);
-		DestroyScreen(this);
-		GFX_Display=SDL_Display=LockPubScreen(NULL);
+        CGX_DestroyImage (this, current);
+        CGX_DestroyWindow (this, current);
+        DestroyScreen (this);
+        GFX_Display = SDL_Display = LockPubScreen (NULL);
 
-		bpp=this->hidden->depth=GetCyberMapAttr(SDL_Display->RastPort.BitMap,CYBRMATTR_DEPTH);
+        bpp = this->hidden->depth =
+            GetCyberMapAttr (SDL_Display->RastPort.BitMap, CYBRMATTR_DEPTH);
 
-		for ( i = 0; i < this->hidden->nvisuals; i++ ) {
-			if ( this->hidden->visuals[i].depth == bpp ) /* era .depth */
-				break;
-		}
-		if ( i == this->hidden->nvisuals ) {
-			SDL_SetError("No matching visual for requested depth");
-			return NULL;	/* should never happen */
-		}
-		SDL_Visual = this->hidden->visuals[i].visual;
+        for (i = 0; i < this->hidden->nvisuals; i++) {
+            if (this->hidden->visuals[i].depth == bpp)  /* era .depth */
+                break;
+        }
+        if (i == this->hidden->nvisuals) {
+            SDL_SetError ("No matching visual for requested depth");
+            return NULL;        /* should never happen */
+        }
+        SDL_Visual = this->hidden->visuals[i].visual;
 
-		D(bug("Setting screen depth to: %ld\n",this->hidden->depth));
+        D (bug ("Setting screen depth to: %ld\n", this->hidden->depth));
 
-	}
-	/* Check the combination of flags we were passed */
-	if ( flags & SDL_FULLSCREEN ) {
-		int i;
+    }
+    /* Check the combination of flags we were passed */
+    if (flags & SDL_FULLSCREEN) {
+        int i;
 
-		/* Clear fullscreen flag if not supported */
-		if ( SDL_windowid ) {
-			flags &= ~SDL_FULLSCREEN;
-		}
-		else if(current && current->flags&SDL_FULLSCREEN ) {
-			if(current->w!=width ||
-				current->h!=height ||
-				(this->hidden && this->hidden->depth!=bpp))
-			{
-				D(bug("Deleting previous window...\n"));
-				CGX_DestroyImage(this,current);
-				CGX_DestroyWindow(this,current);
-				DestroyScreen(this);
-				goto buildnewscreen;
-			}
-		}
-		else
-buildnewscreen:
-		{
-			Uint32 okid=BestCModeIDTags(CYBRBIDTG_NominalWidth,width,
-				CYBRBIDTG_NominalHeight,height,
-				CYBRBIDTG_Depth,bpp,
-				TAG_DONE);
+        /* Clear fullscreen flag if not supported */
+        if (SDL_windowid) {
+            flags &= ~SDL_FULLSCREEN;
+        } else if (current && current->flags & SDL_FULLSCREEN) {
+            if (current->w != width ||
+                current->h != height ||
+                (this->hidden && this->hidden->depth != bpp)) {
+                D (bug ("Deleting previous window...\n"));
+                CGX_DestroyImage (this, current);
+                CGX_DestroyWindow (this, current);
+                DestroyScreen (this);
+                goto buildnewscreen;
+            }
+        } else
+          buildnewscreen:
+        {
+            Uint32 okid = BestCModeIDTags (CYBRBIDTG_NominalWidth, width,
+                                           CYBRBIDTG_NominalHeight,
+                                           height,
+                                           CYBRBIDTG_Depth, bpp,
+                                           TAG_DONE);
 
-			GFX_Display=NULL;
+            GFX_Display = NULL;
+
+            D (bug ("Opening screen...\n"));
 
-			D(bug("Opening screen...\n"));
-
-			if(okid!=INVALID_ID)
-				GFX_Display=OpenScreenTags(NULL,
-								SA_Width,width,
-								SA_Height,height,
-								SA_Quiet,TRUE,SA_ShowTitle,FALSE,
-								SA_Depth,bpp,
-								SA_DisplayID,okid,
-								TAG_DONE);
+            if (okid != INVALID_ID)
+                GFX_Display = OpenScreenTags (NULL,
+                                              SA_Width, width,
+                                              SA_Height, height,
+                                              SA_Quiet, TRUE,
+                                              SA_ShowTitle, FALSE,
+                                              SA_Depth, bpp, SA_DisplayID,
+                                              okid, TAG_DONE);
 
-			if(!GFX_Display) {
-				GFX_Display=SDL_Display;
-				flags &= ~SDL_FULLSCREEN;
-				flags &= ~SDL_DOUBLEBUF;
-			}
-			else {
-				UnlockPubScreen(NULL,SDL_Display);
-				SDL_Display=GFX_Display;
-	
-				D(bug("Screen opened.\n"));
+            if (!GFX_Display) {
+                GFX_Display = SDL_Display;
+                flags &= ~SDL_FULLSCREEN;
+                flags &= ~SDL_DOUBLEBUF;
+            } else {
+                UnlockPubScreen (NULL, SDL_Display);
+                SDL_Display = GFX_Display;
+
+                D (bug ("Screen opened.\n"));
 
-				if(flags&SDL_DOUBLEBUF) {
-					int ok=0;
-					D(bug("Start of DBuffering allocations...\n"));
+                if (flags & SDL_DOUBLEBUF) {
+                    int ok = 0;
+                    D (bug ("Start of DBuffering allocations...\n"));
 
-					if(this->hidden->SB[0]=AllocScreenBuffer(SDL_Display,NULL,SB_SCREEN_BITMAP)) {
+                    if (this->hidden->SB[0] =
+                        AllocScreenBuffer (SDL_Display, NULL,
+                                           SB_SCREEN_BITMAP)) {
+
+                        if (this->hidden->SB[1] =
+                            AllocScreenBuffer (SDL_Display, NULL, 0L)) {
+                            extern struct MsgPort *safeport, *dispport;
 
-						if(this->hidden->SB[1]=AllocScreenBuffer(SDL_Display,NULL,0L)) {
-							extern struct MsgPort *safeport,*dispport;
-
-							safeport=CreateMsgPort();
-							dispport=CreateMsgPort();
+                            safeport = CreateMsgPort ();
+                            dispport = CreateMsgPort ();
 
-							if(!safeport || !dispport) {
-								if(safeport) {
-									DeleteMsgPort(safeport);
-									safeport=NULL;
-								}
-								if(dispport) {
-									DeleteMsgPort(dispport);
-									dispport=NULL;
-								}
-								FreeScreenBuffer(SDL_Display,this->hidden->SB[0]);
-								FreeScreenBuffer(SDL_Display,this->hidden->SB[1]);
-							}
-							else {
-								extern ULONG safe_sigbit,disp_sigbit;
-								int i;
+                            if (!safeport || !dispport) {
+                                if (safeport) {
+                                    DeleteMsgPort (safeport);
+                                    safeport = NULL;
+                                }
+                                if (dispport) {
+                                    DeleteMsgPort (dispport);
+                                    dispport = NULL;
+                                }
+                                FreeScreenBuffer (SDL_Display,
+                                                  this->hidden->SB[0]);
+                                FreeScreenBuffer (SDL_Display,
+                                                  this->hidden->SB[1]);
+                            } else {
+                                extern ULONG safe_sigbit, disp_sigbit;
+                                int i;
 
-								safe_sigbit=1L<< safeport->mp_SigBit;
-								disp_sigbit=1L<< dispport->mp_SigBit;
+                                safe_sigbit = 1L << safeport->mp_SigBit;
+                                disp_sigbit = 1L << dispport->mp_SigBit;
 
-								for(i=0;i<2;i++) {
-									this->hidden->SB[i]->sb_DBufInfo->dbi_SafeMessage.mn_ReplyPort=safeport;
-									this->hidden->SB[i]->sb_DBufInfo->dbi_DispMessage.mn_ReplyPort=dispport;
-								}
+                                for (i = 0; i < 2; i++) {
+                                    this->hidden->SB[i]->
+                                        sb_DBufInfo->
+                                        dbi_SafeMessage.
+                                        mn_ReplyPort = safeport;
+                                    this->hidden->SB[i]->
+                                        sb_DBufInfo->
+                                        dbi_DispMessage.
+                                        mn_ReplyPort = dispport;
+                                }
 
-								ok=1;
-								D(bug("Dbuffering enabled!\n"));
-								this->hidden->dbuffer=1;
-								current->flags|=SDL_DOUBLEBUF;
-							}
-						}
-						else {
-							FreeScreenBuffer(SDL_Display,this->hidden->SB[1]);
-							this->hidden->SB[0]=NULL;
-						}
-					}
+                                ok = 1;
+                                D (bug ("Dbuffering enabled!\n"));
+                                this->hidden->dbuffer = 1;
+                                current->flags |= SDL_DOUBLEBUF;
+                            }
+                        } else {
+                            FreeScreenBuffer (SDL_Display,
+                                              this->hidden->SB[1]);
+                            this->hidden->SB[0] = NULL;
+                        }
+                    }
 
-					if(!ok)
-						flags&=~SDL_DOUBLEBUF;
-				}
-			}
+                    if (!ok)
+                        flags &= ~SDL_DOUBLEBUF;
+                }
+            }
 
-			if(GetCyberMapAttr(SDL_Display->RastPort.BitMap,CYBRMATTR_DEPTH)==bpp)
-				this->hidden->same_format=1;
-		}
+            if (GetCyberMapAttr
+                (SDL_Display->RastPort.BitMap, CYBRMATTR_DEPTH) == bpp)
+                this->hidden->same_format = 1;
+        }
 
-		bpp=this->hidden->depth=GetCyberMapAttr(SDL_Display->RastPort.BitMap,CYBRMATTR_DEPTH);
-		D(bug("Setting screen depth to: %ld\n",this->hidden->depth));
+        bpp = this->hidden->depth =
+            GetCyberMapAttr (SDL_Display->RastPort.BitMap, CYBRMATTR_DEPTH);
+        D (bug ("Setting screen depth to: %ld\n", this->hidden->depth));
 
-		for ( i = 0; i < this->hidden->nvisuals; i++ )
-			if ( this->hidden->visuals[i].depth == bpp ) /* era .depth */
-				break;
+        for (i = 0; i < this->hidden->nvisuals; i++)
+            if (this->hidden->visuals[i].depth == bpp)  /* era .depth */
+                break;
 
-		if ( i == this->hidden->nvisuals ) {
-			SDL_SetError("No matching visual for requested depth");
-			return NULL;	/* should never happen */
-		}
-		SDL_Visual = this->hidden->visuals[i].visual;
+        if (i == this->hidden->nvisuals) {
+            SDL_SetError ("No matching visual for requested depth");
+            return NULL;        /* should never happen */
+        }
+        SDL_Visual = this->hidden->visuals[i].visual;
 
-	}
+    }
 
-	/* Set up the X11 window */
-	saved_flags = current->flags;
+    /* Set up the X11 window */
+    saved_flags = current->flags;
 
-	if (SDL_Window && (saved_flags&SDL_INTERNALOPENGL) == (flags&SDL_INTERNALOPENGL)
-	    && bpp == current->format->BitsPerPixel && !needcreate) {
-		if (CGX_ResizeWindow(this, current, width, height, flags) < 0) {
-			current = NULL;
-			goto done;
-		}
-	} else {
-		if (CGX_CreateWindow(this,current,width,height,bpp,flags) < 0) {
-			current = NULL;
-			goto done;
-		}
-	}
+    if (SDL_Window
+        && (saved_flags & SDL_INTERNALOPENGL) == (flags & SDL_INTERNALOPENGL)
+        && bpp == current->format->BitsPerPixel && !needcreate) {
+        if (CGX_ResizeWindow (this, current, width, height, flags) < 0) {
+            current = NULL;
+            goto done;
+        }
+    } else {
+        if (CGX_CreateWindow (this, current, width, height, bpp, flags) < 0) {
+            current = NULL;
+            goto done;
+        }
+    }
 
 #if 0
-	/* Set up the new mode framebuffer */
-	if ( ((current->w != width) || (current->h != height)) ||
-             ((saved_flags&SDL_INTERNALOPENGL) != (flags&SDL_INTERNALOPENGL)) ) {
-		current->w = width;
-		current->h = height;
-		current->pitch = SDL_CalculatePitch(current);
-		CGX_ResizeImage(this, current, flags);
-	}
+    /* Set up the new mode framebuffer */
+    if (((current->w != width) || (current->h != height)) ||
+        ((saved_flags & SDL_INTERNALOPENGL) != (flags & SDL_INTERNALOPENGL)))
+    {
+        current->w = width;
+        current->h = height;
+        current->pitch = SDL_CalculatePitch (current);
+        CGX_ResizeImage (this, current, flags);
+    }
 #endif
 
-	current->flags |= (flags&SDL_RESIZABLE); // Resizable only if the user asked it
+    current->flags |= (flags & SDL_RESIZABLE);  // Resizable only if the user asked it
 
   done:
-	/* Release the event thread */
-	SDL_Unlock_EventThread();
+    /* Release the event thread */
+    SDL_Unlock_EventThread ();
 
-	/* We're done! */
-	return(current);
+    /* We're done! */
+    return (current);
 }
 
-static int CGX_ToggleFullScreen(_THIS, int on)
+static int
+CGX_ToggleFullScreen (_THIS, int on)
 {
-	Uint32 event_thread;
+    Uint32 event_thread;
 
-	/* Don't switch if we don't own the window */
-	if ( SDL_windowid ) {
-		return(0);
-	}
+    /* Don't switch if we don't own the window */
+    if (SDL_windowid) {
+        return (0);
+    }
 
-	/* Don't lock if we are the event thread */
-	event_thread = SDL_EventThreadID();
-	if ( event_thread && (SDL_ThreadID() == event_thread) ) {
-		event_thread = 0;
-	}
-	if ( event_thread ) {
-		SDL_Lock_EventThread();
-	}
-	if ( on ) {
-		this->screen->flags |= SDL_FULLSCREEN;
-		CGX_EnterFullScreen(this);
-	} else {
-		this->screen->flags &= ~SDL_FULLSCREEN;
-		CGX_LeaveFullScreen(this);
-	}
+    /* Don't lock if we are the event thread */
+    event_thread = SDL_EventThreadID ();
+    if (event_thread && (SDL_ThreadID () == event_thread)) {
+        event_thread = 0;
+    }
+    if (event_thread) {
+        SDL_Lock_EventThread ();
+    }
+    if (on) {
+        this->screen->flags |= SDL_FULLSCREEN;
+        CGX_EnterFullScreen (this);
+    } else {
+        this->screen->flags &= ~SDL_FULLSCREEN;
+        CGX_LeaveFullScreen (this);
+    }
 
-	CGX_RefreshDisplay(this);
-	if ( event_thread ) {
-		SDL_Unlock_EventThread();
-	}
+    CGX_RefreshDisplay (this);
+    if (event_thread) {
+        SDL_Unlock_EventThread ();
+    }
 
-	SDL_ResetKeyboard();
+    SDL_ResetKeyboard ();
 
-	return(1);
+    return (1);
 }
 
-static void SetSingleColor(Uint32 fmt, unsigned char r, unsigned char g, unsigned char b, unsigned char *c)
+static void
+SetSingleColor (Uint32 fmt, unsigned char r, unsigned char g, unsigned char b,
+                unsigned char *c)
 {
-	switch(fmt)
-	{
-		case PIXFMT_BGR15:
-		case PIXFMT_RGB15PC:
-			{
-				Uint16 *t=(Uint16 *)c;
-				*t=(r>>3) | ((g>>3)<<5) | ((b>>3)<<10) ;
-			}
-			break;
-		case PIXFMT_RGB15:
-		case PIXFMT_BGR15PC:
-			{
-				Uint16 *t=(Uint16 *)c;
-				*t=(b>>3) | ((g>>3)<<5) | ((r>>3)<<10) ;
-			}
-			break;
-		case PIXFMT_BGR16PC:
-		case PIXFMT_RGB16:
-			{
-				Uint16 *t=(Uint16 *)c;
-				*t=(b>>3) | ((g>>2)<<5) | ((r>>3)<<11) ;
-			}
-			break;
-		case PIXFMT_BGR16:
-		case PIXFMT_RGB16PC:
-			{
-				Uint16 *t=(Uint16 *)c;
-				*t=(r>>3) | ((g>>2)<<5) | ((b>>3)<<11) ;
-			}
-			break;
-		case PIXFMT_RGB24:
-			c[0]=r;
-			c[1]=g;
-			c[2]=b;
-			c[3]=0;
-			break;
-		case PIXFMT_BGR24:
-			c[0]=b;
-			c[1]=g;
-			c[2]=r;
-			c[3]=0;
-			break;
-		case PIXFMT_ARGB32:
-			c[0]=0;
-			c[1]=r;
-			c[2]=g;
-			c[3]=b;
-			break;
-		case PIXFMT_BGRA32:
-			c[0]=b;
-			c[1]=g;
-			c[2]=r;
-			c[3]=0;
-			break;
-		case PIXFMT_RGBA32:
-			c[0]=r;
-			c[1]=g;
-			c[2]=b;
-			c[3]=0;
-			break;
+    switch (fmt) {
+    case PIXFMT_BGR15:
+    case PIXFMT_RGB15PC:
+        {
+            Uint16 *t = (Uint16 *) c;
+            *t = (r >> 3) | ((g >> 3) << 5) | ((b >> 3) << 10);
+        }
+        break;
+    case PIXFMT_RGB15:
+    case PIXFMT_BGR15PC:
+        {
+            Uint16 *t = (Uint16 *) c;
+            *t = (b >> 3) | ((g >> 3) << 5) | ((r >> 3) << 10);
+        }
+        break;
+    case PIXFMT_BGR16PC:
+    case PIXFMT_RGB16:
+        {
+            Uint16 *t = (Uint16 *) c;
+            *t = (b >> 3) | ((g >> 2) << 5) | ((r >> 3) << 11);
+        }
+        break;
+    case PIXFMT_BGR16:
+    case PIXFMT_RGB16PC:
+        {
+            Uint16 *t = (Uint16 *) c;
+            *t = (r >> 3) | ((g >> 2) << 5) | ((b >> 3) << 11);
+        }
+        break;
+    case PIXFMT_RGB24:
+        c[0] = r;
+        c[1] = g;
+        c[2] = b;
+        c[3] = 0;
+        break;
+    case PIXFMT_BGR24:
+        c[0] = b;
+        c[1] = g;
+        c[2] = r;
+        c[3] = 0;
+        break;
+    case PIXFMT_ARGB32:
+        c[0] = 0;
+        c[1] = r;
+        c[2] = g;
+        c[3] = b;
+        break;
+    case PIXFMT_BGRA32:
+        c[0] = b;
+        c[1] = g;
+        c[2] = r;
+        c[3] = 0;
+        break;
+    case PIXFMT_RGBA32:
+        c[0] = r;
+        c[1] = g;
+        c[2] = b;
+        c[3] = 0;
+        break;
 
-		default:
-			D(bug("Error, SetSingleColor with PIXFMT %ld!\n",fmt));
-	}
+    default:
+        D (bug ("Error, SetSingleColor with PIXFMT %ld!\n", fmt));
+    }
 }
 
 /* Update the current mouse state and position */
-static void CGX_UpdateMouse(_THIS)
+static void
+CGX_UpdateMouse (_THIS)
 {
-	/* Lock the event thread, in multi-threading environments */
-	SDL_Lock_EventThread();
+    /* Lock the event thread, in multi-threading environments */
+    SDL_Lock_EventThread ();
 
-	if(currently_fullscreen)
-	{
-			SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS);
-			SDL_PrivateMouseMotion(0, 0, SDL_Display->MouseX, SDL_Display->MouseY);
-	}
-	else
-	{
-		if(	SDL_Display->MouseX>=(SDL_Window->LeftEdge+SDL_Window->BorderLeft) && SDL_Display->MouseX<(SDL_Window->LeftEdge+SDL_Window->Width-SDL_Window->BorderRight) &&
-			SDL_Display->MouseY>=(SDL_Window->TopEdge+SDL_Window->BorderLeft) && SDL_Display->MouseY<(SDL_Window->TopEdge+SDL_Window->Height-SDL_Window->BorderBottom)
-			)
-		{
-			SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS);
-			SDL_PrivateMouseMotion(0, 0, SDL_Display->MouseX-SDL_Window->LeftEdge-SDL_Window->BorderLeft,
-										SDL_Display->MouseY-SDL_Window->TopEdge-SDL_Window->BorderTop);
-		}
-		else
-		{
-			SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS);
-		}
-	}
-	SDL_Unlock_EventThread();
+    if (currently_fullscreen) {
+        SDL_PrivateAppActive (1, SDL_APPMOUSEFOCUS);
+        SDL_PrivateMouseMotion (0, 0, SDL_Display->MouseX,
+                                SDL_Display->MouseY);
+    } else {
+        if (SDL_Display->MouseX >=
+            (SDL_Window->LeftEdge + SDL_Window->BorderLeft)
+            && SDL_Display->MouseX <
+            (SDL_Window->LeftEdge + SDL_Window->Width -
+             SDL_Window->BorderRight)
+            && SDL_Display->MouseY >=
+            (SDL_Window->TopEdge + SDL_Window->BorderLeft)
+            && SDL_Display->MouseY <
+            (SDL_Window->TopEdge + SDL_Window->Height -
+             SDL_Window->BorderBottom)) {
+            SDL_PrivateAppActive (1, SDL_APPMOUSEFOCUS);
+            SDL_PrivateMouseMotion (0, 0,
+                                    SDL_Display->MouseX -
+                                    SDL_Window->LeftEdge -
+                                    SDL_Window->BorderLeft,
+                                    SDL_Display->MouseY -
+                                    SDL_Window->TopEdge -
+                                    SDL_Window->BorderTop);
+        } else {
+            SDL_PrivateAppActive (0, SDL_APPMOUSEFOCUS);
+        }
+    }
+    SDL_Unlock_EventThread ();
 }
 
-static int CGX_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
+static int
+CGX_SetColors (_THIS, int firstcolor, int ncolors, SDL_Color * colors)
 {
-	int      i;
+    int i;
 
-	/* Check to make sure we have a colormap allocated */
+    /* Check to make sure we have a colormap allocated */
 
-	/* It's easy if we have a hidden colormap */
-	if ( (this->screen->flags & SDL_HWPALETTE) && currently_fullscreen )
-	{
-		ULONG  xcmap[256*3+2];
+    /* It's easy if we have a hidden colormap */
+    if ((this->screen->flags & SDL_HWPALETTE) && currently_fullscreen) {
+        ULONG xcmap[256 * 3 + 2];
 
-		xcmap[0]=(ncolors<<16);
-		xcmap[0]+=firstcolor;
+        xcmap[0] = (ncolors << 16);
+        xcmap[0] += firstcolor;
 
-//		D(bug("Setting %ld colors on an HWPALETTE screen\n",ncolors));
+//              D(bug("Setting %ld colors on an HWPALETTE screen\n",ncolors));
 
-		for ( i=0; i<ncolors; i++ ) {
-			xcmap[i*3+1] = colors[i+firstcolor].r<<24;
-			xcmap[i*3+2] = colors[i+firstcolor].g<<24;
-			xcmap[i*3+3] = colors[i+firstcolor].b<<24;
-		}
-		xcmap[ncolors*3+1]=0;
-		LoadRGB32(&GFX_Display->ViewPort,xcmap);
-	} else {
+        for (i = 0; i < ncolors; i++) {
+            xcmap[i * 3 + 1] = colors[i + firstcolor].r << 24;
+            xcmap[i * 3 + 2] = colors[i + firstcolor].g << 24;
+            xcmap[i * 3 + 3] = colors[i + firstcolor].b << 24;
+        }
+        xcmap[ncolors * 3 + 1] = 0;
+        LoadRGB32 (&GFX_Display->ViewPort, xcmap);
+    } else {
 // XPixels are not needed on 8bit screen with hwpalette
-		unsigned long pixel;
+        unsigned long pixel;
 
-		if ( SDL_XPixels == NULL ) {
-			D(bug("SetColors without colormap!"));
-			return(0);
-		}
+        if (SDL_XPixels == NULL) {
+            D (bug ("SetColors without colormap!"));
+            return (0);
+        }
+
+        if (this->hidden->depth == 8) {
+// In this case I have to unalloc and realloc the full palette
+            D (bug ("Obtaining %ld colors on the screen\n", ncolors));
 
-		if(this->hidden->depth==8)
-		{
-// In this case I have to unalloc and realloc the full palette
-			D(bug("Obtaining %ld colors on the screen\n",ncolors));
+            /* Free existing allocated colors */
+            for (pixel = 0;
+                 pixel < this->screen->format->palette->ncolors; ++pixel) {
+                if (SDL_XPixels[pixel] >= 0)
+                    ReleasePen (GFX_Display->ViewPort.ColorMap,
+                                SDL_XPixels[pixel]);
+            }
 
-		/* Free existing allocated colors */
-			for ( pixel=0; pixel<this->screen->format->palette->ncolors; ++pixel ) {
-				if(SDL_XPixels[pixel]>=0)
-					ReleasePen(GFX_Display->ViewPort.ColorMap,SDL_XPixels[pixel]);
-			}
+            /* Try to allocate all the colors */
+            for (i = 0; i < this->screen->format->palette->ncolors; ++i) {
+                SDL_XPixels[i] =
+                    ObtainBestPenA (GFX_Display->ViewPort.ColorMap,
+                                    colors[i].r << 24,
+                                    colors[i].g << 24,
+                                    colors[i].b << 24, NULL);
+            }
+        } else {
+#ifndef USE_CGX_WRITELUTPIXEL
+            Uint32 fmt;
+            D (bug ("Preparing a conversion pixel table...\n"));
 
-		/* Try to allocate all the colors */
-			for ( i=0; i<this->screen->format->palette->ncolors; ++i ) {
-				SDL_XPixels[i]=ObtainBestPenA(GFX_Display->ViewPort.ColorMap,colors[i].r<<24,colors[i].g<<24,colors[i].b<<24,NULL);
-			}
-		}
-		else
-		{
-#ifndef USE_CGX_WRITELUTPIXEL
-			Uint32 fmt;
-			D(bug("Preparing a conversion pixel table...\n"));
+            fmt =
+                GetCyberMapAttr (SDL_Display->RastPort.BitMap,
+                                 CYBRMATTR_PIXFMT);
 
-			fmt=GetCyberMapAttr(SDL_Display->RastPort.BitMap,CYBRMATTR_PIXFMT);
-
-			for(i=0;i<ncolors;i++)
-			{
-				SetSingleColor(fmt,colors[firstcolor+i].r,colors[firstcolor+i].g,colors[firstcolor+i].b,(unsigned char *)&SDL_XPixels[firstcolor+i]);
-			}
+            for (i = 0; i < ncolors; i++) {
+                SetSingleColor (fmt, colors[firstcolor + i].r,
+                                colors[firstcolor + i].g,
+                                colors[firstcolor + i].b, (unsigned char *)
+                                &SDL_XPixels[firstcolor + i]);
+            }
 #else
-//			D(bug("Executing XPixel(%lx) remapping: (from %ld, %ld colors) first: r%ld g%ld b%ld\n",SDL_XPixels,firstcolor,ncolors,colors[firstcolor].r,colors[firstcolor].g,colors[firstcolor].b));
-			for(i=0;i<ncolors;i++)
-				SDL_XPixels[i+firstcolor]=(colors[firstcolor+i].r<<16)+(colors[firstcolor+i].g<<8)+colors[firstcolor+i].b;
+//                      D(bug("Executing XPixel(%lx) remapping: (from %ld, %ld colors) first: r%ld g%ld b%ld\n",SDL_XPixels,firstcolor,ncolors,colors[firstcolor].r,colors[firstcolor].g,colors[firstcolor].b));
+            for (i = 0; i < ncolors; i++)
+                SDL_XPixels[i + firstcolor] =
+                    (colors[firstcolor + i].r << 16) +
+                    (colors[firstcolor + i].g << 8) + colors[firstcolor +
+                                                             i].b;
 #endif
-		}
-	}
+        }
+    }
 
 // Actually it cannot fail!
 
-	return 1;
+    return 1;
 }
 
 /* Note:  If we are terminated, this could be called in the middle of
    another SDL video routine -- notably UpdateRects.
 */
-static void CGX_VideoQuit(_THIS)
+static void
+CGX_VideoQuit (_THIS)
 {
-	/* Shutdown everything that's still up */
-	/* The event thread should be done, so we can touch SDL_Display */
-	D(bug("CGX_VideoQuit\n"));
+    /* Shutdown everything that's still up */
+    /* The event thread should be done, so we can touch SDL_Display */
+    D (bug ("CGX_VideoQuit\n"));
 
-	if ( SDL_Display != NULL ) {
-		/* Clean up OpenGL */
-		if(this->gl_data->gl_active == 1) {
-			CGX_GL_Quit(this);
-		}
-		/* Start shutting down the windows */
-		D(bug("Destroying image...\n"));
-		CGX_DestroyImage(this, this->screen);
-		D(bug("Destroying window...\n"));
-		CGX_DestroyWindow(this, this->screen);
+    if (SDL_Display != NULL) {
+        /* Clean up OpenGL */
+        if (this->gl_data->gl_active == 1) {
+            CGX_GL_Quit (this);
+        }
+        /* Start shutting down the windows */
+        D (bug ("Destroying image...\n"));
+        CGX_DestroyImage (this, this->screen);
+        D (bug ("Destroying window...\n"));
+        CGX_DestroyWindow (this, this->screen);
 // Otherwise SDL_VideoQuit will try to free it!
-		SDL_VideoSurface=NULL;
+        SDL_VideoSurface = NULL;
 
-		CGX_FreeVideoModes(this);
+        CGX_FreeVideoModes (this);
 
-		/* Free that blank cursor */
-		if ( SDL_BlankCursor != NULL ) {
-			FreeMem(SDL_BlankCursor,16);
-			SDL_BlankCursor = NULL;
-		}
+        /* Free that blank cursor */
+        if (SDL_BlankCursor != NULL) {
+            FreeMem (SDL_BlankCursor, 16);
+            SDL_BlankCursor = NULL;
+        }
 
-		/* Close the X11 graphics connection */
-		this->hidden->same_format=0;
+        /* Close the X11 graphics connection */
+        this->hidden->same_format = 0;
 
-		D(bug("Destroying screen...\n"));
+        D (bug ("Destroying screen...\n"));
 
-		if ( GFX_Display != NULL )
-			DestroyScreen(this);
+        if (GFX_Display != NULL)
+            DestroyScreen (this);
 
-		/* Close the X11 display connection */
-		SDL_Display = NULL;
+        /* Close the X11 display connection */
+        SDL_Display = NULL;
 
-		/* Unload GL library after X11 shuts down */
-	}
+        /* Unload GL library after X11 shuts down */
+    }
 
-	D(bug("Closing libraries...\n"));
+    D (bug ("Closing libraries...\n"));
 
-	if( CyberGfxBase) {
-		CloseLibrary(CyberGfxBase);
-		CyberGfxBase=NULL;
-	}
+    if (CyberGfxBase) {
+        CloseLibrary (CyberGfxBase);
+        CyberGfxBase = NULL;
+    }
 
-	if (IntuitionBase) {
-		CloseLibrary((struct Library *)IntuitionBase);
-		IntuitionBase=NULL;
-	}
-	if (GfxBase) {
-		CloseLibrary((struct Library *)GfxBase);
-		GfxBase=NULL;
-	}
+    if (IntuitionBase) {
+        CloseLibrary ((struct Library *) IntuitionBase);
+        IntuitionBase = NULL;
+    }
+    if (GfxBase) {
+        CloseLibrary ((struct Library *) GfxBase);
+        GfxBase = NULL;
+    }
 
-	if ( this->screen && (this->screen->flags & SDL_HWSURFACE) ) {
-		/* Direct screen access, no memory buffer */
-		this->screen->pixels = NULL;
-	}
-	D(bug("End of CGX_VideoQuit.\n"));
+    if (this->screen && (this->screen->flags & SDL_HWSURFACE)) {
+        /* Direct screen access, no memory buffer */
+        this->screen->pixels = NULL;
+    }
+    D (bug ("End of CGX_VideoQuit.\n"));
 
 }
 
+/* vi: set ts=4 sw=4 expandtab: */