--- a/src/video/x11/SDL_x11image.c	Thu Jul 06 18:01:37 2006 +0000
+++ b/src/video/x11/SDL_x11image.c	Mon Jul 10 21:04:37 2006 +0000
@@ -32,246 +32,259 @@
 
 /* Shared memory error handler routine */
 static int shm_error;
-static int (*X_handler)(Display *, XErrorEvent *) = NULL;
-static int shm_errhandler(Display *d, XErrorEvent *e)
+static int (*X_handler) (Display *, XErrorEvent *) = NULL;
+static int
+shm_errhandler(Display * d, XErrorEvent * e)
 {
-        if ( e->error_code == BadAccess ) {
-        	shm_error = True;
-        	return(0);
-        } else
-		return(X_handler(d,e));
+    if (e->error_code == BadAccess) {
+        shm_error = True;
+        return (0);
+    } else
+        return (X_handler(d, e));
 }
 
-static void try_mitshm(_THIS, SDL_Surface *screen)
+static void
+try_mitshm(_THIS, SDL_Surface * screen)
 {
-	/* Dynamic X11 may not have SHM entry points on this box. */
-	if ((use_mitshm) && (!SDL_X11_HAVE_SHM))
-		use_mitshm = 0;
+    /* Dynamic X11 may not have SHM entry points on this box. */
+    if ((use_mitshm) && (!SDL_X11_HAVE_SHM))
+        use_mitshm = 0;
 
-	if(!use_mitshm)
-		return;
-	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.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);
-			if ( shm_error )
-				shmdt(shminfo.shmaddr);
-		} else {
-			shm_error = True;
-		}
-		shmctl(shminfo.shmid, IPC_RMID, NULL);
-	} else {
-		shm_error = True;
-	}
-	if ( shm_error )
-		use_mitshm = 0;
-	if ( use_mitshm )
-		screen->pixels = shminfo.shmaddr;
+    if (!use_mitshm)
+        return;
+    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.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);
+            if (shm_error)
+                shmdt(shminfo.shmaddr);
+        } else {
+            shm_error = True;
+        }
+        shmctl(shminfo.shmid, IPC_RMID, NULL);
+    } else {
+        shm_error = True;
+    }
+    if (shm_error)
+        use_mitshm = 0;
+    if (use_mitshm)
+        screen->pixels = shminfo.shmaddr;
 }
 #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)
+int
+X11_SetupImage(_THIS, SDL_Surface * screen)
 {
 #ifndef NO_SHARED_MEMORY
-	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);
-		if(!SDL_Ximage) {
-			XShmDetach(SDL_Display, &shminfo);
-			XSync(SDL_Display, False);
-			shmdt(shminfo.shmaddr);
-			screen->pixels = NULL;
-			goto error;
-		}
-		this->UpdateRects = X11_MITSHMUpdate;
-	}
-	if(!use_mitshm)
+    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);
+        if (!SDL_Ximage) {
+            XShmDetach(SDL_Display, &shminfo);
+            XSync(SDL_Display, False);
+            shmdt(shminfo.shmaddr);
+            screen->pixels = NULL;
+            goto error;
+        }
+        this->UpdateRects = X11_MITSHMUpdate;
+    }
+    if (!use_mitshm)
 #endif /* not NO_SHARED_MEMORY */
-	{
-		int bpp;
-		screen->pixels = SDL_malloc(screen->h*screen->pitch);
-		if ( screen->pixels == NULL ) {
-			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);
-		if ( SDL_Ximage == NULL )
-			goto error;
-		/* XPutImage will convert byte sex automatically */
-		SDL_Ximage->byte_order = (SDL_BYTEORDER == SDL_BIG_ENDIAN)
-			                 ? MSBFirst : LSBFirst;
-		this->UpdateRects = X11_NormalUpdate;
-	}
-	screen->pitch = SDL_Ximage->bytes_per_line;
-	return(0);
+    {
+        int bpp;
+        screen->pixels = SDL_malloc(screen->h * screen->pitch);
+        if (screen->pixels == NULL) {
+            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);
+        if (SDL_Ximage == NULL)
+            goto error;
+        /* XPutImage will convert byte sex automatically */
+        SDL_Ximage->byte_order = (SDL_BYTEORDER == SDL_BIG_ENDIAN)
+            ? MSBFirst : LSBFirst;
+        this->UpdateRects = X11_NormalUpdate;
+    }
+    screen->pitch = SDL_Ximage->bytes_per_line;
+    return (0);
 
-error:
-	SDL_SetError("Couldn't create XImage");
-	return 1;
+  error:
+    SDL_SetError("Couldn't create XImage");
+    return 1;
 }
 
-void X11_DestroyImage(_THIS, SDL_Surface *screen)
+void
+X11_DestroyImage(_THIS, SDL_Surface * screen)
 {
-	if ( SDL_Ximage ) {
-		XDestroyImage(SDL_Ximage);
+    if (SDL_Ximage) {
+        XDestroyImage(SDL_Ximage);
 #ifndef NO_SHARED_MEMORY
-		if ( use_mitshm ) {
-			XShmDetach(SDL_Display, &shminfo);
-			XSync(SDL_Display, False);
-			shmdt(shminfo.shmaddr);
-		}
+        if (use_mitshm) {
+            XShmDetach(SDL_Display, &shminfo);
+            XSync(SDL_Display, False);
+            shmdt(shminfo.shmaddr);
+        }
 #endif /* ! NO_SHARED_MEMORY */
-		SDL_Ximage = NULL;
-	}
-	if ( screen ) {
-		screen->pixels = NULL;
-	}
+        SDL_Ximage = NULL;
+    }
+    if (screen) {
+        screen->pixels = NULL;
+    }
 }
 
 /* Determine the number of CPUs in the system */
-static int num_CPU(void)
+static int
+num_CPU(void)
 {
-       static int num_cpus = 0;
+    static int num_cpus = 0;
 
-       if(!num_cpus) {
+    if (!num_cpus) {
 #if defined(__LINUX__)
-           char line[BUFSIZ];
-           FILE *pstat = fopen("/proc/stat", "r");
-           if ( pstat ) {
-               while ( fgets(line, sizeof(line), pstat) ) {
-                   if (SDL_memcmp(line, "cpu", 3) == 0 && line[3] != ' ') {
-                       ++num_cpus;
-                   }
-               }
-               fclose(pstat);
-           }
+        char line[BUFSIZ];
+        FILE *pstat = fopen("/proc/stat", "r");
+        if (pstat) {
+            while (fgets(line, sizeof(line), pstat)) {
+                if (SDL_memcmp(line, "cpu", 3) == 0 && line[3] != ' ') {
+                    ++num_cpus;
+                }
+            }
+            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);
+        /* number of processors online (SVR4.0MP compliant machines) */
+        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);
+        /* number of processors configured (SVR4.0MP compliant machines) */
+        num_cpus = sysconf(_SC_NPROCESSORS_CONF);
 #endif
-           if ( num_cpus <= 0 ) {
-               num_cpus = 1;
-           }
-       }
-       return num_cpus;
+        if (num_cpus <= 0) {
+            num_cpus = 1;
+        }
+    }
+    return num_cpus;
 }
 
-int X11_ResizeImage(_THIS, SDL_Surface *screen, Uint32 flags)
+int
+X11_ResizeImage(_THIS, SDL_Surface * screen, Uint32 flags)
 {
-	int retval;
+    int retval;
 
-	X11_DestroyImage(this, screen);
-        if ( flags & SDL_OPENGL ) {  /* No image when using GL */
-        	retval = 0;
-        } else {
-		retval = X11_SetupImage(this, screen);
-		/* We support asynchronous blitting on the display */
-		if ( flags & SDL_ASYNCBLIT ) {
-			/* This is actually slower on single-CPU systems,
-			   probably because of CPU contention between the
-			   X server and the application.
-			   Note: Is this still true with XFree86 4.0?
-			*/
-			if ( num_CPU() > 1 ) {
-				screen->flags |= SDL_ASYNCBLIT;
-			}
-		}
-	}
-	return(retval);
+    X11_DestroyImage(this, screen);
+    if (flags & SDL_INTERNALOPENGL) {   /* No image when using GL */
+        retval = 0;
+    } else {
+        retval = X11_SetupImage(this, screen);
+        /* We support asynchronous blitting on the display */
+        if (flags & SDL_ASYNCBLIT) {
+            /* This is actually slower on single-CPU systems,
+               probably because of CPU contention between the
+               X server and the application.
+               Note: Is this still true with XFree86 4.0?
+             */
+            if (num_CPU() > 1) {
+                screen->flags |= SDL_ASYNCBLIT;
+            }
+        }
+    }
+    return (retval);
 }
 
 /* We don't actually allow hardware surfaces other than the main one */
-int X11_AllocHWSurface(_THIS, SDL_Surface *surface)
+int
+X11_AllocHWSurface(_THIS, SDL_Surface * surface)
 {
-	return(-1);
+    return (-1);
 }
-void X11_FreeHWSurface(_THIS, SDL_Surface *surface)
+
+void
+X11_FreeHWSurface(_THIS, SDL_Surface * surface)
 {
-	return;
+    return;
 }
 
-int X11_LockHWSurface(_THIS, SDL_Surface *surface)
+int
+X11_LockHWSurface(_THIS, SDL_Surface * surface)
 {
-	if ( (surface == SDL_VideoSurface) && blit_queued ) {
-		XSync(GFX_Display, False);
-		blit_queued = 0;
-	}
-	return(0);
-}
-void X11_UnlockHWSurface(_THIS, SDL_Surface *surface)
-{
-	return;
+    if ((surface == SDL_VideoSurface) && blit_queued) {
+        XSync(GFX_Display, False);
+        blit_queued = 0;
+    }
+    return (0);
 }
 
-int X11_FlipHWSurface(_THIS, SDL_Surface *surface)
+void
+X11_UnlockHWSurface(_THIS, SDL_Surface * surface)
 {
-	return(0);
+    return;
+}
+
+int
+X11_FlipHWSurface(_THIS, SDL_Surface * surface)
+{
+    return (0);
 }
 
-static void X11_NormalUpdate(_THIS, int numrects, SDL_Rect *rects)
+static void
+X11_NormalUpdate(_THIS, int numrects, SDL_Rect * rects)
 {
-	int i;
-	
-	for (i = 0; i < numrects; ++i) {
-		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);
-	}
-	if ( SDL_VideoSurface->flags & SDL_ASYNCBLIT ) {
-		XFlush(GFX_Display);
-		blit_queued = 1;
-	} else {
-		XSync(GFX_Display, False);
-	}
+    int i;
+
+    for (i = 0; i < numrects; ++i) {
+        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);
+    }
+    if (SDL_VideoSurface->flags & SDL_ASYNCBLIT) {
+        XFlush(GFX_Display);
+        blit_queued = 1;
+    } else {
+        XSync(GFX_Display, False);
+    }
 }
 
-static void X11_MITSHMUpdate(_THIS, int numrects, SDL_Rect *rects)
+static void
+X11_MITSHMUpdate(_THIS, int numrects, SDL_Rect * rects)
 {
 #ifndef NO_SHARED_MEMORY
-	int i;
+    int i;
 
-	for ( i=0; i<numrects; ++i ) {
-		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);
-	}
-	if ( SDL_VideoSurface->flags & SDL_ASYNCBLIT ) {
-		XFlush(GFX_Display);
-		blit_queued = 1;
-	} else {
-		XSync(GFX_Display, False);
-	}
+    for (i = 0; i < numrects; ++i) {
+        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);
+    }
+    if (SDL_VideoSurface->flags & SDL_ASYNCBLIT) {
+        XFlush(GFX_Display);
+        blit_queued = 1;
+    } else {
+        XSync(GFX_Display, False);
+    }
 #endif /* ! NO_SHARED_MEMORY */
 }
 
@@ -283,36 +296,45 @@
 */
 static int enable_autorefresh = 1;
 
-void X11_DisableAutoRefresh(_THIS)
+void
+X11_DisableAutoRefresh(_THIS)
 {
-	--enable_autorefresh;
+    --enable_autorefresh;
 }
 
-void X11_EnableAutoRefresh(_THIS)
+void
+X11_EnableAutoRefresh(_THIS)
 {
-	++enable_autorefresh;
+    ++enable_autorefresh;
 }
 
-void X11_RefreshDisplay(_THIS)
+void
+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();
-		return;
-	}
+    /* 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();
+        return;
+    }
 #ifndef NO_SHARED_MEMORY
-	if ( this->UpdateRects == X11_MITSHMUpdate ) {
-		XShmPutImage(SDL_Display, SDL_Window, SDL_GC, SDL_Ximage,
-				0, 0, 0, 0, this->screen->w, this->screen->h,
-				False);
-	} else
+    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);
+    } else
 #endif /* ! NO_SHARED_MEMORY */
-	{
-		XPutImage(SDL_Display, SDL_Window, SDL_GC, SDL_Ximage,
-			  0, 0, 0, 0, this->screen->w, this->screen->h);
-	}
-	XSync(SDL_Display, False);
+    {
+        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);
 }
 
+/* vi: set ts=4 sw=4 expandtab: */