--- a/src/video/macrom/SDL_romvideo.c	Thu Jul 06 18:01:37 2006 +0000
+++ b/src/video/macrom/SDL_romvideo.c	Mon Jul 10 21:04:37 2006 +0000
@@ -53,24 +53,26 @@
 #include "../maccommon/SDL_macevents_c.h"
 
 /* Initialization/Query functions */
-static int ROM_VideoInit(_THIS, SDL_PixelFormat *vformat);
-static SDL_Rect **ROM_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags);
-static SDL_Surface *ROM_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags);
+static int ROM_VideoInit(_THIS, SDL_PixelFormat * vformat);
+static SDL_Rect **ROM_ListModes(_THIS, SDL_PixelFormat * format,
+                                Uint32 flags);
+static SDL_Surface *ROM_SetVideoMode(_THIS, SDL_Surface * current, int width,
+                                     int height, int bpp, Uint32 flags);
 static int ROM_SetColors(_THIS, int firstcolor, int ncolors,
-			 SDL_Color *colors);
+                         SDL_Color * colors);
 static void ROM_VideoQuit(_THIS);
 
 /* Hardware surface functions */
-static int ROM_AllocHWSurface(_THIS, SDL_Surface *surface);
-static int ROM_LockHWSurface(_THIS, SDL_Surface *surface);
-static void ROM_UnlockHWSurface(_THIS, SDL_Surface *surface);
-static void ROM_FreeHWSurface(_THIS, SDL_Surface *surface);
+static int ROM_AllocHWSurface(_THIS, SDL_Surface * surface);
+static int ROM_LockHWSurface(_THIS, SDL_Surface * surface);
+static void ROM_UnlockHWSurface(_THIS, SDL_Surface * surface);
+static void ROM_FreeHWSurface(_THIS, SDL_Surface * surface);
 
-#if !TARGET_API_MAC_CARBON /* This seems not to be available? -sts Aug 2000 */
+#if !TARGET_API_MAC_CARBON      /* This seems not to be available? -sts Aug 2000 */
 /* Saved state for the menu bar */
-static RgnHandle	gSaveGrayRgn = nil;
-static short		gSaveMenuBar = 0;
-static Boolean		gSaveCSVis = true;
+static RgnHandle gSaveGrayRgn = nil;
+static short gSaveMenuBar = 0;
+static Boolean gSaveCSVis = true;
 
 #if powerc
 /* Mixed mode glue to activate the 68K emulator and twiddle a register */
@@ -87,648 +89,674 @@
 		  0x0008, 0x2F10, 0x4E75, 0x0000, 0x0000, 0x0000 }
 
 /* ControlStrip inline glue for PowerPC */
-static pascal Boolean SBIsControlStripVisible(void)
+static pascal Boolean
+SBIsControlStripVisible(void)
 {
-	static short procData[] = TWOWORDSTUB(0x7000, 0xAAF2);
-	ProcInfoType procInfo = kD0DispatchedPascalStackBased
-				| RESULT_SIZE(SIZE_CODE(sizeof(Boolean)))
-            	| DISPATCHED_STACK_ROUTINE_SELECTOR_SIZE(kFourByteCode);
-            				
-	return((Boolean) CallUniversalProc((UniversalProcPtr) procData, procInfo, 0x00));
+    static short procData[] = TWOWORDSTUB(0x7000, 0xAAF2);
+    ProcInfoType procInfo = kD0DispatchedPascalStackBased
+        | RESULT_SIZE(SIZE_CODE(sizeof(Boolean)))
+        | DISPATCHED_STACK_ROUTINE_SELECTOR_SIZE(kFourByteCode);
+
+    return ((Boolean)
+            CallUniversalProc((UniversalProcPtr) procData, procInfo, 0x00));
 }
 
-static pascal void SBShowHideControlStrip(Boolean showIt)
+static pascal void
+SBShowHideControlStrip(Boolean showIt)
 {
-	static short procData[] = THREEWORDSTUB(0x303C, 0x0101, 0xAAF2);
-	ProcInfoType procInfo = kD0DispatchedPascalStackBased
-				| DISPATCHED_STACK_ROUTINE_SELECTOR_SIZE(kFourByteCode)
-				| DISPATCHED_STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(Boolean)));
+    static short procData[] = THREEWORDSTUB(0x303C, 0x0101, 0xAAF2);
+    ProcInfoType procInfo = kD0DispatchedPascalStackBased
+        | DISPATCHED_STACK_ROUTINE_SELECTOR_SIZE(kFourByteCode)
+        | DISPATCHED_STACK_ROUTINE_PARAMETER(1,
+                                             SIZE_CODE(sizeof(Boolean)));
 
-	CallUniversalProc((UniversalProcPtr) procData, procInfo, 0x01, showIt);
+    CallUniversalProc((UniversalProcPtr) procData, procInfo, 0x01, showIt);
 }
 #endif /* powerc */
 #endif /* !TARGET_API_MAC_CARBON */
 
 /* Macintosh toolbox driver bootstrap functions */
 
-static int ROM_Available(void)
+static int
+ROM_Available(void)
 {
-	return(1);
+    return (1);
 }
 
-static void ROM_DeleteDevice(SDL_VideoDevice *device)
+static void
+ROM_DeleteDevice(SDL_VideoDevice * device)
 {
-	SDL_free(device->hidden);
-	SDL_free(device);
+    SDL_free(device->hidden);
+    SDL_free(device);
 }
 
-static SDL_VideoDevice *ROM_CreateDevice(int devindex)
+static SDL_VideoDevice *
+ROM_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));
-	}
-	if ( (device == NULL) || (device->hidden == NULL) ) {
-		SDL_OutOfMemory();
-		if ( device ) {
-			SDL_free(device);
-		}
-		return(0);
-	}
-	SDL_memset(device->hidden, 0, (sizeof *device->hidden));
+    /* 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));
+    }
+    if ((device == NULL) || (device->hidden == NULL)) {
+        SDL_OutOfMemory();
+        if (device) {
+            SDL_free(device);
+        }
+        return (0);
+    }
+    SDL_memset(device->hidden, 0, (sizeof *device->hidden));
 
-	/* Set the function pointers */
-	device->VideoInit = ROM_VideoInit;
-	device->ListModes = ROM_ListModes;
-	device->SetVideoMode = ROM_SetVideoMode;
-	device->SetColors = ROM_SetColors;
-	device->UpdateRects = NULL;
-	device->VideoQuit = ROM_VideoQuit;
-	device->AllocHWSurface = ROM_AllocHWSurface;
-	device->CheckHWBlit = NULL;
-	device->FillHWRect = NULL;
-	device->SetHWColorKey = NULL;
-	device->SetHWAlpha = NULL;
-	device->LockHWSurface = ROM_LockHWSurface;
-	device->UnlockHWSurface = ROM_UnlockHWSurface;
-	device->FlipHWSurface = NULL;
-	device->FreeHWSurface = ROM_FreeHWSurface;
+    /* Set the function pointers */
+    device->VideoInit = ROM_VideoInit;
+    device->ListModes = ROM_ListModes;
+    device->SetVideoMode = ROM_SetVideoMode;
+    device->SetColors = ROM_SetColors;
+    device->UpdateRects = NULL;
+    device->VideoQuit = ROM_VideoQuit;
+    device->AllocHWSurface = ROM_AllocHWSurface;
+    device->CheckHWBlit = NULL;
+    device->FillHWRect = NULL;
+    device->SetHWColorKey = NULL;
+    device->SetHWAlpha = NULL;
+    device->LockHWSurface = ROM_LockHWSurface;
+    device->UnlockHWSurface = ROM_UnlockHWSurface;
+    device->FlipHWSurface = NULL;
+    device->FreeHWSurface = ROM_FreeHWSurface;
 #if SDL_VIDEO_OPENGL
-	device->GL_MakeCurrent = Mac_GL_MakeCurrent;
-	device->GL_SwapBuffers = Mac_GL_SwapBuffers;
-	device->GL_LoadLibrary = Mac_GL_LoadLibrary;
-	device->GL_GetProcAddress = Mac_GL_GetProcAddress;
-#endif	// Have OpenGL
-	device->SetCaption = Mac_SetCaption;
-	device->SetIcon = NULL;
-	device->IconifyWindow = NULL;
-	device->GrabInput = NULL;
-	device->GetWMInfo = NULL;
-	device->FreeWMCursor = Mac_FreeWMCursor;
-	device->CreateWMCursor = Mac_CreateWMCursor;
-	device->ShowWMCursor = Mac_ShowWMCursor;
-	device->WarpWMCursor = Mac_WarpWMCursor;
-	device->InitOSKeymap = Mac_InitOSKeymap;
-	device->PumpEvents = Mac_PumpEvents;
+    device->GL_MakeCurrent = Mac_GL_MakeCurrent;
+    device->GL_SwapBuffers = Mac_GL_SwapBuffers;
+    device->GL_LoadLibrary = Mac_GL_LoadLibrary;
+    device->GL_GetProcAddress = Mac_GL_GetProcAddress;
+#endif // Have OpenGL
+    device->SetCaption = Mac_SetCaption;
+    device->SetIcon = NULL;
+    device->IconifyWindow = NULL;
+    device->GrabInput = NULL;
+    device->GetWMInfo = NULL;
+    device->FreeWMCursor = Mac_FreeWMCursor;
+    device->CreateWMCursor = Mac_CreateWMCursor;
+    device->ShowWMCursor = Mac_ShowWMCursor;
+    device->WarpWMCursor = Mac_WarpWMCursor;
+    device->InitOSKeymap = Mac_InitOSKeymap;
+    device->PumpEvents = Mac_PumpEvents;
 
-	device->free = ROM_DeleteDevice;
+    device->free = ROM_DeleteDevice;
 
-	return device;
+    return device;
 }
 
 VideoBootStrap TOOLBOX_bootstrap = {
-	"toolbox", "MacOS ROM Toolbox",
-	ROM_Available, ROM_CreateDevice
+    "toolbox", "MacOS ROM Toolbox",
+    ROM_Available, ROM_CreateDevice
 };
 
 
-static int ROM_VideoInit(_THIS, SDL_PixelFormat *vformat)
+static int
+ROM_VideoInit(_THIS, SDL_PixelFormat * vformat)
 {
-	long info;
-	
-	/* Check out some things about the system */
-	Gestalt(gestaltQuickdrawVersion, &info);
-	if ( info == gestaltOriginalQD ) {
-		SDL_SetError("Color Quickdraw not available");
-		return(-1);
-	}
+    long info;
+
+    /* Check out some things about the system */
+    Gestalt(gestaltQuickdrawVersion, &info);
+    if (info == gestaltOriginalQD) {
+        SDL_SetError("Color Quickdraw not available");
+        return (-1);
+    }
 
-	/* Start ROMintosh events */
-	Mac_InitEvents(this);
+    /* Start ROMintosh events */
+    Mac_InitEvents(this);
 
-	/* Get a handle to the main monitor */
-	SDL_Display = GetMainDevice();
+    /* Get a handle to the main monitor */
+    SDL_Display = GetMainDevice();
 
-	/* Determine the current screen size */
-	this->info.current_w = (**SDL_Display).gdRect.right;
-	this->info.current_h = (**SDL_Display).gdRect.bottom;
+    /* Determine the current screen size */
+    this->info.current_w = (**SDL_Display).gdRect.right;
+    this->info.current_h = (**SDL_Display).gdRect.bottom;
 
-	/* Determine pixel format */
-	vformat->BitsPerPixel = (**(**SDL_Display).gdPMap).pixelSize;
-	switch (vformat->BitsPerPixel) {
-		case 16:	/* 5-5-5 RGB */
-			vformat->Rmask = 0x00007c00;
-			vformat->Gmask = 0x000003e0;
-			vformat->Bmask = 0x0000001f;
-			break;
-		default:
-			break;
-	}
+    /* Determine pixel format */
+    vformat->BitsPerPixel = (**(**SDL_Display).gdPMap).pixelSize;
+    switch (vformat->BitsPerPixel) {
+    case 16:                   /* 5-5-5 RGB */
+        vformat->Rmask = 0x00007c00;
+        vformat->Gmask = 0x000003e0;
+        vformat->Bmask = 0x0000001f;
+        break;
+    default:
+        break;
+    }
 
-	/* Create our palette */
-	SDL_CTab = (CTabHandle)NewHandle(sizeof(ColorSpec)*256 + 8);
-	if ( SDL_CTab == nil ) {
-		SDL_OutOfMemory();
-		return(-1);
-	}
-	(**SDL_CTab).ctSeed = GetCTSeed();
-	(**SDL_CTab).ctFlags = 0;
-	(**SDL_CTab).ctSize = 255;
-	CTabChanged(SDL_CTab);
-	SDL_CPal = NewPalette(256, SDL_CTab, pmExplicit+pmTolerant, 0);
+    /* Create our palette */
+    SDL_CTab = (CTabHandle) NewHandle(sizeof(ColorSpec) * 256 + 8);
+    if (SDL_CTab == nil) {
+        SDL_OutOfMemory();
+        return (-1);
+    }
+    (**SDL_CTab).ctSeed = GetCTSeed();
+    (**SDL_CTab).ctFlags = 0;
+    (**SDL_CTab).ctSize = 255;
+    CTabChanged(SDL_CTab);
+    SDL_CPal = NewPalette(256, SDL_CTab, pmExplicit + pmTolerant, 0);
 
-	/* Get a list of available fullscreen modes */
-	SDL_modelist = (SDL_Rect **)SDL_malloc((1+1)*sizeof(SDL_Rect *));
-	if ( SDL_modelist ) {
-		SDL_modelist[0] = (SDL_Rect *)SDL_malloc(sizeof(SDL_Rect));
-		if ( SDL_modelist[0] ) {
-			SDL_modelist[0]->x = 0;
-			SDL_modelist[0]->y = 0;
-			SDL_modelist[0]->w = (**SDL_Display).gdRect.right;
-			SDL_modelist[0]->h = (**SDL_Display).gdRect.bottom;
-		}
-		SDL_modelist[1] = NULL;
-	}
+    /* Get a list of available fullscreen modes */
+    SDL_modelist = (SDL_Rect **) SDL_malloc((1 + 1) * sizeof(SDL_Rect *));
+    if (SDL_modelist) {
+        SDL_modelist[0] = (SDL_Rect *) SDL_malloc(sizeof(SDL_Rect));
+        if (SDL_modelist[0]) {
+            SDL_modelist[0]->x = 0;
+            SDL_modelist[0]->y = 0;
+            SDL_modelist[0]->w = (**SDL_Display).gdRect.right;
+            SDL_modelist[0]->h = (**SDL_Display).gdRect.bottom;
+        }
+        SDL_modelist[1] = NULL;
+    }
 
-	/* Fill in some window manager capabilities */
-	this->info.wm_available = 1;
+    /* Fill in some window manager capabilities */
+    this->info.wm_available = 1;
 
-	/* We're done! */
-	return(0);
+    /* We're done! */
+    return (0);
 }
 
-static SDL_Rect **ROM_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags)
+static SDL_Rect **
+ROM_ListModes(_THIS, SDL_PixelFormat * format, Uint32 flags)
 {
-	if ( this->screen->format->BitsPerPixel == format->BitsPerPixel ) {
-		if ( (flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) {
-			return(SDL_modelist);
-		} else {
-			return((SDL_Rect **)-1);
-		}
-	} else {
-		return((SDL_Rect **)0);
-	}
+    if (this->screen->format->BitsPerPixel == format->BitsPerPixel) {
+        if ((flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) {
+            return (SDL_modelist);
+        } else {
+            return ((SDL_Rect **) - 1);
+        }
+    } else {
+        return ((SDL_Rect **) 0);
+    }
 }
 
-static void ROM_HideMenuBar(_THIS)
+static void
+ROM_HideMenuBar(_THIS)
 {
-#if !TARGET_API_MAC_CARBON /* This seems not to be available? -sts Aug 2000 */
-	RgnHandle		drawRgn = nil;
-	RgnHandle		tempRgn = nil;
-	RgnHandle		grayRgn = nil;
-	WindowPtr		window = nil;
-	GDHandle		gd = nil;
-	GrafPtr			savePort;
-	long			response;
-	short			height;
-	EventRecord		theEvent;
+#if !TARGET_API_MAC_CARBON      /* This seems not to be available? -sts Aug 2000 */
+    RgnHandle drawRgn = nil;
+    RgnHandle tempRgn = nil;
+    RgnHandle grayRgn = nil;
+    WindowPtr window = nil;
+    GDHandle gd = nil;
+    GrafPtr savePort;
+    long response;
+    short height;
+    EventRecord theEvent;
+
+    height = GetMBarHeight();
 
-	height = GetMBarHeight();
-	
-	if ( height > 0 ) {
-		tempRgn = NewRgn();
-		drawRgn = NewRgn();
-		gSaveGrayRgn = NewRgn();
-		if ( ! tempRgn || ! drawRgn || ! gSaveGrayRgn ) {
-			goto CLEANUP;
-		}
-		grayRgn = GetGrayRgn(); /* No need to check for this */
-	
-		GetPort(&savePort);
+    if (height > 0) {
+        tempRgn = NewRgn();
+        drawRgn = NewRgn();
+        gSaveGrayRgn = NewRgn();
+        if (!tempRgn || !drawRgn || !gSaveGrayRgn) {
+            goto CLEANUP;
+        }
+        grayRgn = GetGrayRgn(); /* No need to check for this */
+
+        GetPort(&savePort);
 
-		/* Hide the control strip if it's present, and record its 
-		   previous position into the dirty region for redrawing. 
-		   This isn't necessary, but may help catch stray bits. */
-		CopyRgn(grayRgn, tempRgn);
-		if (!Gestalt(gestaltControlStripAttr, &response) && 
-			(response & (1L << gestaltControlStripExists))) {
-			gSaveCSVis = SBIsControlStripVisible();
-			if (gSaveCSVis)
-				SBShowHideControlStrip(false);
-		}
-		DiffRgn(grayRgn, tempRgn, drawRgn);
+        /* Hide the control strip if it's present, and record its 
+           previous position into the dirty region for redrawing. 
+           This isn't necessary, but may help catch stray bits. */
+        CopyRgn(grayRgn, tempRgn);
+        if (!Gestalt(gestaltControlStripAttr, &response) &&
+            (response & (1L << gestaltControlStripExists))) {
+            gSaveCSVis = SBIsControlStripVisible();
+            if (gSaveCSVis)
+                SBShowHideControlStrip(false);
+        }
+        DiffRgn(grayRgn, tempRgn, drawRgn);
 
-		/* Save the gray region once the control strip is hidden*/
-		CopyRgn(grayRgn, gSaveGrayRgn);
+        /* Save the gray region once the control strip is hidden */
+        CopyRgn(grayRgn, gSaveGrayRgn);
+
+        /* Change the menu height in lowmem */
+        gSaveMenuBar = height;
+        LMSetMBarHeight(0);
 
-		/* Change the menu height in lowmem */
-		gSaveMenuBar = height;
-		LMSetMBarHeight(0);
-		
-		/* Walk the monitor rectangles, and combine any pieces that
-		   aren't in GrayRgn: menubar, round corners, fake floaters. */
-		for(gd = GetDeviceList(); gd; gd = GetNextDevice(gd)) 
-			{
-			if (!TestDeviceAttribute(gd, screenDevice)) continue;
-			if (!TestDeviceAttribute(gd, screenActive)) continue;
+        /* Walk the monitor rectangles, and combine any pieces that
+           aren't in GrayRgn: menubar, round corners, fake floaters. */
+        for (gd = GetDeviceList(); gd; gd = GetNextDevice(gd)) {
+            if (!TestDeviceAttribute(gd, screenDevice))
+                continue;
+            if (!TestDeviceAttribute(gd, screenActive))
+                continue;
+
+            RectRgn(tempRgn, &(*gd)->gdRect);   /* Get the whole screen */
+            DiffRgn(tempRgn, grayRgn, tempRgn); /* Subtract out GrayRgn */
+            UnionRgn(tempRgn, drawRgn, drawRgn);        /* Combine all the bits */
+        }
 
-			RectRgn(tempRgn, &(*gd)->gdRect);	/* Get the whole screen */
-			DiffRgn(tempRgn, grayRgn, tempRgn); /* Subtract out GrayRgn */
-			UnionRgn(tempRgn, drawRgn, drawRgn);/* Combine all the bits */
-			}
-			
-		/* Add the bits into the GrayRgn */
-		UnionRgn(drawRgn, grayRgn, grayRgn);
+        /* Add the bits into the GrayRgn */
+        UnionRgn(drawRgn, grayRgn, grayRgn);
 
-		/* Modify the vis regions of exposed windows */
-		window = (FrontWindow()) ? FrontWindow() : (WindowPtr) -1L;
-		PaintBehind(window, drawRgn);
-		CalcVisBehind(window, drawRgn);
+        /* Modify the vis regions of exposed windows */
+        window = (FrontWindow())? FrontWindow() : (WindowPtr) - 1L;
+        PaintBehind(window, drawRgn);
+        CalcVisBehind(window, drawRgn);
+
+        SetPort(savePort);
 
-		SetPort(savePort);
-		
-		/* Yield time so that floaters can catch up */
-		EventAvail(0, &theEvent);
-		EventAvail(0, &theEvent);
-		EventAvail(0, &theEvent);
-		EventAvail(0, &theEvent);
-		}
+        /* Yield time so that floaters can catch up */
+        EventAvail(0, &theEvent);
+        EventAvail(0, &theEvent);
+        EventAvail(0, &theEvent);
+        EventAvail(0, &theEvent);
+    }
 
-CLEANUP:
+  CLEANUP:
 
-	if (tempRgn) DisposeRgn(tempRgn);
-	if (drawRgn) DisposeRgn(drawRgn);
+    if (tempRgn)
+        DisposeRgn(tempRgn);
+    if (drawRgn)
+        DisposeRgn(drawRgn);
 #endif /* !TARGET_API_MAC_CARBON */
 }
-	
-static void ROM_ShowMenuBar(_THIS)
+
+static void
+ROM_ShowMenuBar(_THIS)
 {
-#if !TARGET_API_MAC_CARBON /* This seems not to be available? -sts Aug 2000 */
-	RgnHandle		drawRgn = nil;
-	RgnHandle		menuRgn = nil;
-	RgnHandle		tempRgn = nil;
-	RgnHandle		grayRgn = nil;
-	WindowPtr		window = nil;
-	GrafPtr			wMgrPort;
-	GrafPtr			savePort;
-	Rect			menuRect;
-	long			response;
-	short			height;
-	EventRecord		theEvent;
-	RGBColor		saveRGB;
-	RGBColor		blackRGB = { 0, 0, 0 };
+#if !TARGET_API_MAC_CARBON      /* This seems not to be available? -sts Aug 2000 */
+    RgnHandle drawRgn = nil;
+    RgnHandle menuRgn = nil;
+    RgnHandle tempRgn = nil;
+    RgnHandle grayRgn = nil;
+    WindowPtr window = nil;
+    GrafPtr wMgrPort;
+    GrafPtr savePort;
+    Rect menuRect;
+    long response;
+    short height;
+    EventRecord theEvent;
+    RGBColor saveRGB;
+    RGBColor blackRGB = { 0, 0, 0 };
+
+    height = GetMBarHeight();
 
-	height = GetMBarHeight();
-	
-	if ((height <= 0) && (gSaveMenuBar > 0)) {
-		drawRgn = NewRgn();
-		menuRgn = NewRgn();
-		tempRgn = NewRgn();
-		if ( ! tempRgn || ! drawRgn || ! gSaveGrayRgn ) {
-			goto CLEANUP;
-		}
-		grayRgn = GetGrayRgn(); /* No need to check for this */
-	
-		GetPort(&savePort);
-		GetWMgrPort(&wMgrPort);
+    if ((height <= 0) && (gSaveMenuBar > 0)) {
+        drawRgn = NewRgn();
+        menuRgn = NewRgn();
+        tempRgn = NewRgn();
+        if (!tempRgn || !drawRgn || !gSaveGrayRgn) {
+            goto CLEANUP;
+        }
+        grayRgn = GetGrayRgn(); /* No need to check for this */
+
+        GetPort(&savePort);
+        GetWMgrPort(&wMgrPort);
 
-		/* Set the height properly */
-		LMSetMBarHeight(gSaveMenuBar);
+        /* Set the height properly */
+        LMSetMBarHeight(gSaveMenuBar);
 
-		/* Restore the old GrayRgn: rounded corners, etc, but not
-		   the menubar -- subtract that out first! */
-		if (gSaveGrayRgn)
-			{
-			menuRect = (*GetMainDevice())->gdRect;
-			menuRect.bottom = menuRect.top + gSaveMenuBar;
-			RectRgn(menuRgn, &menuRect);
+        /* Restore the old GrayRgn: rounded corners, etc, but not
+           the menubar -- subtract that out first! */
+        if (gSaveGrayRgn) {
+            menuRect = (*GetMainDevice())->gdRect;
+            menuRect.bottom = menuRect.top + gSaveMenuBar;
+            RectRgn(menuRgn, &menuRect);
+
+            DiffRgn(grayRgn, gSaveGrayRgn, drawRgn);    /* What do we inval? */
+            DiffRgn(drawRgn, menuRgn, drawRgn); /* Clip out the menu */
 
-			DiffRgn(grayRgn, gSaveGrayRgn, drawRgn); 	/* What do we inval? */
-			DiffRgn(drawRgn, menuRgn, drawRgn);			/* Clip out the menu */
-			
-			/* Now redraw the corners and other bits black */
-			SetPort(wMgrPort);
-			GetClip(tempRgn);
-			SetClip(drawRgn);
-			GetForeColor(&saveRGB);
-			RGBForeColor(&blackRGB);
-			PaintRgn(drawRgn);
-			RGBForeColor(&saveRGB);
-			SetClip(tempRgn);
-			SetPort(savePort);
-			
-			UnionRgn(drawRgn, menuRgn, drawRgn);		/* Put back the menu */
+            /* Now redraw the corners and other bits black */
+            SetPort(wMgrPort);
+            GetClip(tempRgn);
+            SetClip(drawRgn);
+            GetForeColor(&saveRGB);
+            RGBForeColor(&blackRGB);
+            PaintRgn(drawRgn);
+            RGBForeColor(&saveRGB);
+            SetClip(tempRgn);
+            SetPort(savePort);
 
-			/* Now actually restore the GrayRgn */
-			CopyRgn(gSaveGrayRgn, grayRgn);
-			DisposeRgn(gSaveGrayRgn);
-			gSaveGrayRgn = nil;
-			}
+            UnionRgn(drawRgn, menuRgn, drawRgn);        /* Put back the menu */
+
+            /* Now actually restore the GrayRgn */
+            CopyRgn(gSaveGrayRgn, grayRgn);
+            DisposeRgn(gSaveGrayRgn);
+            gSaveGrayRgn = nil;
+        }
+
+        /* Modify the vis regions of exposed windows and draw menubar */
+        window = (FrontWindow())? FrontWindow() : (WindowPtr) - 1L;
+        PaintBehind(window, drawRgn);
+        CalcVisBehind(window, drawRgn);
+        DrawMenuBar();
 
-		/* Modify the vis regions of exposed windows and draw menubar */
-		window = (FrontWindow()) ? FrontWindow() : (WindowPtr) -1L;
-		PaintBehind(window, drawRgn);
-		CalcVisBehind(window, drawRgn);
-		DrawMenuBar();
+        SetPort(savePort);
+        gSaveMenuBar = 0;
 
-		SetPort(savePort);
-		gSaveMenuBar = 0;
+        /* Now show the control strip if it's present */
+        if (!Gestalt(gestaltControlStripAttr, &response) &&
+            (response & (1L << gestaltControlStripExists))) {
+            if (gSaveCSVis && !SBIsControlStripVisible())
+                SBShowHideControlStrip(true);
+            gSaveCSVis = true;
+        }
 
-		/* Now show the control strip if it's present */
-		if (!Gestalt(gestaltControlStripAttr, &response) && 
-				(response & (1L << gestaltControlStripExists)))
-			{
-			if (gSaveCSVis && !SBIsControlStripVisible())
-				SBShowHideControlStrip(true);
-			gSaveCSVis = true;
-			}
+        /* Yield time so that floaters can catch up */
+        EventAvail(0, &theEvent);
+        EventAvail(0, &theEvent);
+        EventAvail(0, &theEvent);
+        EventAvail(0, &theEvent);
+    }
 
-		/* Yield time so that floaters can catch up */
-		EventAvail(0, &theEvent);
-		EventAvail(0, &theEvent);
-		EventAvail(0, &theEvent);
-		EventAvail(0, &theEvent);
-		}
+  CLEANUP:
 
-CLEANUP:
-
-	if (drawRgn) DisposeRgn(drawRgn);
-	if (menuRgn) DisposeRgn(menuRgn);
-	if (tempRgn) DisposeRgn(tempRgn);
+    if (drawRgn)
+        DisposeRgn(drawRgn);
+    if (menuRgn)
+        DisposeRgn(menuRgn);
+    if (tempRgn)
+        DisposeRgn(tempRgn);
 #endif /* !TARGET_API_MAC_CARBON */
 }
 
 /* Various screen update functions available */
-static void ROM_DirectUpdate(_THIS, int numrects, SDL_Rect *rects);
-static void ROM_WindowUpdate(_THIS, int numrects, SDL_Rect *rects);
+static void ROM_DirectUpdate(_THIS, int numrects, SDL_Rect * rects);
+static void ROM_WindowUpdate(_THIS, int numrects, SDL_Rect * rects);
 
-static void ROM_UnsetVideoMode(_THIS, SDL_Surface *current)
+static void
+ROM_UnsetVideoMode(_THIS, SDL_Surface * current)
 {
-	/* Free the current window, if any */
-	if ( SDL_Window != nil ) {
-		GWorldPtr memworld;
-		
-		/* Handle OpenGL support */
-		Mac_GL_Quit(this);
+    /* Free the current window, if any */
+    if (SDL_Window != nil) {
+        GWorldPtr memworld;
+
+        /* Handle OpenGL support */
+        Mac_GL_Quit(this);
 
-		memworld = (GWorldPtr)GetWRefCon(SDL_Window);
-		if ( memworld != nil ) {
-			UnlockPixels(GetGWorldPixMap(memworld));
-			DisposeGWorld(memworld);
-		}
-		if ( (current->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) {
+        memworld = (GWorldPtr) GetWRefCon(SDL_Window);
+        if (memworld != nil) {
+            UnlockPixels(GetGWorldPixMap(memworld));
+            DisposeGWorld(memworld);
+        }
+        if ((current->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) {
 #if USE_QUICKTIME
-			EndFullScreen(fullscreen_ctx, nil);
-			SDL_Window = nil;
+            EndFullScreen(fullscreen_ctx, nil);
+            SDL_Window = nil;
 #else
-			ROM_ShowMenuBar(this);
+            ROM_ShowMenuBar(this);
 #endif
-		}
-	}
-	current->pixels = NULL;
-	current->flags &= ~(SDL_HWSURFACE|SDL_FULLSCREEN);
+        }
+    }
+    current->pixels = NULL;
+    current->flags &= ~(SDL_HWSURFACE | SDL_FULLSCREEN);
 }
 
-static SDL_Surface *ROM_SetVideoMode(_THIS, SDL_Surface *current,
-				int width, int height, int bpp, Uint32 flags)
+static SDL_Surface *
+ROM_SetVideoMode(_THIS, SDL_Surface * current,
+                 int width, int height, int bpp, Uint32 flags)
 {
-	Rect wrect, orect;
+    Rect wrect, orect;
 #if TARGET_API_MAC_CARBON
-	Rect tmprect;
+    Rect tmprect;
 #endif
 
-	/* Free any previous video mode */
-	ROM_UnsetVideoMode(this, current);
+    /* Free any previous video mode */
+    ROM_UnsetVideoMode(this, current);
 
-	/* Create the ROM window and SDL video surface */
-	current->flags = 0;		/* Clear flags */
-	current->w = width;
-	current->h = height;
-	SetRect(&wrect, 0, 0, width, height);
-	if ( SDL_Window ) {
-		/* If we recreate the window, don't move it around */
+    /* Create the ROM window and SDL video surface */
+    current->flags = 0;         /* Clear flags */
+    current->w = width;
+    current->h = height;
+    SetRect(&wrect, 0, 0, width, height);
+    if (SDL_Window) {
+        /* If we recreate the window, don't move it around */
 #if TARGET_API_MAC_CARBON
-		orect = *GetWindowPortBounds(SDL_Window, &tmprect);
+        orect = *GetWindowPortBounds(SDL_Window, &tmprect);
 #else
-		orect = SDL_Window->portRect;
+        orect = SDL_Window->portRect;
 #endif
-		OffsetRect(&wrect, orect.left, orect.top);
-	} else {
-		/* Center the window the first time we show it */
-		OffsetRect(&wrect,
-		(SDL_modelist[0]->w-width)/2, (SDL_modelist[0]->h-height)/2);
-	}
+        OffsetRect(&wrect, orect.left, orect.top);
+    } else {
+        /* Center the window the first time we show it */
+        OffsetRect(&wrect,
+                   (SDL_modelist[0]->w - width) / 2,
+                   (SDL_modelist[0]->h - height) / 2);
+    }
 
 #if defined(__MACOSX__) && !USE_QUICKTIME
-	/* Hum.. fullscreen mode is broken */
-	flags &= ~SDL_FULLSCREEN;
+    /* Hum.. fullscreen mode is broken */
+    flags &= ~SDL_FULLSCREEN;
 #endif
-	if ( (flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) {
-		/* Create the fullscreen window and use screen bits */
-		current->flags |= SDL_HWSURFACE|SDL_FULLSCREEN;
-		if ( SDL_Window ) {
-			DisposeWindow(SDL_Window);
-		}
+    if ((flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) {
+        /* Create the fullscreen window and use screen bits */
+        current->flags |= SDL_HWSURFACE | SDL_FULLSCREEN;
+        if (SDL_Window) {
+            DisposeWindow(SDL_Window);
+        }
 #if USE_QUICKTIME
-		BeginFullScreen(&fullscreen_ctx, nil, 0,0, &SDL_Window, nil, 0);
+        BeginFullScreen(&fullscreen_ctx, nil, 0, 0, &SDL_Window, nil, 0);
 #else
-		SDL_Window = NewCWindow(nil, &wrect, "\p", true, plainDBox,
-						(WindowPtr)-1, false, 0);
-		ROM_HideMenuBar(this);
+        SDL_Window = NewCWindow(nil, &wrect, "\p", true, plainDBox,
+                                (WindowPtr) - 1, false, 0);
+        ROM_HideMenuBar(this);
 #endif
-		current->pitch = (**(**SDL_Display).gdPMap).rowBytes & 0x3FFF;
-		current->pixels = (**(**SDL_Display).gdPMap).baseAddr;
-		this->UpdateRects = ROM_DirectUpdate;
-	} else {
-		GWorldPtr memworld;
-		PixMapHandle pixmap;
-		int style;
+        current->pitch = (**(**SDL_Display).gdPMap).rowBytes & 0x3FFF;
+        current->pixels = (**(**SDL_Display).gdPMap).baseAddr;
+        this->UpdateRects = ROM_DirectUpdate;
+    } else {
+        GWorldPtr memworld;
+        PixMapHandle pixmap;
+        int style;
+
+        style = noGrowDocProc;
+        if (flags & SDL_NOFRAME) {
+            style = plainDBox;
+            current->flags |= SDL_NOFRAME;
+        } else if (flags & SDL_RESIZABLE) {
+            style = zoomDocProc;
+            current->flags |= SDL_RESIZABLE;
+        }
+        if (SDL_Window && (style == current_style)) {
+            /* Resize existing window, if necessary */
+            if (((orect.right - orect.left) != width) ||
+                ((orect.bottom - orect.top) != height)) {
+                SizeWindow(SDL_Window, width, height, false);
+            }
+        } else {
+            /* Recreate the window in the new style */
+            if (SDL_Window) {
+                DisposeWindow(SDL_Window);
+            }
+            SDL_Window = NewCWindow(nil, &wrect, "\p", true,
+                                    style, (WindowPtr) - 1, true, 0);
 
-		style = noGrowDocProc;
-		if ( flags & SDL_NOFRAME ) {
-			style = plainDBox;
-			current->flags |= SDL_NOFRAME;
-		} else
-		if ( flags & SDL_RESIZABLE ) {
-			style = zoomDocProc;
-			current->flags |= SDL_RESIZABLE;
-		}
-		if ( SDL_Window && (style == current_style) ) {
-			/* Resize existing window, if necessary */
-			if ( ((orect.right-orect.left) != width) ||
-			     ((orect.bottom-orect.top) != height) ) {
-				SizeWindow(SDL_Window, width, height, false);
-			}
-		} else {
-			/* Recreate the window in the new style */
-			if ( SDL_Window ) {
-				DisposeWindow(SDL_Window);
-			}
-			SDL_Window = NewCWindow(nil, &wrect, "\p", true,
-			                        style, (WindowPtr)-1, true, 0);
+            /* Set the window title, if any */
+            {
+                char *title;
+                SDL_WM_GetCaption(&title, NULL);
+                if (title) {
+                    Mac_SetCaption(this, title, NULL);
+                }
+            }
+        }
+        current_style = style;
+        SetPalette(SDL_Window, SDL_CPal, false);
+        ActivatePalette(SDL_Window);
+        if (NewGWorld(&memworld, 0,
+#if TARGET_API_MAC_CARBON
+                      GetWindowPortBounds(SDL_Window, &tmprect),
+#else
+                      &SDL_Window->portRect,
+#endif
+                      SDL_CTab, nil, 0) != noErr) {
+            SDL_SetError("NewGWorld() failed");
+            return (NULL);
+        }
+        SetWRefCon(SDL_Window, (long) memworld);
+        pixmap = GetGWorldPixMap(memworld);
+        LockPixels(pixmap);
+        current->pitch = (**pixmap).rowBytes & 0x3FFF;
+        current->pixels = GetPixBaseAddr(pixmap);
+        this->UpdateRects = ROM_WindowUpdate;
+    }
+    SetPortWindowPort(SDL_Window);
+    SelectWindow(SDL_Window);
 
-			/* Set the window title, if any */
-			{ char *title;
-				SDL_WM_GetCaption(&title, NULL);
-				if ( title ) {
-					Mac_SetCaption(this, title, NULL);
-				}
-			}
-		}
-		current_style = style;
-		SetPalette(SDL_Window, SDL_CPal, false);
-		ActivatePalette(SDL_Window);
-		if ( NewGWorld(&memworld, 0,
-#if TARGET_API_MAC_CARBON
-			       GetWindowPortBounds(SDL_Window, &tmprect),
-#else
-			       &SDL_Window->portRect,
-#endif
-			       SDL_CTab, nil, 0) != noErr ) {
-			SDL_SetError("NewGWorld() failed");
-			return(NULL);
-		}
-		SetWRefCon(SDL_Window, (long)memworld);
-		pixmap = GetGWorldPixMap(memworld);
-		LockPixels(pixmap);
-		current->pitch = (**pixmap).rowBytes & 0x3FFF;
-		current->pixels = GetPixBaseAddr(pixmap);
-		this->UpdateRects = ROM_WindowUpdate;
-	}
-	SetPortWindowPort(SDL_Window);
-	SelectWindow(SDL_Window);
+    /* Handle OpenGL support */
+    if (flags & SDL_INTERNALOPENGL) {
+        if (Mac_GL_Init(this) == 0) {
+            current->flags |= SDL_INTERNALOPENGL;
+        } else {
+            current = NULL;
+        }
+    }
 
-	/* Handle OpenGL support */
-	if ( flags & SDL_OPENGL ) {
-		if ( Mac_GL_Init(this) == 0 ) {
-			current->flags |= SDL_OPENGL;
-		} else {
-			current = NULL;
-		}
-	}
-	
-	if ( (flags & SDL_HWPALETTE) && (flags & SDL_FULLSCREEN) )
-	   current->flags |= SDL_HWPALETTE;
-	   
-	/* We're live! */
-	return(current);
+    if ((flags & SDL_HWPALETTE) && (flags & SDL_FULLSCREEN))
+        current->flags |= SDL_HWPALETTE;
+
+    /* We're live! */
+    return (current);
 }
 
 /* We don't actually allow hardware surfaces other than the main one */
-static int ROM_AllocHWSurface(_THIS, SDL_Surface *surface)
+static int
+ROM_AllocHWSurface(_THIS, SDL_Surface * surface)
 {
-	return(-1);
+    return (-1);
 }
-static void ROM_FreeHWSurface(_THIS, SDL_Surface *surface)
+static void
+ROM_FreeHWSurface(_THIS, SDL_Surface * surface)
 {
-	return;
+    return;
 }
-static int ROM_LockHWSurface(_THIS, SDL_Surface *surface)
+static int
+ROM_LockHWSurface(_THIS, SDL_Surface * surface)
 {
-	return(0);
+    return (0);
 }
-static void ROM_UnlockHWSurface(_THIS, SDL_Surface *surface)
+static void
+ROM_UnlockHWSurface(_THIS, SDL_Surface * surface)
 {
-	return;
+    return;
 }
 
-static void ROM_DirectUpdate(_THIS, int numrects, SDL_Rect *rects)
+static void
+ROM_DirectUpdate(_THIS, int numrects, SDL_Rect * rects)
 {
-	/* The application is already updating the visible video memory */
-	return;
+    /* The application is already updating the visible video memory */
+    return;
 }
 
-static void ROM_WindowUpdate(_THIS, int numrects, SDL_Rect *rects)
+static void
+ROM_WindowUpdate(_THIS, int numrects, SDL_Rect * rects)
 {
-	GWorldPtr memworld;
-	GrafPtr saveport;
-	CGrafPtr thePort;
-	const BitMap *memBits;
-	const BitMap *winBits;
-	int i;
-	Rect update;
-	
-	/* Copy from the offscreen GWorld to the window port */
-	GetPort(&saveport);
-	SetPortWindowPort(SDL_Window);
-	thePort = GetWindowPort(SDL_Window);
-	memworld = (GWorldPtr)GetWRefCon(SDL_Window);
+    GWorldPtr memworld;
+    GrafPtr saveport;
+    CGrafPtr thePort;
+    const BitMap *memBits;
+    const BitMap *winBits;
+    int i;
+    Rect update;
+
+    /* Copy from the offscreen GWorld to the window port */
+    GetPort(&saveport);
+    SetPortWindowPort(SDL_Window);
+    thePort = GetWindowPort(SDL_Window);
+    memworld = (GWorldPtr) GetWRefCon(SDL_Window);
 #if TARGET_API_MAC_CARBON && ACCESSOR_CALLS_ARE_FUNCTIONS
-	memBits = GetPortBitMapForCopyBits((CGrafPtr) memworld);
+    memBits = GetPortBitMapForCopyBits((CGrafPtr) memworld);
 #else
-	memBits = &((GrafPtr)memworld)->portBits;
+    memBits = &((GrafPtr) memworld)->portBits;
 #endif
 #if TARGET_API_MAC_CARBON && ACCESSOR_CALLS_ARE_FUNCTIONS
-	winBits = GetPortBitMapForCopyBits(thePort);
+    winBits = GetPortBitMapForCopyBits(thePort);
 #else
-	winBits = &SDL_Window->portBits;
+    winBits = &SDL_Window->portBits;
 #endif
-	for ( i=0; i<numrects; ++i ) {
-		update.left = rects[i].x;
-		update.right = rects[i].x+rects[i].w;
-		update.top = rects[i].y;
-		update.bottom = rects[i].y+rects[i].h;
-		CopyBits(memBits, winBits,
-			 &update, &update, srcCopy, nil);
-	}
+    for (i = 0; i < numrects; ++i) {
+        update.left = rects[i].x;
+        update.right = rects[i].x + rects[i].w;
+        update.top = rects[i].y;
+        update.bottom = rects[i].y + rects[i].h;
+        CopyBits(memBits, winBits, &update, &update, srcCopy, nil);
+    }
 #if TARGET_API_MAC_CARBON
-	if ( QDIsPortBuffered(thePort) ) {
-		QDFlushPortBuffer(thePort, NULL);
-	}
+    if (QDIsPortBuffered(thePort)) {
+        QDFlushPortBuffer(thePort, NULL);
+    }
 #endif
-	SetPort(saveport);
+    SetPort(saveport);
 }
 
-static int ROM_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
+static int
+ROM_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color * colors)
 {
-	CTabHandle cTab;
-	int i;
+    CTabHandle cTab;
+    int i;
 
-	/* Get the colortable from the either the display or window */
-	if ( (this->screen->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) {
-		cTab = (**(**SDL_Display).gdPMap).pmTable;
-	} else {
-		cTab = SDL_CTab;
-	}
+    /* Get the colortable from the either the display or window */
+    if ((this->screen->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) {
+        cTab = (**(**SDL_Display).gdPMap).pmTable;
+    } else {
+        cTab = SDL_CTab;
+    }
+
+    /* Verify the range of colors */
+    if ((firstcolor + ncolors) > ((**cTab).ctSize + 1)) {
+        return (0);
+    }
 
-	/* Verify the range of colors */
-	if ( (firstcolor+ncolors) > ((**cTab).ctSize+1) ) {
-		return(0);
-	}
-	
-	/* Set the screen palette and update the display */
-	for ( i=0; i< ncolors; ++i ) {
-	        int j = firstcolor + i;
-		(**cTab).ctTable[j].value = j;
-		(**cTab).ctTable[j].rgb.red = colors[i].r << 8 | colors[i].r;
-		(**cTab).ctTable[j].rgb.green = colors[i].g << 8 | colors[i].g;
-		(**cTab).ctTable[j].rgb.blue = colors[i].b << 8 | colors[i].b;
-	}
-//	if ( (this->screen->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) 
-{
-		GDevice **odisplay;
-		odisplay = GetGDevice();
-		SetGDevice(SDL_Display);
-		SetEntries(0, (**cTab).ctSize, (ColorSpec *)&(**cTab).ctTable);
-		SetGDevice(odisplay);
-	}
-	return(1);
+    /* Set the screen palette and update the display */
+    for (i = 0; i < ncolors; ++i) {
+        int j = firstcolor + i;
+        (**cTab).ctTable[j].value = j;
+        (**cTab).ctTable[j].rgb.red = colors[i].r << 8 | colors[i].r;
+        (**cTab).ctTable[j].rgb.green = colors[i].g << 8 | colors[i].g;
+        (**cTab).ctTable[j].rgb.blue = colors[i].b << 8 | colors[i].b;
+    }
+//      if ( (this->screen->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) 
+    {
+        GDevice **odisplay;
+        odisplay = GetGDevice();
+        SetGDevice(SDL_Display);
+        SetEntries(0, (**cTab).ctSize, (ColorSpec *) & (**cTab).ctTable);
+        SetGDevice(odisplay);
+    }
+    return (1);
 }
 
-void ROM_VideoQuit(_THIS)
+void
+ROM_VideoQuit(_THIS)
 {
-	int i;
+    int i;
 
-	/* Free current video mode */
-	ROM_UnsetVideoMode(this, this->screen);
-	if ( SDL_Window ) {
-		DisposeWindow(SDL_Window);
-		SDL_Window = nil;
-	}
+    /* Free current video mode */
+    ROM_UnsetVideoMode(this, this->screen);
+    if (SDL_Window) {
+        DisposeWindow(SDL_Window);
+        SDL_Window = nil;
+    }
 
-	/* Free palette and restore original one */
-	if ( SDL_CTab != nil ) {
-		DisposeHandle((Handle)SDL_CTab);
-		SDL_CTab = nil;
-	}
-	if ( SDL_CPal != nil ) {
-		DisposePalette(SDL_CPal);
-		SDL_CPal = nil;
-	}
-	RestoreDeviceClut(GetMainDevice());
+    /* Free palette and restore original one */
+    if (SDL_CTab != nil) {
+        DisposeHandle((Handle) SDL_CTab);
+        SDL_CTab = nil;
+    }
+    if (SDL_CPal != nil) {
+        DisposePalette(SDL_CPal);
+        SDL_CPal = nil;
+    }
+    RestoreDeviceClut(GetMainDevice());
 
-	/* Free list of video modes */
-	if ( SDL_modelist != NULL ) {
-		for ( i=0; SDL_modelist[i]; ++i ) {
-			SDL_free(SDL_modelist[i]);
-		}
-		SDL_free(SDL_modelist);
-		SDL_modelist = NULL;
-	}
+    /* Free list of video modes */
+    if (SDL_modelist != NULL) {
+        for (i = 0; SDL_modelist[i]; ++i) {
+            SDL_free(SDL_modelist[i]);
+        }
+        SDL_free(SDL_modelist);
+        SDL_modelist = NULL;
+    }
 }
 
+/* vi: set ts=4 sw=4 expandtab: */