--- a/src/video/nanox/SDL_nxvideo.c	Sun May 21 17:27:13 2006 +0000
+++ b/src/video/nanox/SDL_nxvideo.c	Sun May 28 13:04:16 2006 +0000
@@ -40,190 +40,203 @@
 #include "SDL_nxevents_c.h"
 
 // Initialization/Query functions
-static int NX_VideoInit (_THIS, SDL_PixelFormat * vformat) ;
-static SDL_Surface * NX_SetVideoMode (_THIS, SDL_Surface * current, int width, int height, int bpp, Uint32 flags) ;
-static int NX_SetColors (_THIS, int firstcolor, int ncolors, SDL_Color * colors) ;
-static void NX_VideoQuit (_THIS) ;
-static void NX_DestroyWindow (_THIS, SDL_Surface * screen) ;
-static int NX_ToggleFullScreen (_THIS, int on) ;
-static void NX_UpdateMouse (_THIS) ;
-static int NX_SetGammaRamp (_THIS, Uint16 * ramp) ;
-static int NX_GetGammaRamp (_THIS, Uint16 * ramp) ;
+static int NX_VideoInit (_THIS, SDL_PixelFormat * vformat);
+static SDL_Surface *NX_SetVideoMode (_THIS, SDL_Surface * current, int width,
+                                     int height, int bpp, Uint32 flags);
+static int NX_SetColors (_THIS, int firstcolor, int ncolors,
+                         SDL_Color * colors);
+static void NX_VideoQuit (_THIS);
+static void NX_DestroyWindow (_THIS, SDL_Surface * screen);
+static int NX_ToggleFullScreen (_THIS, int on);
+static void NX_UpdateMouse (_THIS);
+static int NX_SetGammaRamp (_THIS, Uint16 * ramp);
+static int NX_GetGammaRamp (_THIS, Uint16 * ramp);
 
 // Microwin driver bootstrap functions
-static int NX_Available ()
+static int
+NX_Available ()
 {
-    Dprintf ("enter NX_Available\n") ;
+    Dprintf ("enter NX_Available\n");
 
-    if (GrOpen () < 0) return 0 ;
-        GrClose () ;
-    
-    Dprintf ("leave NX_Available\n") ;
-    return 1 ;
+    if (GrOpen () < 0)
+        return 0;
+    GrClose ();
+
+    Dprintf ("leave NX_Available\n");
+    return 1;
 }
 
-static void NX_DeleteDevice (SDL_VideoDevice * device)
+static void
+NX_DeleteDevice (SDL_VideoDevice * device)
 {
-    Dprintf ("enter NX_DeleteDevice\n") ;
+    Dprintf ("enter NX_DeleteDevice\n");
 
     if (device) {
-        if (device -> hidden) SDL_free (device -> hidden) ;
-        if (device -> gl_data) SDL_free (device -> gl_data) ;
-            SDL_free (device) ;
+        if (device->hidden)
+            SDL_free (device->hidden);
+        if (device->gl_data)
+            SDL_free (device->gl_data);
+        SDL_free (device);
     }
 
-    Dprintf ("leave NX_DeleteDevice\n") ;
+    Dprintf ("leave NX_DeleteDevice\n");
 }
-    
-static SDL_VideoDevice * NX_CreateDevice (int devindex)
+
+static SDL_VideoDevice *
+NX_CreateDevice (int devindex)
 {
-    SDL_VideoDevice * device ;
+    SDL_VideoDevice *device;
 
-    Dprintf ("enter NX_CreateDevice\n") ;
+    Dprintf ("enter NX_CreateDevice\n");
 
     // Initialize all variables that we clean on shutdown
-    device = (SDL_VideoDevice *) SDL_malloc (sizeof (SDL_VideoDevice)) ;
+    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 = NULL ;
+        SDL_memset (device, 0, (sizeof *device));
+        device->hidden = (struct SDL_PrivateVideoData *)
+            SDL_malloc ((sizeof *device->hidden));
+        device->gl_data = NULL;
     }
-    if ((device == NULL) || (device -> hidden == NULL)) {
-        SDL_OutOfMemory () ;
-        NX_DeleteDevice (device) ;
-        return 0 ;
+    if ((device == NULL) || (device->hidden == NULL)) {
+        SDL_OutOfMemory ();
+        NX_DeleteDevice (device);
+        return 0;
     }
-    SDL_memset (device -> hidden, 0, (sizeof * device -> hidden)) ;
+    SDL_memset (device->hidden, 0, (sizeof *device->hidden));
 
     // Set the function pointers
-    device -> VideoInit = NX_VideoInit ;
-    device -> ListModes = NX_ListModes ;
-    device -> SetVideoMode = NX_SetVideoMode ;
-    device -> ToggleFullScreen = NX_ToggleFullScreen ;
-    device -> UpdateMouse = NX_UpdateMouse ;
-    device -> CreateYUVOverlay = NULL ;
-    device -> SetColors = NX_SetColors ;
-    device -> UpdateRects = NULL ;
-    device -> VideoQuit = NX_VideoQuit;
-    device -> AllocHWSurface = NULL ;
-    device -> CheckHWBlit = NULL ;
-    device -> FillHWRect = NULL ;
-    device -> SetHWColorKey = NULL ;
-    device -> SetHWAlpha = NULL ;
-    device -> LockHWSurface = NULL ;
-    device -> UnlockHWSurface = NULL ;
-    device -> FlipHWSurface = NULL ;
-    device -> FreeHWSurface = NULL ;
-    device -> SetGamma = NULL ;
-    device -> GetGamma = NULL ;
-    device -> SetGammaRamp = NX_SetGammaRamp ;
-    device -> GetGammaRamp = NX_GetGammaRamp ;
+    device->VideoInit = NX_VideoInit;
+    device->ListModes = NX_ListModes;
+    device->SetVideoMode = NX_SetVideoMode;
+    device->ToggleFullScreen = NX_ToggleFullScreen;
+    device->UpdateMouse = NX_UpdateMouse;
+    device->CreateYUVOverlay = NULL;
+    device->SetColors = NX_SetColors;
+    device->UpdateRects = NULL;
+    device->VideoQuit = NX_VideoQuit;
+    device->AllocHWSurface = NULL;
+    device->CheckHWBlit = NULL;
+    device->FillHWRect = NULL;
+    device->SetHWColorKey = NULL;
+    device->SetHWAlpha = NULL;
+    device->LockHWSurface = NULL;
+    device->UnlockHWSurface = NULL;
+    device->FlipHWSurface = NULL;
+    device->FreeHWSurface = NULL;
+    device->SetGamma = NULL;
+    device->GetGamma = NULL;
+    device->SetGammaRamp = NX_SetGammaRamp;
+    device->GetGammaRamp = NX_GetGammaRamp;
 
 #if SDL_VIDEO_OPENGL
-    device -> GL_LoadLibrary = NULL ;
-    device -> GL_GetProcAddress = NULL ;
-    device -> GL_GetAttribute = NULL ;
-    device -> GL_MakeCurrent = NULL ;
-    device -> GL_SwapBuffers = NULL ;
+    device->GL_LoadLibrary = NULL;
+    device->GL_GetProcAddress = NULL;
+    device->GL_GetAttribute = NULL;
+    device->GL_MakeCurrent = NULL;
+    device->GL_SwapBuffers = NULL;
 #endif
 
-    device -> SetIcon = NULL ;
-    device -> SetCaption = NX_SetCaption;
-    device -> IconifyWindow = NULL ;
-    device -> GrabInput = NULL ;
-    device -> GetWMInfo = NX_GetWMInfo ;
-    device -> FreeWMCursor =  NX_FreeWMCursor ;
-    device -> CreateWMCursor = NX_CreateWMCursor ;
-    device -> ShowWMCursor = NX_ShowWMCursor ;
-    device -> WarpWMCursor = NX_WarpWMCursor ;
-    device -> CheckMouseMode = NULL ;
-    device -> InitOSKeymap = NX_InitOSKeymap ;
-    device -> PumpEvents = NX_PumpEvents ;
+    device->SetIcon = NULL;
+    device->SetCaption = NX_SetCaption;
+    device->IconifyWindow = NULL;
+    device->GrabInput = NULL;
+    device->GetWMInfo = NX_GetWMInfo;
+    device->FreeWMCursor = NX_FreeWMCursor;
+    device->CreateWMCursor = NX_CreateWMCursor;
+    device->ShowWMCursor = NX_ShowWMCursor;
+    device->WarpWMCursor = NX_WarpWMCursor;
+    device->CheckMouseMode = NULL;
+    device->InitOSKeymap = NX_InitOSKeymap;
+    device->PumpEvents = NX_PumpEvents;
 
-    device -> free = NX_DeleteDevice ;
+    device->free = NX_DeleteDevice;
 
-    Dprintf ("leave NX_CreateDevice\n") ;
-    return device ;
+    Dprintf ("leave NX_CreateDevice\n");
+    return device;
 }
 
 VideoBootStrap NX_bootstrap = {
     "nanox", "nanox", NX_Available, NX_CreateDevice
-} ;
+};
 
-static void create_aux_windows (_THIS)
+static void
+create_aux_windows (_THIS)
 {
-    GR_WM_PROPERTIES props ;
+    GR_WM_PROPERTIES props;
 
-    Dprintf ("enter create_aux_windows\n") ;
+    Dprintf ("enter create_aux_windows\n");
 
     // Don't create any extra windows if we are being managed
     if (SDL_windowid) {
-        FSwindow = 0 ;
-        return ;
+        FSwindow = 0;
+        return;
     }
-    
+
     if (FSwindow && FSwindow != GR_ROOT_WINDOW_ID) {
-        GrDestroyWindow (FSwindow) ;
+        GrDestroyWindow (FSwindow);
     }
-    
-    FSwindow = GrNewWindow (GR_ROOT_WINDOW_ID, 0, 0, 1, 1, 0, BLACK, BLACK) ;
-    props.flags = GR_WM_FLAGS_PROPS ;
-    props.props = GR_WM_PROPS_NODECORATE ;
-    GrSetWMProperties (FSwindow, & props) ;
+
+    FSwindow = GrNewWindow (GR_ROOT_WINDOW_ID, 0, 0, 1, 1, 0, BLACK, BLACK);
+    props.flags = GR_WM_FLAGS_PROPS;
+    props.props = GR_WM_PROPS_NODECORATE;
+    GrSetWMProperties (FSwindow, &props);
 
-    GrSelectEvents (FSwindow, (GR_EVENT_MASK_EXPOSURE         |
-        GR_EVENT_MASK_BUTTON_DOWN  | GR_EVENT_MASK_BUTTON_UP  |
-        GR_EVENT_MASK_FOCUS_IN     | GR_EVENT_MASK_FOCUS_OUT  |
-        GR_EVENT_MASK_KEY_DOWN     | GR_EVENT_MASK_KEY_UP     |
-        GR_EVENT_MASK_MOUSE_ENTER  | GR_EVENT_MASK_MOUSE_EXIT |
-        GR_EVENT_MASK_MOUSE_MOTION | GR_EVENT_MASK_UPDATE     |
-        GR_EVENT_MASK_CLOSE_REQ)) ;
+    GrSelectEvents (FSwindow, (GR_EVENT_MASK_EXPOSURE |
+                               GR_EVENT_MASK_BUTTON_DOWN |
+                               GR_EVENT_MASK_BUTTON_UP |
+                               GR_EVENT_MASK_FOCUS_IN |
+                               GR_EVENT_MASK_FOCUS_OUT |
+                               GR_EVENT_MASK_KEY_DOWN | GR_EVENT_MASK_KEY_UP |
+                               GR_EVENT_MASK_MOUSE_ENTER |
+                               GR_EVENT_MASK_MOUSE_EXIT |
+                               GR_EVENT_MASK_MOUSE_MOTION |
+                               GR_EVENT_MASK_UPDATE |
+                               GR_EVENT_MASK_CLOSE_REQ));
 
-    Dprintf ("leave create_aux_windows\n") ;
+    Dprintf ("leave create_aux_windows\n");
 }
 
-int NX_VideoInit (_THIS, SDL_PixelFormat * vformat)
+int
+NX_VideoInit (_THIS, SDL_PixelFormat * vformat)
 {
-    GR_SCREEN_INFO si ;
+    GR_SCREEN_INFO si;
 
-    Dprintf ("enter NX_VideoInit\n") ;
-    
+    Dprintf ("enter NX_VideoInit\n");
+
     if (GrOpen () < 0) {
-        SDL_SetError ("GrOpen() fail") ;
-        return -1 ;
+        SDL_SetError ("GrOpen() fail");
+        return -1;
     }
-
     // use share memory to speed up
 #ifdef NANOX_SHARE_MEMORY
     GrReqShmCmds (0xFFFF);
 #endif
 
-    SDL_Window = 0 ;
-    FSwindow = 0 ;
+    SDL_Window = 0;
+    FSwindow = 0;
 
-    GammaRamp_R = NULL ;
-    GammaRamp_G = NULL ;
-    GammaRamp_B = NULL ;    
+    GammaRamp_R = NULL;
+    GammaRamp_G = NULL;
+    GammaRamp_B = NULL;
 
-    GrGetScreenInfo (& si) ;
-    SDL_Visual.bpp = si.bpp ;
+    GrGetScreenInfo (&si);
+    SDL_Visual.bpp = si.bpp;
 
     /* Determine the current screen size */
-    this->info.current_w = si.cols ;
-    this->info.current_h = si.rows ;
+    this->info.current_w = si.cols;
+    this->info.current_h = si.rows;
 
     // GetVideoMode
-    SDL_modelist = (SDL_Rect **) SDL_malloc (sizeof (SDL_Rect *) * 2) ;
+    SDL_modelist = (SDL_Rect **) SDL_malloc (sizeof (SDL_Rect *) * 2);
     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 = si.cols ;
-            SDL_modelist [0] -> h = si.rows ;
+        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 = si.cols;
+            SDL_modelist[0]->h = si.rows;
         }
-        SDL_modelist [1] = NULL ;
+        SDL_modelist[1] = NULL;
     }
 
     pixel_type = si.pixtype;
@@ -231,311 +244,329 @@
     SDL_Visual.green_mask = si.gmask;
     SDL_Visual.blue_mask = si.bmask;
 
-    vformat -> BitsPerPixel = SDL_Visual.bpp ;
-    if (vformat -> BitsPerPixel > 8) {
-        vformat -> Rmask = SDL_Visual.red_mask ;
-        vformat -> Gmask = SDL_Visual.green_mask ;
-        vformat -> Bmask = SDL_Visual.blue_mask ;
+    vformat->BitsPerPixel = SDL_Visual.bpp;
+    if (vformat->BitsPerPixel > 8) {
+        vformat->Rmask = SDL_Visual.red_mask;
+        vformat->Gmask = SDL_Visual.green_mask;
+        vformat->Bmask = SDL_Visual.blue_mask;
     }
-
     // See if we have been passed a window to use
-    SDL_windowid = getenv ("SDL_WINDOWID") ;
-    
+    SDL_windowid = getenv ("SDL_WINDOWID");
+
     // Create the fullscreen (and managed windows : no implement)
-    create_aux_windows (this) ;
+    create_aux_windows (this);
 
-    Dprintf ("leave NX_VideoInit\n") ;
-    return 0 ;
+    Dprintf ("leave NX_VideoInit\n");
+    return 0;
 }
 
-void NX_VideoQuit (_THIS)
+void
+NX_VideoQuit (_THIS)
 {
-    Dprintf ("enter NX_VideoQuit\n") ;
+    Dprintf ("enter NX_VideoQuit\n");
 
     // Start shutting down the windows
-    NX_DestroyImage (this, this -> screen) ;
-    NX_DestroyWindow (this, this -> screen) ;
+    NX_DestroyImage (this, this->screen);
+    NX_DestroyWindow (this, this->screen);
     if (FSwindow && FSwindow != GR_ROOT_WINDOW_ID) {
-        GrDestroyWindow (FSwindow) ;
+        GrDestroyWindow (FSwindow);
     }
-    NX_FreeVideoModes (this) ;
-    SDL_free (GammaRamp_R) ;
-    SDL_free (GammaRamp_G) ;
-    SDL_free (GammaRamp_B) ;
+    NX_FreeVideoModes (this);
+    SDL_free (GammaRamp_R);
+    SDL_free (GammaRamp_G);
+    SDL_free (GammaRamp_B);
 
 #ifdef ENABLE_NANOX_DIRECT_FB
     if (Clientfb)
-        GrCloseClientFramebuffer();
+        GrCloseClientFramebuffer ();
 #endif
-    GrClose () ;
+    GrClose ();
 
-    Dprintf ("leave NX_VideoQuit\n") ;
+    Dprintf ("leave NX_VideoQuit\n");
 }
 
-static void NX_DestroyWindow (_THIS, SDL_Surface * screen)
+static void
+NX_DestroyWindow (_THIS, SDL_Surface * screen)
 {
-    Dprintf ("enter NX_DestroyWindow\n") ;
+    Dprintf ("enter NX_DestroyWindow\n");
 
-    if (! SDL_windowid) {
-        if (screen && (screen -> flags & SDL_FULLSCREEN)) {
-            screen -> flags &= ~ SDL_FULLSCREEN ;
-            NX_LeaveFullScreen (this) ;
+    if (!SDL_windowid) {
+        if (screen && (screen->flags & SDL_FULLSCREEN)) {
+            screen->flags &= ~SDL_FULLSCREEN;
+            NX_LeaveFullScreen (this);
         }
-
         // Destroy the output window
         if (SDL_Window && SDL_Window != GR_ROOT_WINDOW_ID) {
-            GrDestroyWindow (SDL_Window) ;
+            GrDestroyWindow (SDL_Window);
         }
     }
-    
     // Free the graphics context
-    if (! SDL_GC) {
-        GrDestroyGC (SDL_GC) ;
+    if (!SDL_GC) {
+        GrDestroyGC (SDL_GC);
         SDL_GC = 0;
     }
 
-    Dprintf ("leave NX_DestroyWindow\n") ;
+    Dprintf ("leave NX_DestroyWindow\n");
 }
 
-static int NX_CreateWindow (_THIS, SDL_Surface * screen,
-                int w, int h, int bpp, Uint32 flags)
+static int
+NX_CreateWindow (_THIS, SDL_Surface * screen,
+                 int w, int h, int bpp, Uint32 flags)
 {
-    Dprintf ("enter NX_CreateWindow\n") ;
+    Dprintf ("enter NX_CreateWindow\n");
 
     // If a window is already present, destroy it and start fresh
     if (SDL_Window && SDL_Window != GR_ROOT_WINDOW_ID) {
-        NX_DestroyWindow (this, screen) ;
+        NX_DestroyWindow (this, screen);
     }
-
     // See if we have been given a window id
     if (SDL_windowid) {
-        SDL_Window = SDL_strtol (SDL_windowid, NULL, 0) ;
+        SDL_Window = SDL_strtol (SDL_windowid, NULL, 0);
     } else {
-        SDL_Window = 0 ;
+        SDL_Window = 0;
     }
-    
-    if ( ! SDL_ReallocFormat (screen, bpp, SDL_Visual.red_mask, 
-        SDL_Visual.green_mask, SDL_Visual.blue_mask, 0))
+
+    if (!SDL_ReallocFormat (screen, bpp, SDL_Visual.red_mask,
+                            SDL_Visual.green_mask, SDL_Visual.blue_mask, 0))
         return -1;
 
     // Create (or use) the nanox display window
-    if (! SDL_windowid) {
+    if (!SDL_windowid) {
 
-        SDL_Window = GrNewWindow (GR_ROOT_WINDOW_ID, 0, 0, w, h, 0, BLACK, WHITE) ;
+        SDL_Window =
+            GrNewWindow (GR_ROOT_WINDOW_ID, 0, 0, w, h, 0, BLACK, WHITE);
 
-        GrSelectEvents (SDL_Window, (GR_EVENT_MASK_EXPOSURE       |
-            GR_EVENT_MASK_BUTTON_DOWN  | GR_EVENT_MASK_BUTTON_UP  |
-            GR_EVENT_MASK_FOCUS_IN     | GR_EVENT_MASK_FOCUS_OUT  |
-            GR_EVENT_MASK_KEY_DOWN     | GR_EVENT_MASK_KEY_UP     |
-            GR_EVENT_MASK_MOUSE_ENTER  | GR_EVENT_MASK_MOUSE_EXIT |
-            GR_EVENT_MASK_MOUSE_MOTION | GR_EVENT_MASK_UPDATE     |
-            GR_EVENT_MASK_CLOSE_REQ)) ;
-    }
-    
-    /* Create the graphics context here, once we have a window */
-    SDL_GC = GrNewGC () ;
-    if (SDL_GC == 0) {
-        SDL_SetError("Couldn't create graphics context");
-        return(-1);
+        GrSelectEvents (SDL_Window, (GR_EVENT_MASK_EXPOSURE |
+                                     GR_EVENT_MASK_BUTTON_DOWN |
+                                     GR_EVENT_MASK_BUTTON_UP |
+                                     GR_EVENT_MASK_FOCUS_IN |
+                                     GR_EVENT_MASK_FOCUS_OUT |
+                                     GR_EVENT_MASK_KEY_DOWN |
+                                     GR_EVENT_MASK_KEY_UP |
+                                     GR_EVENT_MASK_MOUSE_ENTER |
+                                     GR_EVENT_MASK_MOUSE_EXIT |
+                                     GR_EVENT_MASK_MOUSE_MOTION |
+                                     GR_EVENT_MASK_UPDATE |
+                                     GR_EVENT_MASK_CLOSE_REQ));
     }
 
+    /* Create the graphics context here, once we have a window */
+    SDL_GC = GrNewGC ();
+    if (SDL_GC == 0) {
+        SDL_SetError ("Couldn't create graphics context");
+        return (-1);
+    }
     // Map them both and go fullscreen, if requested
-    if (! SDL_windowid) {
-        GrMapWindow (SDL_Window) ;
+    if (!SDL_windowid) {
+        GrMapWindow (SDL_Window);
         if (flags & SDL_FULLSCREEN) {
-            screen -> flags |= SDL_FULLSCREEN ;
-            NX_EnterFullScreen (this) ;
+            screen->flags |= SDL_FULLSCREEN;
+            NX_EnterFullScreen (this);
         } else {
-            screen -> flags &= ~ SDL_FULLSCREEN ;
+            screen->flags &= ~SDL_FULLSCREEN;
         }
     }
-
 #ifdef ENABLE_NANOX_DIRECT_FB
     /* attempt allocating the client side framebuffer */
-    Clientfb = GrOpenClientFramebuffer();
-    /* NULL return will default to using GrArea()*/
+    Clientfb = GrOpenClientFramebuffer ();
+    /* NULL return will default to using GrArea() */
 #endif
 
-    Dprintf ("leave NX_CreateWindow\n") ;
-    return 0 ;
+    Dprintf ("leave NX_CreateWindow\n");
+    return 0;
 }
 
-SDL_Surface * NX_SetVideoMode (_THIS, SDL_Surface * current,
-                int width, int height, int bpp, Uint32 flags)
+SDL_Surface *
+NX_SetVideoMode (_THIS, SDL_Surface * current,
+                 int width, int height, int bpp, Uint32 flags)
 {
-    Dprintf ("enter NX_SetVideoMode\n") ;
+    Dprintf ("enter NX_SetVideoMode\n");
 
     // Lock the event thread, in multi-threading environments
-    SDL_Lock_EventThread () ;
+    SDL_Lock_EventThread ();
 
-    bpp = SDL_Visual.bpp ;
+    bpp = SDL_Visual.bpp;
     if (NX_CreateWindow (this, current, width, height, bpp, flags) < 0) {
         current = NULL;
         goto done;
     }
 
-    if (current -> w != width || current -> h != height) {
-        current -> w = width ;
-        current -> h = height ;
-        current -> pitch = SDL_CalculatePitch (current) ;
-        NX_ResizeImage (this, current, flags) ;
+    if (current->w != width || current->h != height) {
+        current->w = width;
+        current->h = height;
+        current->pitch = SDL_CalculatePitch (current);
+        NX_ResizeImage (this, current, flags);
     }
-    current -> flags |= (flags & (SDL_RESIZABLE | SDL_NOFRAME)) ;
+    current->flags |= (flags & (SDL_RESIZABLE | SDL_NOFRAME));
 
   done:
-    SDL_Unlock_EventThread () ;
+    SDL_Unlock_EventThread ();
 
-    Dprintf ("leave NX_SetVideoMode\n") ;
+    Dprintf ("leave NX_SetVideoMode\n");
 
     // We're done!
-    return current ;
+    return current;
 }
 
 // ncolors <= 256
-int NX_SetColors (_THIS, int firstcolor, int ncolors, SDL_Color * colors)
+int
+NX_SetColors (_THIS, int firstcolor, int ncolors, SDL_Color * colors)
 {
-    int        i ;
-    GR_PALETTE pal ;
+    int i;
+    GR_PALETTE pal;
 
-    Dprintf ("enter NX_SetColors\n") ;
+    Dprintf ("enter NX_SetColors\n");
+
+    if (ncolors > 256)
+        return 0;
 
-    if (ncolors > 256) return 0 ;
-    
-    pal.count = ncolors ;
-    for (i = 0; i < ncolors; ++ i) {
-        pal.palette [i].r = colors [i].r ;
-        pal.palette [i].g = colors [i].g ;
-        pal.palette [i].b = colors [i].b ;
+    pal.count = ncolors;
+    for (i = 0; i < ncolors; ++i) {
+        pal.palette[i].r = colors[i].r;
+        pal.palette[i].g = colors[i].g;
+        pal.palette[i].b = colors[i].b;
     }
-    GrSetSystemPalette (firstcolor, & pal) ;
+    GrSetSystemPalette (firstcolor, &pal);
 
-    Dprintf ("leave NX_SetColors\n") ;
-    return 1 ;
+    Dprintf ("leave NX_SetColors\n");
+    return 1;
 }
 
-static int NX_ToggleFullScreen (_THIS, int on)
+static int
+NX_ToggleFullScreen (_THIS, int on)
 {
-    SDL_Rect rect ;
-    Uint32   event_thread ;
-    
-    Dprintf ("enter NX_ToggleFullScreen\n") ;
+    SDL_Rect rect;
+    Uint32 event_thread;
+
+    Dprintf ("enter NX_ToggleFullScreen\n");
 
     // Don't switch if we don't own the window
-    if (SDL_windowid) return 0 ;
-    
+    if (SDL_windowid)
+        return 0;
+
     // Don't lock if we are the event thread
-    event_thread = SDL_EventThreadID () ;
+    event_thread = SDL_EventThreadID ();
     if (event_thread && (SDL_ThreadID () == event_thread)) {
-        event_thread = 0 ;
+        event_thread = 0;
     }
     if (event_thread) {
-        SDL_Lock_EventThread() ;
+        SDL_Lock_EventThread ();
     }
-    
+
     if (on) {
-        NX_EnterFullScreen (this) ;
+        NX_EnterFullScreen (this);
     } else {
-        this -> screen -> flags &= ~ SDL_FULLSCREEN ;
-        NX_LeaveFullScreen (this) ;
+        this->screen->flags &= ~SDL_FULLSCREEN;
+        NX_LeaveFullScreen (this);
     }
 
-    rect.x = rect.y = 0 ;
-    rect.w = this -> screen -> w, rect.h = this -> screen -> h ;
-    NX_NormalUpdate (this, 1, & rect) ;
+    rect.x = rect.y = 0;
+    rect.w = this->screen->w, rect.h = this->screen->h;
+    NX_NormalUpdate (this, 1, &rect);
 
     if (event_thread) {
-        SDL_Unlock_EventThread () ;
+        SDL_Unlock_EventThread ();
     }
-    
-    Dprintf ("leave NX_ToggleFullScreen\n") ;
-    return 1 ;
+
+    Dprintf ("leave NX_ToggleFullScreen\n");
+    return 1;
 }
 
 // Update the current mouse state and position
-static void NX_UpdateMouse (_THIS)
+static void
+NX_UpdateMouse (_THIS)
 {
-    int            x, y ;
-    GR_WINDOW_INFO info ;
-    GR_SCREEN_INFO si ;
+    int x, y;
+    GR_WINDOW_INFO info;
+    GR_SCREEN_INFO si;
 
 
-    Dprintf ("enter NX_UpdateMouse\n") ;
+    Dprintf ("enter NX_UpdateMouse\n");
 
     // Lock the event thread, in multi-threading environments
-    SDL_Lock_EventThread () ;
-    
-    GrGetScreenInfo (& si) ;
-    GrGetWindowInfo (SDL_Window, & info) ;
-    x = si.xpos - info.x ;
-    y = si.ypos - info.y ;
+    SDL_Lock_EventThread ();
+
+    GrGetScreenInfo (&si);
+    GrGetWindowInfo (SDL_Window, &info);
+    x = si.xpos - info.x;
+    y = si.ypos - info.y;
     if (x >= 0 && x <= info.width && y >= 0 && y <= info.height) {
-        SDL_PrivateAppActive (1, SDL_APPMOUSEFOCUS) ;
+        SDL_PrivateAppActive (1, SDL_APPMOUSEFOCUS);
         SDL_PrivateMouseMotion (0, 0, x, y);
     } else {
-        SDL_PrivateAppActive (0, SDL_APPMOUSEFOCUS) ;
-    }
-
-    SDL_Unlock_EventThread () ;
-    Dprintf ("leave NX_UpdateMouse\n") ;
-}
-
-static int NX_SetGammaRamp (_THIS, Uint16 * ramp)
-{
-    int i ;
-    Uint16 * red, * green, * blue ;
-    
-    Dprintf ("enter NX_SetGammaRamp\n") ;
-    
-    if (SDL_Visual.bpp != 32 && SDL_Visual.bpp != 24) return -1 ;
-
-    if (! GammaRamp_R) GammaRamp_R = (Uint16 *) SDL_malloc (sizeof (Uint16) * CI_SIZE) ;
-    if (! GammaRamp_G) GammaRamp_G = (Uint16 *) SDL_malloc (sizeof (Uint16) * CI_SIZE) ;
-    if (! GammaRamp_B) GammaRamp_B = (Uint16 *) SDL_malloc (sizeof (Uint16) * CI_SIZE) ;
-    if ((! GammaRamp_R) || (! GammaRamp_G) || (! GammaRamp_B)) {
-        SDL_OutOfMemory () ;
-        return -1 ;
+        SDL_PrivateAppActive (0, SDL_APPMOUSEFOCUS);
     }
 
-    for (i = 0; i < CI_SIZE; ++ i)
-        GammaRamp_R [i] = GammaRamp_G [i] = GammaRamp_B [i] = i ;
-
-    red   = ramp ;
-    green = ramp + CI_SIZE ;
-    blue  = green + CI_SIZE ;
-        
-    for (i = 0; i < CI_SIZE; ++ i) {
-        GammaRamp_R [i] = red   [i] ;
-        GammaRamp_G [i] = green [i] ;
-        GammaRamp_B [i] = blue  [i] ;
-    }
-    SDL_UpdateRect(this->screen, 0, 0, 0, 0);
-
-    Dprintf ("leave NX_SetGammaRamp\n") ;   
-    return 0 ;
+    SDL_Unlock_EventThread ();
+    Dprintf ("leave NX_UpdateMouse\n");
 }
 
-static int NX_GetGammaRamp (_THIS, Uint16 * ramp)
+static int
+NX_SetGammaRamp (_THIS, Uint16 * ramp)
 {
-    int i ;
-    Uint16 * red, * green, * blue ;
+    int i;
+    Uint16 *red, *green, *blue;
+
+    Dprintf ("enter NX_SetGammaRamp\n");
+
+    if (SDL_Visual.bpp != 32 && SDL_Visual.bpp != 24)
+        return -1;
 
-    Dprintf ("enter NX_GetGammaRamp\n") ;   
+    if (!GammaRamp_R)
+        GammaRamp_R = (Uint16 *) SDL_malloc (sizeof (Uint16) * CI_SIZE);
+    if (!GammaRamp_G)
+        GammaRamp_G = (Uint16 *) SDL_malloc (sizeof (Uint16) * CI_SIZE);
+    if (!GammaRamp_B)
+        GammaRamp_B = (Uint16 *) SDL_malloc (sizeof (Uint16) * CI_SIZE);
+    if ((!GammaRamp_R) || (!GammaRamp_G) || (!GammaRamp_B)) {
+        SDL_OutOfMemory ();
+        return -1;
+    }
+
+    for (i = 0; i < CI_SIZE; ++i)
+        GammaRamp_R[i] = GammaRamp_G[i] = GammaRamp_B[i] = i;
+
+    red = ramp;
+    green = ramp + CI_SIZE;
+    blue = green + CI_SIZE;
 
-    if (SDL_Visual.bpp != 32 && SDL_Visual.bpp != 24) return -1 ;
-    red   = ramp ;
-    green = ramp  + CI_SIZE ;
-    blue  = green + CI_SIZE ;
+    for (i = 0; i < CI_SIZE; ++i) {
+        GammaRamp_R[i] = red[i];
+        GammaRamp_G[i] = green[i];
+        GammaRamp_B[i] = blue[i];
+    }
+    SDL_UpdateRect (this->screen, 0, 0, 0, 0);
+
+    Dprintf ("leave NX_SetGammaRamp\n");
+    return 0;
+}
+
+static int
+NX_GetGammaRamp (_THIS, Uint16 * ramp)
+{
+    int i;
+    Uint16 *red, *green, *blue;
+
+    Dprintf ("enter NX_GetGammaRamp\n");
+
+    if (SDL_Visual.bpp != 32 && SDL_Visual.bpp != 24)
+        return -1;
+    red = ramp;
+    green = ramp + CI_SIZE;
+    blue = green + CI_SIZE;
     if (GammaRamp_R && GammaRamp_G && GammaRamp_B) {
-        for (i = 0; i < CI_SIZE; ++ i) {
-            red   [i] = GammaRamp_R [i] ;
-            green [i] = GammaRamp_G [i] ;
-            blue  [i] = GammaRamp_B [i] ;
+        for (i = 0; i < CI_SIZE; ++i) {
+            red[i] = GammaRamp_R[i];
+            green[i] = GammaRamp_G[i];
+            blue[i] = GammaRamp_B[i];
         }
     } else {
-        for (i = 0; i < CI_SIZE; ++ i)
-            red [i] = green [i] = blue [i] = i ;
+        for (i = 0; i < CI_SIZE; ++i)
+            red[i] = green[i] = blue[i] = i;
     }
 
-    Dprintf ("leave NX_GetGammaRamp\n") ;
-    return 0 ;
+    Dprintf ("leave NX_GetGammaRamp\n");
+    return 0;
 }
+
+/* vi: set ts=4 sw=4 expandtab: */