Merge remote-tracking branch 'origin/released'

Conflicts:
	pixman/pixman/pixman-mmx.c
	xorg-server/Xext/shm.c
	xorg-server/Xext/syncsrv.h
	xorg-server/Xext/xvmain.c
	xorg-server/Xi/exevents.c
	xorg-server/Xi/opendev.c
	xorg-server/composite/compalloc.c
	xorg-server/composite/compoverlay.c
	xorg-server/dix/colormap.c
	xorg-server/dix/devices.c
	xorg-server/dix/dispatch.c
	xorg-server/dix/dixfonts.c
	xorg-server/dix/eventconvert.c
	xorg-server/dix/events.c
	xorg-server/dix/gc.c
	xorg-server/dix/getevents.c
	xorg-server/dix/main.c
	xorg-server/dix/privates.c
	xorg-server/dix/registry.c
	xorg-server/dix/resource.c
	xorg-server/exa/exa_accel.c
	xorg-server/exa/exa_migration_classic.c
	xorg-server/exa/exa_unaccel.c
	xorg-server/fb/fb.h
	xorg-server/fb/fbcopy.c
	xorg-server/fb/fbpixmap.c
	xorg-server/glx/dispatch.h
	xorg-server/glx/glapi.h
	xorg-server/glx/glapi_gentable.c
	xorg-server/glx/glapitable.h
	xorg-server/glx/glprocs.h
	xorg-server/glx/glxcmds.c
	xorg-server/glx/glxcmdsswap.c
	xorg-server/glx/glxdricommon.c
	xorg-server/glx/glxdriswrast.c
	xorg-server/glx/glxext.c
	xorg-server/glx/indirect_dispatch.c
	xorg-server/glx/indirect_dispatch.h
	xorg-server/glx/indirect_dispatch_swap.c
	xorg-server/glx/indirect_size.h
	xorg-server/glx/indirect_size_get.h
	xorg-server/glx/indirect_table.c
	xorg-server/glx/indirect_util.c
	xorg-server/glx/rensize.c
	xorg-server/glx/single2swap.c
	xorg-server/glx/singlepix.c
	xorg-server/glx/singlepixswap.c
	xorg-server/glx/singlesize.c
	xorg-server/hw/dmx/dmxinit.c
	xorg-server/hw/kdrive/ephyr/ephyr.c
	xorg-server/hw/kdrive/ephyr/hostx.c
	xorg-server/hw/kdrive/ephyr/hostx.h
	xorg-server/hw/kdrive/src/kinput.c
	xorg-server/hw/xfree86/common/compiler.h
	xorg-server/hw/xwin/InitInput.c
	xorg-server/hw/xwin/InitOutput.c
	xorg-server/hw/xwin/ddraw.h
	xorg-server/hw/xwin/glx/glwrap.c
	xorg-server/hw/xwin/glx/indirect.c
	xorg-server/hw/xwin/glx/wgl_ext_api.h
	xorg-server/hw/xwin/glx/winpriv.c
	xorg-server/hw/xwin/win.h
	xorg-server/hw/xwin/winallpriv.c
	xorg-server/hw/xwin/winauth.c
	xorg-server/hw/xwin/winclipboard.h
	xorg-server/hw/xwin/winclipboardinit.c
	xorg-server/hw/xwin/winclipboardthread.c
	xorg-server/hw/xwin/winclipboardunicode.c
	xorg-server/hw/xwin/winclipboardwndproc.c
	xorg-server/hw/xwin/winclipboardwrappers.c
	xorg-server/hw/xwin/winclipboardxevents.c
	xorg-server/hw/xwin/wincmap.c
	xorg-server/hw/xwin/winconfig.c
	xorg-server/hw/xwin/wincreatewnd.c
	xorg-server/hw/xwin/wincursor.c
	xorg-server/hw/xwin/windialogs.c
	xorg-server/hw/xwin/winengine.c
	xorg-server/hw/xwin/winerror.c
	xorg-server/hw/xwin/wingc.c
	xorg-server/hw/xwin/wingetsp.c
	xorg-server/hw/xwin/winkeybd.c
	xorg-server/hw/xwin/winkeybd.h
	xorg-server/hw/xwin/winlayouts.h
	xorg-server/hw/xwin/winmisc.c
	xorg-server/hw/xwin/winmonitors.c
	xorg-server/hw/xwin/winmouse.c
	xorg-server/hw/xwin/winmsg.c
	xorg-server/hw/xwin/winmsg.h
	xorg-server/hw/xwin/winmultiwindowclass.c
	xorg-server/hw/xwin/winmultiwindowicons.c
	xorg-server/hw/xwin/winmultiwindowshape.c
	xorg-server/hw/xwin/winmultiwindowwindow.c
	xorg-server/hw/xwin/winmultiwindowwm.c
	xorg-server/hw/xwin/winmultiwindowwndproc.c
	xorg-server/hw/xwin/winnativegdi.c
	xorg-server/hw/xwin/winpfbdd.c
	xorg-server/hw/xwin/winpixmap.c
	xorg-server/hw/xwin/winpolyline.c
	xorg-server/hw/xwin/winprefs.c
	xorg-server/hw/xwin/winprocarg.c
	xorg-server/hw/xwin/winregistry.c
	xorg-server/hw/xwin/winscrinit.c
	xorg-server/hw/xwin/winsetsp.c
	xorg-server/hw/xwin/winshaddd.c
	xorg-server/hw/xwin/winshadddnl.c
	xorg-server/hw/xwin/winshadgdi.c
	xorg-server/hw/xwin/wintrayicon.c
	xorg-server/hw/xwin/winwin32rootless.c
	xorg-server/hw/xwin/winwin32rootlesswindow.c
	xorg-server/hw/xwin/winwin32rootlesswndproc.c
	xorg-server/hw/xwin/winwindow.c
	xorg-server/hw/xwin/winwindow.h
	xorg-server/hw/xwin/winwindowswm.c
	xorg-server/hw/xwin/winwndproc.c
	xorg-server/include/callback.h
	xorg-server/include/dixstruct.h
	xorg-server/include/misc.h
	xorg-server/include/os.h
	xorg-server/include/scrnintstr.h
	xorg-server/mi/micmap.c
	xorg-server/mi/miinitext.c
	xorg-server/mi/mioverlay.c
	xorg-server/mi/misprite.c
	xorg-server/mi/mivaltree.c
	xorg-server/mi/miwindow.c
	xorg-server/miext/damage/damage.c
	xorg-server/miext/rootless/rootlessGC.c
	xorg-server/miext/rootless/rootlessWindow.c
	xorg-server/os/WaitFor.c
	xorg-server/os/access.c
	xorg-server/os/connection.c
	xorg-server/os/io.c
	xorg-server/os/log.c
	xorg-server/os/osinit.c
	xorg-server/os/utils.c
	xorg-server/os/xdmcp.c
	xorg-server/os/xprintf.c
	xorg-server/os/xstrans.c
	xorg-server/render/mipict.c
	xorg-server/xkb/xkbActions.c
	xorg-server/xkb/xkbInit.c
	xorg-server/xkeyboard-config/compat/default.in

1 files changed, 202 insertions, 242 deletions

diff --git a/xorg-server/fb/fboverlay.c b/xorg-server/fb/fboverlay.c
index 255cc23c1..998be66d9 100644
--- a/xorg-server/fb/fboverlay.c
+++ b/xorg-server/fb/fboverlay.c
@@ -22,7 +22,6 @@
  * Author:  Keith Packard, SuSE, Inc.
  */
 
-
 #ifdef HAVE_DIX_CONFIG_H
 #include <dix-config.h>
 #endif
@@ -34,9 +33,11 @@
 #include "shmint.h"
 
 static DevPrivateKeyRec fbOverlayScreenPrivateKeyRec;
+
 #define fbOverlayScreenPrivateKey (&fbOverlayScreenPrivateKeyRec)
 
-DevPrivateKey fbOverlayGetScreenPrivateKey(void)
+DevPrivateKey
+fbOverlayGetScreenPrivateKey(void)
 {
     return fbOverlayScreenPrivateKey;
 }
@@ -48,49 +49,46 @@ DevPrivateKey fbOverlayGetScreenPrivateKey(void)
 Bool
 fbOverlayCreateWindow(WindowPtr pWin)
 {
-    FbOverlayScrPrivPtr	pScrPriv = fbOverlayGetScrPriv(pWin->drawable.pScreen);
-    int			i;
-    PixmapPtr		pPixmap;
-    
+    FbOverlayScrPrivPtr pScrPriv = fbOverlayGetScrPriv(pWin->drawable.pScreen);
+    int i;
+    PixmapPtr pPixmap;
+
     if (pWin->drawable.class != InputOutput)
-	return TRUE;
+        return TRUE;
 
     if (pWin->drawable.bitsPerPixel == 32)
-	pWin->drawable.bitsPerPixel = fbGetScreenPrivate(pWin->drawable.pScreen)->win32bpp;
-
-    for (i = 0; i < pScrPriv->nlayers; i++)
-    {
-	pPixmap = pScrPriv->layer[i].u.run.pixmap;
-	if (pWin->drawable.depth == pPixmap->drawable.depth)
-	{
-	    dixSetPrivate(&pWin->devPrivates, fbGetWinPrivateKey(), pPixmap);
-	    /*
-	     * Make sure layer keys are written correctly by
-	     * having non-root layers set to full while the
-	     * root layer is set to empty.  This will cause
-	     * all of the layers to get painted when the root
-	     * is mapped
-	     */
-	    if (!pWin->parent)
-	    {
-		RegionEmpty(&pScrPriv->layer[i].u.run.region);
-	    }
-	    return TRUE;
-	}
+        pWin->drawable.bitsPerPixel =
+            fbGetScreenPrivate(pWin->drawable.pScreen)->win32bpp;
+
+    for (i = 0; i < pScrPriv->nlayers; i++) {
+        pPixmap = pScrPriv->layer[i].u.run.pixmap;
+        if (pWin->drawable.depth == pPixmap->drawable.depth) {
+            dixSetPrivate(&pWin->devPrivates, fbGetWinPrivateKey(), pPixmap);
+            /*
+             * Make sure layer keys are written correctly by
+             * having non-root layers set to full while the
+             * root layer is set to empty.  This will cause
+             * all of the layers to get painted when the root
+             * is mapped
+             */
+            if (!pWin->parent) {
+                RegionEmpty(&pScrPriv->layer[i].u.run.region);
+            }
+            return TRUE;
+        }
     }
     return FALSE;
 }
 
 Bool
-fbOverlayCloseScreen (int iScreen, ScreenPtr pScreen)
+fbOverlayCloseScreen(int iScreen, ScreenPtr pScreen)
 {
-    FbOverlayScrPrivPtr	pScrPriv = fbOverlayGetScrPriv(pScreen);
-    int			i;
+    FbOverlayScrPrivPtr pScrPriv = fbOverlayGetScrPriv(pScreen);
+    int i;
 
-    for (i = 0; i < pScrPriv->nlayers; i++)
-    {
-	(*pScreen->DestroyPixmap)(pScrPriv->layer[i].u.run.pixmap);
-	RegionUninit(&pScrPriv->layer[i].u.run.region);
+    for (i = 0; i < pScrPriv->nlayers; i++) {
+        (*pScreen->DestroyPixmap) (pScrPriv->layer[i].u.run.pixmap);
+        RegionUninit(&pScrPriv->layer[i].u.run.region);
     }
     return TRUE;
 }
@@ -102,103 +100,90 @@ int
 fbOverlayWindowLayer(WindowPtr pWin)
 {
     FbOverlayScrPrivPtr pScrPriv = fbOverlayGetScrPriv(pWin->drawable.pScreen);
-    int                 i;
+    int i;
 
     for (i = 0; i < pScrPriv->nlayers; i++)
-	if (dixLookupPrivate(&pWin->devPrivates, fbGetWinPrivateKey()) ==
-	    (pointer) pScrPriv->layer[i].u.run.pixmap)
-	    return i;
+        if (dixLookupPrivate(&pWin->devPrivates, fbGetWinPrivateKey()) ==
+            (pointer) pScrPriv->layer[i].u.run.pixmap)
+            return i;
     return 0;
 }
 
 Bool
 fbOverlayCreateScreenResources(ScreenPtr pScreen)
 {
-    int			i;
-    FbOverlayScrPrivPtr	pScrPriv = fbOverlayGetScrPriv(pScreen);
-    PixmapPtr		pPixmap;
-    pointer		pbits;
-    int			width;
-    int			depth;
-    BoxRec		box;
-    
+    int i;
+    FbOverlayScrPrivPtr pScrPriv = fbOverlayGetScrPriv(pScreen);
+    PixmapPtr pPixmap;
+    pointer pbits;
+    int width;
+    int depth;
+    BoxRec box;
+
     if (!miCreateScreenResources(pScreen))
-	return FALSE;
+        return FALSE;
 
     box.x1 = 0;
     box.y1 = 0;
     box.x2 = pScreen->width;
     box.y2 = pScreen->height;
-    for (i = 0; i < pScrPriv->nlayers; i++)
-    {
-	pbits = pScrPriv->layer[i].u.init.pbits;
-	width = pScrPriv->layer[i].u.init.width;
-	depth = pScrPriv->layer[i].u.init.depth;
-	pPixmap = (*pScreen->CreatePixmap)(pScreen, 0, 0, depth, 0);
-	if (!pPixmap)
-	    return FALSE;
-	if (!(*pScreen->ModifyPixmapHeader)(pPixmap, pScreen->width,
-					    pScreen->height, depth,
-					    BitsPerPixel(depth),
-					    PixmapBytePad(width, depth),
-					    pbits))
-	    return FALSE;
-	pScrPriv->layer[i].u.run.pixmap = pPixmap;
-	RegionInit(&pScrPriv->layer[i].u.run.region, &box, 0);
+    for (i = 0; i < pScrPriv->nlayers; i++) {
+        pbits = pScrPriv->layer[i].u.init.pbits;
+        width = pScrPriv->layer[i].u.init.width;
+        depth = pScrPriv->layer[i].u.init.depth;
+        pPixmap = (*pScreen->CreatePixmap) (pScreen, 0, 0, depth, 0);
+        if (!pPixmap)
+            return FALSE;
+        if (!(*pScreen->ModifyPixmapHeader) (pPixmap, pScreen->width,
+                                             pScreen->height, depth,
+                                             BitsPerPixel(depth),
+                                             PixmapBytePad(width, depth),
+                                             pbits))
+            return FALSE;
+        pScrPriv->layer[i].u.run.pixmap = pPixmap;
+        RegionInit(&pScrPriv->layer[i].u.run.region, &box, 0);
     }
     pScreen->devPrivate = pScrPriv->layer[0].u.run.pixmap;
     return TRUE;
 }
 
 void
-fbOverlayPaintKey (DrawablePtr	pDrawable,
-		   RegionPtr	pRegion,
-		   CARD32	pixel,
-		   int		layer)
+fbOverlayPaintKey(DrawablePtr pDrawable,
+                  RegionPtr pRegion, CARD32 pixel, int layer)
 {
-    fbFillRegionSolid (pDrawable, pRegion, 0, 
-		       fbReplicatePixel (pixel, pDrawable->bitsPerPixel));
+    fbFillRegionSolid(pDrawable, pRegion, 0,
+                      fbReplicatePixel(pixel, pDrawable->bitsPerPixel));
 }
 
 /*
  * Track visible region for each layer
  */
 void
-fbOverlayUpdateLayerRegion (ScreenPtr	pScreen,
-			    int		layer,
-			    RegionPtr	prgn)
+fbOverlayUpdateLayerRegion(ScreenPtr pScreen, int layer, RegionPtr prgn)
 {
     FbOverlayScrPrivPtr pScrPriv = fbOverlayGetScrPriv(pScreen);
-    int			i;
-    RegionRec		rgnNew;
-    
+    int i;
+    RegionRec rgnNew;
+
     if (!prgn || !RegionNotEmpty(prgn))
-	return;
-    for (i = 0; i < pScrPriv->nlayers; i++)
-    {
-	if (i == layer)
-	{
-	    /* add new piece to this fb */
-	    RegionUnion(&pScrPriv->layer[i].u.run.region,
-			&pScrPriv->layer[i].u.run.region,
-			prgn);
-	}
-	else if (RegionNotEmpty(&pScrPriv->layer[i].u.run.region))
-	{
-	    /* paint new piece with chroma key */
-	    RegionNull(&rgnNew);
-	    RegionIntersect(&rgnNew, prgn,
-			    &pScrPriv->layer[i].u.run.region);
-	    (*pScrPriv->PaintKey) (&pScrPriv->layer[i].u.run.pixmap->drawable,
-				   &rgnNew,
-				   pScrPriv->layer[i].key,
-				   i);
-	    RegionUninit(&rgnNew);
-	    /* remove piece from other fbs */
-	    RegionSubtract(&pScrPriv->layer[i].u.run.region,
-			   &pScrPriv->layer[i].u.run.region,
-			   prgn);
-	}
+        return;
+    for (i = 0; i < pScrPriv->nlayers; i++) {
+        if (i == layer) {
+            /* add new piece to this fb */
+            RegionUnion(&pScrPriv->layer[i].u.run.region,
+                        &pScrPriv->layer[i].u.run.region, prgn);
+        }
+        else if (RegionNotEmpty(&pScrPriv->layer[i].u.run.region)) {
+            /* paint new piece with chroma key */
+            RegionNull(&rgnNew);
+            RegionIntersect(&rgnNew, prgn, &pScrPriv->layer[i].u.run.region);
+            (*pScrPriv->PaintKey) (&pScrPriv->layer[i].u.run.pixmap->drawable,
+                                   &rgnNew, pScrPriv->layer[i].key, i);
+            RegionUninit(&rgnNew);
+            /* remove piece from other fbs */
+            RegionSubtract(&pScrPriv->layer[i].u.run.region,
+                           &pScrPriv->layer[i].u.run.region, prgn);
+        }
     }
 }
 
@@ -206,17 +191,15 @@ fbOverlayUpdateLayerRegion (ScreenPtr	pScreen,
  * Copy only areas in each layer containing real bits
  */
 void
-fbOverlayCopyWindow(WindowPtr	pWin,
-		    DDXPointRec	ptOldOrg,
-		    RegionPtr	prgnSrc)
+fbOverlayCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
 {
-    ScreenPtr		pScreen = pWin->drawable.pScreen;
-    FbOverlayScrPrivPtr	pScrPriv = fbOverlayGetScrPriv(pScreen);
-    RegionRec		rgnDst;
-    int			dx, dy;
-    int			i;
-    RegionRec		layerRgn[FB_OVERLAY_MAX];
-    PixmapPtr		pPixmap;
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    FbOverlayScrPrivPtr pScrPriv = fbOverlayGetScrPriv(pScreen);
+    RegionRec rgnDst;
+    int dx, dy;
+    int i;
+    RegionRec layerRgn[FB_OVERLAY_MAX];
+    PixmapPtr pPixmap;
 
     dx = ptOldOrg.x - pWin->drawable.x;
     dy = ptOldOrg.y - pWin->drawable.y;
@@ -231,168 +214,146 @@ fbOverlayCopyWindow(WindowPtr	pWin,
     /*
      * Compute the portion of each fb affected by this copy
      */
-    for (i = 0; i < pScrPriv->nlayers; i++)
-    {
-	RegionNull(&layerRgn[i]);
-	RegionIntersect(&layerRgn[i], &rgnDst,
-			 &pScrPriv->layer[i].u.run.region);
-	if (RegionNotEmpty(&layerRgn[i]))
-	{
-	    RegionTranslate(&layerRgn[i], -dx, -dy);
-	    pPixmap = pScrPriv->layer[i].u.run.pixmap;
-	    miCopyRegion (&pPixmap->drawable, &pPixmap->drawable,
-			  0,
-			  &layerRgn[i], dx, dy, pScrPriv->CopyWindow, 0,
-			  (void *)(long) i);
-	}
+    for (i = 0; i < pScrPriv->nlayers; i++) {
+        RegionNull(&layerRgn[i]);
+        RegionIntersect(&layerRgn[i], &rgnDst,
+                        &pScrPriv->layer[i].u.run.region);
+        if (RegionNotEmpty(&layerRgn[i])) {
+            RegionTranslate(&layerRgn[i], -dx, -dy);
+            pPixmap = pScrPriv->layer[i].u.run.pixmap;
+            miCopyRegion(&pPixmap->drawable, &pPixmap->drawable,
+                         0,
+                         &layerRgn[i], dx, dy, pScrPriv->CopyWindow, 0,
+                         (void *) (long) i);
+        }
     }
     /*
      * Update regions
      */
-    for (i = 0; i < pScrPriv->nlayers; i++)
-    {
-	if (RegionNotEmpty(&layerRgn[i]))
-	    fbOverlayUpdateLayerRegion (pScreen, i, &layerRgn[i]);
+    for (i = 0; i < pScrPriv->nlayers; i++) {
+        if (RegionNotEmpty(&layerRgn[i]))
+            fbOverlayUpdateLayerRegion(pScreen, i, &layerRgn[i]);
 
-	RegionUninit(&layerRgn[i]);
+        RegionUninit(&layerRgn[i]);
     }
     RegionUninit(&rgnDst);
-}   
+}
 
 void
-fbOverlayWindowExposures (WindowPtr	pWin,
-			  RegionPtr	prgn,
-			  RegionPtr	other_exposed)
+fbOverlayWindowExposures(WindowPtr pWin,
+                         RegionPtr prgn, RegionPtr other_exposed)
 {
-    fbOverlayUpdateLayerRegion (pWin->drawable.pScreen,
-				fbOverlayWindowLayer (pWin),
-				prgn);
+    fbOverlayUpdateLayerRegion(pWin->drawable.pScreen,
+                               fbOverlayWindowLayer(pWin), prgn);
     miWindowExposures(pWin, prgn, other_exposed);
 }
 
 Bool
-fbOverlaySetupScreen(ScreenPtr	pScreen,
-		     pointer	pbits1,
-		     pointer	pbits2,
-		     int	xsize,
-		     int	ysize,
-		     int	dpix,
-		     int	dpiy,
-		     int	width1,
-		     int	width2,
-		     int	bpp1,
-		     int	bpp2)
+fbOverlaySetupScreen(ScreenPtr pScreen,
+                     pointer pbits1,
+                     pointer pbits2,
+                     int xsize,
+                     int ysize,
+                     int dpix,
+                     int dpiy, int width1, int width2, int bpp1, int bpp2)
 {
-    return fbSetupScreen (pScreen,
-			  pbits1,
-			  xsize,
-			  ysize,
-			  dpix,
-			  dpiy,
-			  width1,
-			  bpp1);
+    return fbSetupScreen(pScreen,
+                         pbits1, xsize, ysize, dpix, dpiy, width1, bpp1);
 }
 
 static Bool
 fb24_32OverlayCreateScreenResources(ScreenPtr pScreen)
 {
-    FbOverlayScrPrivPtr	pScrPriv = fbOverlayGetScrPriv(pScreen);
+    FbOverlayScrPrivPtr pScrPriv = fbOverlayGetScrPriv(pScreen);
     int pitch;
     Bool retval;
     int i;
 
-    if((retval = fbOverlayCreateScreenResources(pScreen))) {
-	for (i = 0; i < pScrPriv->nlayers; i++)
-	{
-	    /* fix the screen pixmap */
-	    PixmapPtr pPix = (PixmapPtr) pScrPriv->layer[i].u.run.pixmap;
-	    if (pPix->drawable.bitsPerPixel == 32) {
-		pPix->drawable.bitsPerPixel = 24;
-		pitch = BitmapBytePad(pPix->drawable.width * 24);
-		pPix->devKind = pitch;
-	    }
-	}
+    if ((retval = fbOverlayCreateScreenResources(pScreen))) {
+        for (i = 0; i < pScrPriv->nlayers; i++) {
+            /* fix the screen pixmap */
+            PixmapPtr pPix = (PixmapPtr) pScrPriv->layer[i].u.run.pixmap;
+
+            if (pPix->drawable.bitsPerPixel == 32) {
+                pPix->drawable.bitsPerPixel = 24;
+                pitch = BitmapBytePad(pPix->drawable.width * 24);
+                pPix->devKind = pitch;
+            }
+        }
     }
 
     return retval;
 }
 
 Bool
-fbOverlayFinishScreenInit(ScreenPtr	pScreen,
-			  pointer	pbits1,
-			  pointer	pbits2,
-			  int		xsize,
-			  int		ysize,
-			  int		dpix,
-			  int		dpiy,
-			  int		width1,
-			  int		width2,
-			  int		bpp1,
-			  int		bpp2,
-			  int		depth1,
-			  int		depth2)
+fbOverlayFinishScreenInit(ScreenPtr pScreen,
+                          pointer pbits1,
+                          pointer pbits2,
+                          int xsize,
+                          int ysize,
+                          int dpix,
+                          int dpiy,
+                          int width1,
+                          int width2,
+                          int bpp1, int bpp2, int depth1, int depth2)
 {
-    VisualPtr	visuals;
-    DepthPtr	depths;
-    int		nvisuals;
-    int		ndepths;
-    int		bpp = 0, imagebpp = 32;
-    VisualID	defaultVisual;
-    FbOverlayScrPrivPtr	pScrPriv;
-
-    if (!dixRegisterPrivateKey(&fbOverlayScreenPrivateKeyRec, PRIVATE_SCREEN, 0))
-	return FALSE;
-
-    pScrPriv = malloc(sizeof (FbOverlayScrPrivRec));
+    VisualPtr visuals;
+    DepthPtr depths;
+    int nvisuals;
+    int ndepths;
+    int bpp = 0, imagebpp = 32;
+    VisualID defaultVisual;
+    FbOverlayScrPrivPtr pScrPriv;
+
+    if (!dixRegisterPrivateKey
+        (&fbOverlayScreenPrivateKeyRec, PRIVATE_SCREEN, 0))
+        return FALSE;
+
+    pScrPriv = malloc(sizeof(FbOverlayScrPrivRec));
     if (!pScrPriv)
-	return FALSE;
- 
+        return FALSE;
+
     if (bpp1 == 32 || bpp2 == 32)
-	bpp = 32;
+        bpp = 32;
     else if (bpp1 == 24 || bpp2 == 24)
-	bpp = 24;
-
-    if (bpp == 24)
-    {
-	int	f;
-	
-	imagebpp = 32;
-	/*
-	 * Check to see if we're advertising a 24bpp image format,
-	 * in which case windows will use it in preference to a 32 bit
-	 * format.
-	 */
-	for (f = 0; f < screenInfo.numPixmapFormats; f++)
-	{
-	    if (screenInfo.formats[f].bitsPerPixel == 24)
-	    {
-		imagebpp = 24;
-		break;
-	    }
-	}	    
+        bpp = 24;
+
+    if (bpp == 24) {
+        int f;
+
+        imagebpp = 32;
+        /*
+         * Check to see if we're advertising a 24bpp image format,
+         * in which case windows will use it in preference to a 32 bit
+         * format.
+         */
+        for (f = 0; f < screenInfo.numPixmapFormats; f++) {
+            if (screenInfo.formats[f].bitsPerPixel == 24) {
+                imagebpp = 24;
+                break;
+            }
+        }
     }
-    if (imagebpp == 32)
-    {
-	fbGetScreenPrivate(pScreen)->win32bpp = bpp;
-	fbGetScreenPrivate(pScreen)->pix32bpp = bpp;
+    if (imagebpp == 32) {
+        fbGetScreenPrivate(pScreen)->win32bpp = bpp;
+        fbGetScreenPrivate(pScreen)->pix32bpp = bpp;
     }
-    else
-    {
-	fbGetScreenPrivate(pScreen)->win32bpp = 32;
-	fbGetScreenPrivate(pScreen)->pix32bpp = 32;
+    else {
+        fbGetScreenPrivate(pScreen)->win32bpp = 32;
+        fbGetScreenPrivate(pScreen)->pix32bpp = 32;
     }
-   
-    if (!fbInitVisuals (&visuals, &depths, &nvisuals, &ndepths, &depth1,
-			&defaultVisual, ((unsigned long)1<<(bpp1-1)) |
-			((unsigned long)1<<(bpp2-1)), 8)) {
-	free(pScrPriv);
-	return FALSE;
+
+    if (!fbInitVisuals(&visuals, &depths, &nvisuals, &ndepths, &depth1,
+                       &defaultVisual, ((unsigned long) 1 << (bpp1 - 1)) |
+                       ((unsigned long) 1 << (bpp2 - 1)), 8)) {
+        free(pScrPriv);
+        return FALSE;
     }
-    if (! miScreenInit(pScreen, 0, xsize, ysize, dpix, dpiy, 0,
-			depth1, ndepths, depths,
-			defaultVisual, nvisuals, visuals)) {
-	free(pScrPriv);
-	return FALSE;
+    if (!miScreenInit(pScreen, 0, xsize, ysize, dpix, dpiy, 0,
+                      depth1, ndepths, depths,
+                      defaultVisual, nvisuals, visuals)) {
+        free(pScrPriv);
+        return FALSE;
     }
     /* MI thinks there's no frame buffer */
 #ifdef MITSHM
@@ -400,7 +361,7 @@ fbOverlayFinishScreenInit(ScreenPtr	pScreen,
 #endif
     pScreen->minInstalledCmaps = 1;
     pScreen->maxInstalledCmaps = 2;
-    
+
     pScrPriv->nlayers = 2;
     pScrPriv->PaintKey = fbOverlayPaintKey;
     pScrPriv->CopyWindow = fbCopyWindowProc;
@@ -412,17 +373,16 @@ fbOverlayFinishScreenInit(ScreenPtr	pScreen,
     pScrPriv->layer[1].u.init.width = width2;
     pScrPriv->layer[1].u.init.depth = depth2;
     dixSetPrivate(&pScreen->devPrivates, fbOverlayScreenPrivateKey, pScrPriv);
-    
+
     /* overwrite miCloseScreen with our own */
     pScreen->CloseScreen = fbOverlayCloseScreen;
     pScreen->CreateScreenResources = fbOverlayCreateScreenResources;
     pScreen->CreateWindow = fbOverlayCreateWindow;
     pScreen->WindowExposures = fbOverlayWindowExposures;
     pScreen->CopyWindow = fbOverlayCopyWindow;
-    if (bpp == 24 && imagebpp == 32)
-    {
-	pScreen->ModifyPixmapHeader = fb24_32ModifyPixmapHeader;
-  	pScreen->CreateScreenResources = fb24_32OverlayCreateScreenResources;
+    if (bpp == 24 && imagebpp == 32) {
+        pScreen->ModifyPixmapHeader = fb24_32ModifyPixmapHeader;
+        pScreen->CreateScreenResources = fb24_32OverlayCreateScreenResources;
     }
 
     return TRUE;