--- a/src/video/x11/SDL_x11image.c	Mon May 29 03:53:21 2006 +0000
+++ b/src/video/x11/SDL_x11image.c	Mon May 29 04:04:35 2006 +0000
@@ -34,17 +34,17 @@
 static int shm_error;
 static int (*X_handler) (Display *, XErrorEvent *) = NULL;
 static int
-shm_errhandler (Display * d, XErrorEvent * e)
+shm_errhandler(Display * d, XErrorEvent * e)
 {
     if (e->error_code == BadAccess) {
         shm_error = True;
         return (0);
     } else
-        return (X_handler (d, e));
+        return (X_handler(d, e));
 }
 
 static void
-try_mitshm (_THIS, SDL_Surface * screen)
+try_mitshm(_THIS, SDL_Surface * screen)
 {
     /* Dynamic X11 may not have SHM entry points on this box. */
     if ((use_mitshm) && (!SDL_X11_HAVE_SHM))
@@ -52,23 +52,23 @@
 
     if (!use_mitshm)
         return;
-    shminfo.shmid = shmget (IPC_PRIVATE, screen->h * screen->pitch,
-                            IPC_CREAT | 0777);
+    shminfo.shmid = shmget(IPC_PRIVATE, screen->h * screen->pitch,
+                           IPC_CREAT | 0777);
     if (shminfo.shmid >= 0) {
-        shminfo.shmaddr = (char *) shmat (shminfo.shmid, 0, 0);
+        shminfo.shmaddr = (char *) shmat(shminfo.shmid, 0, 0);
         shminfo.readOnly = False;
         if (shminfo.shmaddr != (char *) -1) {
             shm_error = False;
-            X_handler = XSetErrorHandler (shm_errhandler);
-            XShmAttach (SDL_Display, &shminfo);
-            XSync (SDL_Display, True);
-            XSetErrorHandler (X_handler);
+            X_handler = XSetErrorHandler(shm_errhandler);
+            XShmAttach(SDL_Display, &shminfo);
+            XSync(SDL_Display, True);
+            XSetErrorHandler(X_handler);
             if (shm_error)
-                shmdt (shminfo.shmaddr);
+                shmdt(shminfo.shmaddr);
         } else {
             shm_error = True;
         }
-        shmctl (shminfo.shmid, IPC_RMID, NULL);
+        shmctl(shminfo.shmid, IPC_RMID, NULL);
     } else {
         shm_error = True;
     }
@@ -80,23 +80,23 @@
 #endif /* ! NO_SHARED_MEMORY */
 
 /* Various screen update functions available */
-static void X11_NormalUpdate (_THIS, int numrects, SDL_Rect * rects);
-static void X11_MITSHMUpdate (_THIS, int numrects, SDL_Rect * rects);
+static void X11_NormalUpdate(_THIS, int numrects, SDL_Rect * rects);
+static void X11_MITSHMUpdate(_THIS, int numrects, SDL_Rect * rects);
 
 int
-X11_SetupImage (_THIS, SDL_Surface * screen)
+X11_SetupImage(_THIS, SDL_Surface * screen)
 {
 #ifndef NO_SHARED_MEMORY
-    try_mitshm (this, screen);
+    try_mitshm(this, screen);
     if (use_mitshm) {
-        SDL_Ximage = XShmCreateImage (SDL_Display, SDL_Visual,
-                                      this->hidden->depth, ZPixmap,
-                                      shminfo.shmaddr, &shminfo,
-                                      screen->w, screen->h);
+        SDL_Ximage = XShmCreateImage(SDL_Display, SDL_Visual,
+                                     this->hidden->depth, ZPixmap,
+                                     shminfo.shmaddr, &shminfo,
+                                     screen->w, screen->h);
         if (!SDL_Ximage) {
-            XShmDetach (SDL_Display, &shminfo);
-            XSync (SDL_Display, False);
-            shmdt (shminfo.shmaddr);
+            XShmDetach(SDL_Display, &shminfo);
+            XSync(SDL_Display, False);
+            shmdt(shminfo.shmaddr);
             screen->pixels = NULL;
             goto error;
         }
@@ -106,16 +106,16 @@
 #endif /* not NO_SHARED_MEMORY */
     {
         int bpp;
-        screen->pixels = SDL_malloc (screen->h * screen->pitch);
+        screen->pixels = SDL_malloc(screen->h * screen->pitch);
         if (screen->pixels == NULL) {
-            SDL_OutOfMemory ();
+            SDL_OutOfMemory();
             return -1;
         }
         bpp = screen->format->BytesPerPixel;
-        SDL_Ximage = XCreateImage (SDL_Display, SDL_Visual,
-                                   this->hidden->depth, ZPixmap, 0,
-                                   (char *) screen->pixels,
-                                   screen->w, screen->h, 32, 0);
+        SDL_Ximage = XCreateImage(SDL_Display, SDL_Visual,
+                                  this->hidden->depth, ZPixmap, 0,
+                                  (char *) screen->pixels,
+                                  screen->w, screen->h, 32, 0);
         if (SDL_Ximage == NULL)
             goto error;
         /* XPutImage will convert byte sex automatically */
@@ -127,20 +127,20 @@
     return (0);
 
   error:
-    SDL_SetError ("Couldn't create XImage");
+    SDL_SetError("Couldn't create XImage");
     return 1;
 }
 
 void
-X11_DestroyImage (_THIS, SDL_Surface * screen)
+X11_DestroyImage(_THIS, SDL_Surface * screen)
 {
     if (SDL_Ximage) {
-        XDestroyImage (SDL_Ximage);
+        XDestroyImage(SDL_Ximage);
 #ifndef NO_SHARED_MEMORY
         if (use_mitshm) {
-            XShmDetach (SDL_Display, &shminfo);
-            XSync (SDL_Display, False);
-            shmdt (shminfo.shmaddr);
+            XShmDetach(SDL_Display, &shminfo);
+            XSync(SDL_Display, False);
+            shmdt(shminfo.shmaddr);
         }
 #endif /* ! NO_SHARED_MEMORY */
         SDL_Ximage = NULL;
@@ -152,30 +152,30 @@
 
 /* Determine the number of CPUs in the system */
 static int
-num_CPU (void)
+num_CPU(void)
 {
     static int num_cpus = 0;
 
     if (!num_cpus) {
 #if defined(__LINUX__)
         char line[BUFSIZ];
-        FILE *pstat = fopen ("/proc/stat", "r");
+        FILE *pstat = fopen("/proc/stat", "r");
         if (pstat) {
-            while (fgets (line, sizeof (line), pstat)) {
-                if (SDL_memcmp (line, "cpu", 3) == 0 && line[3] != ' ') {
+            while (fgets(line, sizeof(line), pstat)) {
+                if (SDL_memcmp(line, "cpu", 3) == 0 && line[3] != ' ') {
                     ++num_cpus;
                 }
             }
-            fclose (pstat);
+            fclose(pstat);
         }
 #elif defined(__IRIX__)
-        num_cpus = sysconf (_SC_NPROC_ONLN);
+        num_cpus = sysconf(_SC_NPROC_ONLN);
 #elif defined(_SC_NPROCESSORS_ONLN)
         /* number of processors online (SVR4.0MP compliant machines) */
-        num_cpus = sysconf (_SC_NPROCESSORS_ONLN);
+        num_cpus = sysconf(_SC_NPROCESSORS_ONLN);
 #elif defined(_SC_NPROCESSORS_CONF)
         /* number of processors configured (SVR4.0MP compliant machines) */
-        num_cpus = sysconf (_SC_NPROCESSORS_CONF);
+        num_cpus = sysconf(_SC_NPROCESSORS_CONF);
 #endif
         if (num_cpus <= 0) {
             num_cpus = 1;
@@ -185,15 +185,15 @@
 }
 
 int
-X11_ResizeImage (_THIS, SDL_Surface * screen, Uint32 flags)
+X11_ResizeImage(_THIS, SDL_Surface * screen, Uint32 flags)
 {
     int retval;
 
-    X11_DestroyImage (this, screen);
+    X11_DestroyImage(this, screen);
     if (flags & SDL_INTERNALOPENGL) {   /* No image when using GL */
         retval = 0;
     } else {
-        retval = X11_SetupImage (this, screen);
+        retval = X11_SetupImage(this, screen);
         /* We support asynchronous blitting on the display */
         if (flags & SDL_ASYNCBLIT) {
             /* This is actually slower on single-CPU systems,
@@ -201,7 +201,7 @@
                X server and the application.
                Note: Is this still true with XFree86 4.0?
              */
-            if (num_CPU () > 1) {
+            if (num_CPU() > 1) {
                 screen->flags |= SDL_ASYNCBLIT;
             }
         }
@@ -211,41 +211,41 @@
 
 /* We don't actually allow hardware surfaces other than the main one */
 int
-X11_AllocHWSurface (_THIS, SDL_Surface * surface)
+X11_AllocHWSurface(_THIS, SDL_Surface * surface)
 {
     return (-1);
 }
 
 void
-X11_FreeHWSurface (_THIS, SDL_Surface * surface)
+X11_FreeHWSurface(_THIS, SDL_Surface * surface)
 {
     return;
 }
 
 int
-X11_LockHWSurface (_THIS, SDL_Surface * surface)
+X11_LockHWSurface(_THIS, SDL_Surface * surface)
 {
     if ((surface == SDL_VideoSurface) && blit_queued) {
-        XSync (GFX_Display, False);
+        XSync(GFX_Display, False);
         blit_queued = 0;
     }
     return (0);
 }
 
 void
-X11_UnlockHWSurface (_THIS, SDL_Surface * surface)
+X11_UnlockHWSurface(_THIS, SDL_Surface * surface)
 {
     return;
 }
 
 int
-X11_FlipHWSurface (_THIS, SDL_Surface * surface)
+X11_FlipHWSurface(_THIS, SDL_Surface * surface)
 {
     return (0);
 }
 
 static void
-X11_NormalUpdate (_THIS, int numrects, SDL_Rect * rects)
+X11_NormalUpdate(_THIS, int numrects, SDL_Rect * rects)
 {
     int i;
 
@@ -253,20 +253,20 @@
         if (rects[i].w == 0 || rects[i].h == 0) {       /* Clipped? */
             continue;
         }
-        XPutImage (GFX_Display, SDL_Window, SDL_GC, SDL_Ximage,
-                   rects[i].x, rects[i].y,
-                   rects[i].x, rects[i].y, rects[i].w, rects[i].h);
+        XPutImage(GFX_Display, SDL_Window, SDL_GC, SDL_Ximage,
+                  rects[i].x, rects[i].y,
+                  rects[i].x, rects[i].y, rects[i].w, rects[i].h);
     }
     if (SDL_VideoSurface->flags & SDL_ASYNCBLIT) {
-        XFlush (GFX_Display);
+        XFlush(GFX_Display);
         blit_queued = 1;
     } else {
-        XSync (GFX_Display, False);
+        XSync(GFX_Display, False);
     }
 }
 
 static void
-X11_MITSHMUpdate (_THIS, int numrects, SDL_Rect * rects)
+X11_MITSHMUpdate(_THIS, int numrects, SDL_Rect * rects)
 {
 #ifndef NO_SHARED_MEMORY
     int i;
@@ -275,15 +275,15 @@
         if (rects[i].w == 0 || rects[i].h == 0) {       /* Clipped? */
             continue;
         }
-        XShmPutImage (GFX_Display, SDL_Window, SDL_GC, SDL_Ximage,
-                      rects[i].x, rects[i].y,
-                      rects[i].x, rects[i].y, rects[i].w, rects[i].h, False);
+        XShmPutImage(GFX_Display, SDL_Window, SDL_GC, SDL_Ximage,
+                     rects[i].x, rects[i].y,
+                     rects[i].x, rects[i].y, rects[i].w, rects[i].h, False);
     }
     if (SDL_VideoSurface->flags & SDL_ASYNCBLIT) {
-        XFlush (GFX_Display);
+        XFlush(GFX_Display);
         blit_queued = 1;
     } else {
-        XSync (GFX_Display, False);
+        XSync(GFX_Display, False);
     }
 #endif /* ! NO_SHARED_MEMORY */
 }
@@ -297,44 +297,44 @@
 static int enable_autorefresh = 1;
 
 void
-X11_DisableAutoRefresh (_THIS)
+X11_DisableAutoRefresh(_THIS)
 {
     --enable_autorefresh;
 }
 
 void
-X11_EnableAutoRefresh (_THIS)
+X11_EnableAutoRefresh(_THIS)
 {
     ++enable_autorefresh;
 }
 
 void
-X11_RefreshDisplay (_THIS)
+X11_RefreshDisplay(_THIS)
 {
     /* Don't refresh a display that doesn't have an image (like GL)
        Instead, post an expose event so the application can refresh.
      */
     if (!SDL_Ximage || (enable_autorefresh <= 0)) {
-        SDL_PrivateExpose ();
+        SDL_PrivateExpose();
         return;
     }
 #ifndef NO_SHARED_MEMORY
     if (this->UpdateRects == X11_MITSHMUpdate) {
-        XShmPutImage (SDL_Display, SDL_Window, SDL_GC, SDL_Ximage,
-                      0, 0, SDL_CurrentWindow.offset_x,
-                      SDL_CurrentWindow.offset_y,
-                      SDL_CurrentDisplay.current_mode.w,
-                      SDL_CurrentDisplay.current_mode.h, False);
+        XShmPutImage(SDL_Display, SDL_Window, SDL_GC, SDL_Ximage,
+                     0, 0, SDL_CurrentWindow.offset_x,
+                     SDL_CurrentWindow.offset_y,
+                     SDL_CurrentDisplay.current_mode.w,
+                     SDL_CurrentDisplay.current_mode.h, False);
     } else
 #endif /* ! NO_SHARED_MEMORY */
     {
-        XPutImage (SDL_Display, SDL_Window, SDL_GC, SDL_Ximage,
-                   0, 0, SDL_CurrentWindow.offset_x,
-                   SDL_CurrentWindow.offset_y,
-                   SDL_CurrentDisplay.current_mode.w,
-                   SDL_CurrentDisplay.current_mode.h);
+        XPutImage(SDL_Display, SDL_Window, SDL_GC, SDL_Ximage,
+                  0, 0, SDL_CurrentWindow.offset_x,
+                  SDL_CurrentWindow.offset_y,
+                  SDL_CurrentDisplay.current_mode.w,
+                  SDL_CurrentDisplay.current_mode.h);
     }
-    XSync (SDL_Display, False);
+    XSync(SDL_Display, False);
 }
 
 /* vi: set ts=4 sw=4 expandtab: */