libX11 xserver fontconfig mesa pixman xkbcomp xkeyboard-config git update

23 Mar 2012

5 files changed, 1432 insertions, 1621 deletions

diff --git a/xorg-server/dbe/dbe.c b/xorg-server/dbe/dbe.c
index a46867676..ca7f3e278 100644
--- a/xorg-server/dbe/dbe.c
+++ b/xorg-server/dbe/dbe.c
@@ -30,7 +30,6 @@
  *
  *****************************************************************************/
 
-
 /* INCLUDES */
 
 #ifdef HAVE_DIX_CONFIG_H
@@ -57,11 +56,11 @@ DevPrivateKeyRec dbeScreenPrivKeyRec;
 DevPrivateKeyRec dbeWindowPrivKeyRec;
 
 /* These are globals for use by DDX */
-RESTYPE	dbeDrawableResType;
-RESTYPE	dbeWindowPrivResType;
+RESTYPE dbeDrawableResType;
+RESTYPE dbeWindowPrivResType;
 
 /* Used to generate DBE's BadBuffer error. */
-static int	dbeErrorBase;
+static int dbeErrorBase;
 
 /******************************************************************************
  *
@@ -87,19 +86,17 @@ DbeStubScreen(DbeScreenPrivPtr pDbeScreenPriv, int *nStubbedScreens)
      */
 
     /* Stub DDX. */
-    pDbeScreenPriv->GetVisualInfo       = NULL;
+    pDbeScreenPriv->GetVisualInfo = NULL;
     pDbeScreenPriv->AllocBackBufferName = NULL;
-    pDbeScreenPriv->SwapBuffers         = NULL;
-    pDbeScreenPriv->BeginIdiom          = NULL;
-    pDbeScreenPriv->EndIdiom            = NULL;
-    pDbeScreenPriv->WinPrivDelete       = NULL;
-    pDbeScreenPriv->ResetProc           = NULL;
+    pDbeScreenPriv->SwapBuffers = NULL;
+    pDbeScreenPriv->BeginIdiom = NULL;
+    pDbeScreenPriv->EndIdiom = NULL;
+    pDbeScreenPriv->WinPrivDelete = NULL;
+    pDbeScreenPriv->ResetProc = NULL;
 
     (*nStubbedScreens)++;
 
-} /* DbeStubScreen() */
-
-
+}                               /* DbeStubScreen() */
 
 /******************************************************************************
  *
@@ -121,27 +118,25 @@ static int
 ProcDbeGetVersion(ClientPtr client)
 {
     /* REQUEST(xDbeGetVersionReq); */
-    xDbeGetVersionReply	rep;
+    xDbeGetVersionReply rep;
 
     REQUEST_SIZE_MATCH(xDbeGetVersionReq);
 
-    rep.type           = X_Reply;
-    rep.length         = 0;
+    rep.type = X_Reply;
+    rep.length = 0;
     rep.sequenceNumber = client->sequence;
-    rep.majorVersion   = DBE_MAJOR_VERSION;
-    rep.minorVersion   = DBE_MINOR_VERSION;
+    rep.majorVersion = DBE_MAJOR_VERSION;
+    rep.minorVersion = DBE_MINOR_VERSION;
 
-    if (client->swapped)
-    {
+    if (client->swapped) {
         swaps(&rep.sequenceNumber);
     }
 
-    WriteToClient(client, sizeof(xDbeGetVersionReply), (char *)&rep);
+    WriteToClient(client, sizeof(xDbeGetVersionReply), (char *) &rep);
 
     return Success;
 
-} /* ProcDbeGetVersion() */
-
+}                               /* ProcDbeGetVersion() */
 
 /******************************************************************************
  *
@@ -170,38 +165,34 @@ static int
 ProcDbeAllocateBackBufferName(ClientPtr client)
 {
     REQUEST(xDbeAllocateBackBufferNameReq);
-    WindowPtr			pWin;
-    DbeScreenPrivPtr		pDbeScreenPriv;
-    DbeWindowPrivPtr		pDbeWindowPriv;
-    XdbeScreenVisualInfo	scrVisInfo;
-    register int		i;
-    Bool			visualMatched = FALSE;
-    xDbeSwapAction		swapAction;
-    VisualID			visual;
-    int				status;
-    int				add_index;
-
+    WindowPtr pWin;
+    DbeScreenPrivPtr pDbeScreenPriv;
+    DbeWindowPrivPtr pDbeWindowPriv;
+    XdbeScreenVisualInfo scrVisInfo;
+    register int i;
+    Bool visualMatched = FALSE;
+    xDbeSwapAction swapAction;
+    VisualID visual;
+    int status;
+    int add_index;
 
     REQUEST_SIZE_MATCH(xDbeAllocateBackBufferNameReq);
 
     /* The window must be valid. */
     status = dixLookupWindow(&pWin, stuff->window, client, DixManageAccess);
     if (status != Success)
-	return status;
+        return status;
 
     /* The window must be InputOutput. */
-    if (pWin->drawable.class != InputOutput)
-    {
-	return BadMatch;
+    if (pWin->drawable.class != InputOutput) {
+        return BadMatch;
     }
 
     /* The swap action must be valid. */
-    swapAction = stuff->swapAction;	/* use local var for performance. */
-    if ((swapAction != XdbeUndefined ) &&
+    swapAction = stuff->swapAction;     /* use local var for performance. */
+    if ((swapAction != XdbeUndefined) &&
         (swapAction != XdbeBackground) &&
-        (swapAction != XdbeUntouched ) &&
-        (swapAction != XdbeCopied    ))
-    {
+        (swapAction != XdbeUntouched) && (swapAction != XdbeCopied)) {
         return BadValue;
     }
 
@@ -213,115 +204,105 @@ ProcDbeAllocateBackBufferName(ClientPtr client)
      */
     pDbeScreenPriv = DBE_SCREEN_PRIV_FROM_WINDOW(pWin);
     if (!pDbeScreenPriv->GetVisualInfo)
-	return BadMatch; /* screen doesn't support double buffering */
+        return BadMatch;        /* screen doesn't support double buffering */
 
-    if (!(*pDbeScreenPriv->GetVisualInfo)(pWin->drawable.pScreen, &scrVisInfo))
-    {
+    if (!(*pDbeScreenPriv->GetVisualInfo) (pWin->drawable.pScreen, &scrVisInfo)) {
         /* GetVisualInfo() failed to allocate visual info data. */
         return BadAlloc;
     }
 
     /* See if the window's visual is on the list. */
     visual = wVisual(pWin);
-    for (i = 0; (i < scrVisInfo.count) && !visualMatched; i++)
-    {
-        if (scrVisInfo.visinfo[i].visual == visual)
-	{
-	    visualMatched = TRUE;
-	}
+    for (i = 0; (i < scrVisInfo.count) && !visualMatched; i++) {
+        if (scrVisInfo.visinfo[i].visual == visual) {
+            visualMatched = TRUE;
+        }
     }
 
     /* Free what was allocated by the GetVisualInfo() call above. */
     free(scrVisInfo.visinfo);
 
-    if (!visualMatched)
-    {
-	return BadMatch;
+    if (!visualMatched) {
+        return BadMatch;
     }
 
-    if ((pDbeWindowPriv = DBE_WINDOW_PRIV(pWin)) == NULL)
-    {
+    if ((pDbeWindowPriv = DBE_WINDOW_PRIV(pWin)) == NULL) {
         /* There is no buffer associated with the window.
          * Allocate a window priv.
          */
 
-        pDbeWindowPriv = dixAllocateObjectWithPrivates(DbeWindowPrivRec, PRIVATE_DBE_WINDOW);
-	if (!pDbeWindowPriv)
+        pDbeWindowPriv =
+            dixAllocateObjectWithPrivates(DbeWindowPrivRec, PRIVATE_DBE_WINDOW);
+        if (!pDbeWindowPriv)
             return BadAlloc;
 
         /* Fill out window priv information. */
-        pDbeWindowPriv->pWindow      = pWin;
-        pDbeWindowPriv->width        = pWin->drawable.width;
-        pDbeWindowPriv->height       = pWin->drawable.height;
-        pDbeWindowPriv->x            = pWin->drawable.x;
-        pDbeWindowPriv->y            = pWin->drawable.y;
-        pDbeWindowPriv->nBufferIDs   = 0;
+        pDbeWindowPriv->pWindow = pWin;
+        pDbeWindowPriv->width = pWin->drawable.width;
+        pDbeWindowPriv->height = pWin->drawable.height;
+        pDbeWindowPriv->x = pWin->drawable.x;
+        pDbeWindowPriv->y = pWin->drawable.y;
+        pDbeWindowPriv->nBufferIDs = 0;
 
         /* Set the buffer ID array pointer to the initial (static) array). */
         pDbeWindowPriv->IDs = pDbeWindowPriv->initIDs;
 
-        /* Initialize the buffer ID list. */ 
+        /* Initialize the buffer ID list. */
         pDbeWindowPriv->maxAvailableIDs = DBE_INIT_MAX_IDS;
         pDbeWindowPriv->IDs[0] = stuff->buffer;
 
         add_index = 0;
-        for (i = 0; i < DBE_INIT_MAX_IDS; i++)
-        {
+        for (i = 0; i < DBE_INIT_MAX_IDS; i++) {
             pDbeWindowPriv->IDs[i] = DBE_FREE_ID_ELEMENT;
         }
 
         /* Actually connect the window priv to the window. */
         dixSetPrivate(&pWin->devPrivates, dbeWindowPrivKey, pDbeWindowPriv);
 
-    } /* if -- There is no buffer associated with the window. */
+    }                           /* if -- There is no buffer associated with the window. */
 
-    else
-    {
+    else {
         /* A buffer is already associated with the window.
          * Add the new buffer ID to the array, reallocating the array memory
          * if necessary.
          */
 
         /* Determine if there is a free element in the ID array. */
-        for (i = 0; i < pDbeWindowPriv->maxAvailableIDs; i++)
-        {
-            if (pDbeWindowPriv->IDs[i] == DBE_FREE_ID_ELEMENT)
-            {
+        for (i = 0; i < pDbeWindowPriv->maxAvailableIDs; i++) {
+            if (pDbeWindowPriv->IDs[i] == DBE_FREE_ID_ELEMENT) {
                 /* There is still room in the ID array. */
                 break;
             }
         }
- 
-        if (i == pDbeWindowPriv->maxAvailableIDs)
-        {
+
+        if (i == pDbeWindowPriv->maxAvailableIDs) {
             /* No more room in the ID array -- reallocate another array. */
-            XID	*pIDs;
+            XID *pIDs;
 
             /* Setup an array pointer for the realloc operation below. */
-            if (pDbeWindowPriv->maxAvailableIDs == DBE_INIT_MAX_IDS)
-            {
+            if (pDbeWindowPriv->maxAvailableIDs == DBE_INIT_MAX_IDS) {
                 /* We will malloc a new array. */
                 pIDs = NULL;
             }
-            else
-            {
+            else {
                 /* We will realloc a new array. */
                 pIDs = pDbeWindowPriv->IDs;
             }
 
             /* malloc/realloc a new array and initialize all elements to 0. */
-            pDbeWindowPriv->IDs = (XID *)realloc(pIDs,
-                (pDbeWindowPriv->maxAvailableIDs+DBE_INCR_MAX_IDS)*sizeof(XID));
-            if (!pDbeWindowPriv->IDs)
-            {
+            pDbeWindowPriv->IDs = (XID *) realloc(pIDs,
+                                                  (pDbeWindowPriv->
+                                                   maxAvailableIDs +
+                                                   DBE_INCR_MAX_IDS) *
+                                                  sizeof(XID));
+            if (!pDbeWindowPriv->IDs) {
                 return BadAlloc;
             }
             memset(&pDbeWindowPriv->IDs[pDbeWindowPriv->nBufferIDs], 0,
                    (pDbeWindowPriv->maxAvailableIDs + DBE_INCR_MAX_IDS -
                     pDbeWindowPriv->nBufferIDs) * sizeof(XID));
 
-            if (pDbeWindowPriv->maxAvailableIDs == DBE_INIT_MAX_IDS)
-            {
+            if (pDbeWindowPriv->maxAvailableIDs == DBE_INIT_MAX_IDS) {
                 /* We just went from using the initial (static) array to a
                  * newly allocated array.  Copy the IDs from the initial array
                  * to the new array.
@@ -333,21 +314,18 @@ ProcDbeAllocateBackBufferName(ClientPtr client)
             pDbeWindowPriv->maxAvailableIDs += DBE_INCR_MAX_IDS;
         }
 
-	add_index = i;
-
-    } /* else -- A buffer is already associated with the window. */
+        add_index = i;
 
+    }                           /* else -- A buffer is already associated with the window. */
 
     /* Call the DDX routine to allocate the back buffer. */
-    status = (*pDbeScreenPriv->AllocBackBufferName)(pWin, stuff->buffer,
-                                                    stuff->swapAction);
+    status = (*pDbeScreenPriv->AllocBackBufferName) (pWin, stuff->buffer,
+                                                     stuff->swapAction);
 
-    if (status == Success)
-    {
-	pDbeWindowPriv->IDs[add_index] = stuff->buffer;
+    if (status == Success) {
+        pDbeWindowPriv->IDs[add_index] = stuff->buffer;
         if (!AddResource(stuff->buffer, dbeWindowPrivResType,
-                         (pointer)pDbeWindowPriv))
-	{
+                         (pointer) pDbeWindowPriv)) {
             pDbeWindowPriv->IDs[add_index] = DBE_FREE_ID_ELEMENT;
 
             if (pDbeWindowPriv->nBufferIDs == 0) {
@@ -355,7 +333,8 @@ ProcDbeAllocateBackBufferName(ClientPtr client)
                 goto out_free;
             }
         }
-    } else {
+    }
+    else {
         /* The DDX buffer allocation routine failed for the first buffer of
          * this window.
          */
@@ -372,13 +351,12 @@ ProcDbeAllocateBackBufferName(ClientPtr client)
 
     return status;
 
-out_free:
+ out_free:
     dixSetPrivate(&pWin->devPrivates, dbeWindowPrivKey, NULL);
     free(pDbeWindowPriv);
     return status;
 
-} /* ProcDbeAllocateBackBufferName() */
-
+}                               /* ProcDbeAllocateBackBufferName() */
 
 /******************************************************************************
  *
@@ -401,41 +379,37 @@ static int
 ProcDbeDeallocateBackBufferName(ClientPtr client)
 {
     REQUEST(xDbeDeallocateBackBufferNameReq);
-    DbeWindowPrivPtr	pDbeWindowPriv;
-    int			rc, i;
+    DbeWindowPrivPtr pDbeWindowPriv;
+    int rc, i;
     pointer val;
 
-
     REQUEST_SIZE_MATCH(xDbeDeallocateBackBufferNameReq);
 
     /* Buffer name must be valid */
-    rc = dixLookupResourceByType((pointer *)&pDbeWindowPriv, stuff->buffer,
-				 dbeWindowPrivResType, client,
-				 DixDestroyAccess);
+    rc = dixLookupResourceByType((pointer *) &pDbeWindowPriv, stuff->buffer,
+                                 dbeWindowPrivResType, client,
+                                 DixDestroyAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     rc = dixLookupResourceByType(&val, stuff->buffer, dbeDrawableResType,
-				 client, DixDestroyAccess);
+                                 client, DixDestroyAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     /* Make sure that the id is valid for the window.
      * This is paranoid code since we already looked up the ID by type
      * above.
      */
 
-    for (i = 0; i < pDbeWindowPriv->nBufferIDs; i++)
-    {
+    for (i = 0; i < pDbeWindowPriv->nBufferIDs; i++) {
         /* Loop through the ID list to find the ID. */
-        if (pDbeWindowPriv->IDs[i] == stuff->buffer)
-        {
+        if (pDbeWindowPriv->IDs[i] == stuff->buffer) {
             break;
         }
     }
 
-    if (i == pDbeWindowPriv->nBufferIDs)
-    {
+    if (i == pDbeWindowPriv->nBufferIDs) {
         /* We did not find the ID in the ID list. */
         client->errorValue = stuff->buffer;
         return dbeErrorBase + DbeBadBuffer;
@@ -445,8 +419,7 @@ ProcDbeDeallocateBackBufferName(ClientPtr client)
 
     return Success;
 
-} /* ProcDbeDeallocateBackBufferName() */
-
+}                               /* ProcDbeDeallocateBackBufferName() */
 
 /******************************************************************************
  *
@@ -475,82 +448,72 @@ static int
 ProcDbeSwapBuffers(ClientPtr client)
 {
     REQUEST(xDbeSwapBuffersReq);
-    WindowPtr		pWin;
-    DbeScreenPrivPtr	pDbeScreenPriv;
-    DbeSwapInfoPtr	swapInfo;
-    xDbeSwapInfo	*dbeSwapInfo;
-    int			error;
-    register int	i, j;
-    int			nStuff;
-
+    WindowPtr pWin;
+    DbeScreenPrivPtr pDbeScreenPriv;
+    DbeSwapInfoPtr swapInfo;
+    xDbeSwapInfo *dbeSwapInfo;
+    int error;
+    register int i, j;
+    int nStuff;
 
     REQUEST_AT_LEAST_SIZE(xDbeSwapBuffersReq);
-    nStuff = stuff->n;	/* use local variable for performance. */
+    nStuff = stuff->n;          /* use local variable for performance. */
 
-    if (nStuff == 0)
-    {
+    if (nStuff == 0) {
         return Success;
     }
 
     if (nStuff > UINT32_MAX / sizeof(DbeSwapInfoRec))
-	    return BadAlloc;
+        return BadAlloc;
 
     /* Get to the swap info appended to the end of the request. */
-    dbeSwapInfo = (xDbeSwapInfo *)&stuff[1];
+    dbeSwapInfo = (xDbeSwapInfo *) &stuff[1];
 
-    /* Allocate array to record swap information. */ 
-    swapInfo = (DbeSwapInfoPtr)malloc(nStuff * sizeof(DbeSwapInfoRec));
-    if (swapInfo == NULL)
-    {
+    /* Allocate array to record swap information. */
+    swapInfo = (DbeSwapInfoPtr) malloc(nStuff * sizeof(DbeSwapInfoRec));
+    if (swapInfo == NULL) {
         return BadAlloc;
     }
 
-
-    for (i = 0; i < nStuff; i++)
-    {
+    for (i = 0; i < nStuff; i++) {
         /* Check all windows to swap. */
 
         /* Each window must be a valid window - BadWindow. */
-	error = dixLookupWindow(&pWin, dbeSwapInfo[i].window, client,
-				DixWriteAccess);
-	if (error != Success) {
+        error = dixLookupWindow(&pWin, dbeSwapInfo[i].window, client,
+                                DixWriteAccess);
+        if (error != Success) {
             free(swapInfo);
-	    return error;
+            return error;
         }
 
         /* Each window must be double-buffered - BadMatch. */
-        if (DBE_WINDOW_PRIV(pWin) == NULL)
-        {
+        if (DBE_WINDOW_PRIV(pWin) == NULL) {
             free(swapInfo);
             return BadMatch;
         }
 
         /* Each window must only be specified once - BadMatch. */
-        for (j = i + 1; j < nStuff; j++)
-        {
-            if (dbeSwapInfo[i].window == dbeSwapInfo[j].window)
-            {
+        for (j = i + 1; j < nStuff; j++) {
+            if (dbeSwapInfo[i].window == dbeSwapInfo[j].window) {
                 free(swapInfo);
                 return BadMatch;
-	    }
+            }
         }
 
         /* Each swap action must be valid - BadValue. */
-        if ((dbeSwapInfo[i].swapAction != XdbeUndefined ) &&
+        if ((dbeSwapInfo[i].swapAction != XdbeUndefined) &&
             (dbeSwapInfo[i].swapAction != XdbeBackground) &&
-            (dbeSwapInfo[i].swapAction != XdbeUntouched ) &&
-            (dbeSwapInfo[i].swapAction != XdbeCopied    ))
-        {
+            (dbeSwapInfo[i].swapAction != XdbeUntouched) &&
+            (dbeSwapInfo[i].swapAction != XdbeCopied)) {
             free(swapInfo);
             return BadValue;
         }
 
         /* Everything checks out OK.  Fill in the swap info array. */
-        swapInfo[i].pWindow    = pWin;     
-        swapInfo[i].swapAction = dbeSwapInfo[i].swapAction;     
-
-    } /* for (i = 0; i < nStuff; i++) */
+        swapInfo[i].pWindow = pWin;
+        swapInfo[i].swapAction = dbeSwapInfo[i].swapAction;
 
+    }                           /* for (i = 0; i < nStuff; i++) */
 
     /* Call the DDX routine to perform the swap(s).  The DDX routine should
      * scan the swap list (swap info), swap any buffers that it knows how to
@@ -565,22 +528,19 @@ ProcDbeSwapBuffers(ClientPtr client)
      * could deal with cross-screen synchronization.
      */
 
-    while (nStuff > 0)
-    {
+    while (nStuff > 0) {
         pDbeScreenPriv = DBE_SCREEN_PRIV_FROM_WINDOW(swapInfo[0].pWindow);
-        error = (*pDbeScreenPriv->SwapBuffers)(client, &nStuff, swapInfo);
-        if (error != Success)
-        {
+        error = (*pDbeScreenPriv->SwapBuffers) (client, &nStuff, swapInfo);
+        if (error != Success) {
             free(swapInfo);
             return error;
         }
     }
-    
+
     free(swapInfo);
     return Success;
 
-} /* ProcDbeSwapBuffers() */
-
+}                               /* ProcDbeSwapBuffers() */
 
 /******************************************************************************
  *
@@ -602,27 +562,23 @@ static int
 ProcDbeBeginIdiom(ClientPtr client)
 {
     /* REQUEST(xDbeBeginIdiomReq); */
-    DbeScreenPrivPtr	pDbeScreenPriv;
-    register int	i;
-
+    DbeScreenPrivPtr pDbeScreenPriv;
+    register int i;
 
     REQUEST_SIZE_MATCH(xDbeBeginIdiomReq);
 
-    for (i = 0; i < screenInfo.numScreens; i++)
-    {
+    for (i = 0; i < screenInfo.numScreens; i++) {
         pDbeScreenPriv = DBE_SCREEN_PRIV(screenInfo.screens[i]);
 
         /* Call the DDX begin idiom procedure if there is one. */
-        if (pDbeScreenPriv->BeginIdiom)
-        {
-           (*pDbeScreenPriv->BeginIdiom)(client);
+        if (pDbeScreenPriv->BeginIdiom) {
+            (*pDbeScreenPriv->BeginIdiom) (client);
         }
     }
 
     return Success;
 
-} /* ProcDbeBeginIdiom() */
-
+}                               /* ProcDbeBeginIdiom() */
 
 /******************************************************************************
  *
@@ -645,37 +601,33 @@ static int
 ProcDbeGetVisualInfo(ClientPtr client)
 {
     REQUEST(xDbeGetVisualInfoReq);
-    DbeScreenPrivPtr		pDbeScreenPriv;
-    xDbeGetVisualInfoReply	rep;
-    Drawable			*drawables;
-    DrawablePtr			*pDrawables = NULL;
-    register int		i, j, rc;
-    register int		count;  /* number of visual infos in reply */
-    register int		length; /* length of reply */
-    ScreenPtr			pScreen;
-    XdbeScreenVisualInfo	*pScrVisInfo;
-
+    DbeScreenPrivPtr pDbeScreenPriv;
+    xDbeGetVisualInfoReply rep;
+    Drawable *drawables;
+    DrawablePtr *pDrawables = NULL;
+    register int i, j, rc;
+    register int count;         /* number of visual infos in reply */
+    register int length;        /* length of reply */
+    ScreenPtr pScreen;
+    XdbeScreenVisualInfo *pScrVisInfo;
 
     REQUEST_AT_LEAST_SIZE(xDbeGetVisualInfoReq);
 
     if (stuff->n > UINT32_MAX / sizeof(DrawablePtr))
-	    return BadAlloc;
+        return BadAlloc;
     /* Make sure any specified drawables are valid. */
-    if (stuff->n != 0)
-    {
-        if (!(pDrawables = (DrawablePtr *)malloc(stuff->n *
-                                                 sizeof(DrawablePtr))))
-        {
+    if (stuff->n != 0) {
+        if (!(pDrawables = (DrawablePtr *) malloc(stuff->n *
+                                                  sizeof(DrawablePtr)))) {
             return BadAlloc;
         }
 
-        drawables = (Drawable *)&stuff[1];
+        drawables = (Drawable *) &stuff[1];
 
-        for (i = 0; i < stuff->n; i++)
-        {
-	    rc = dixLookupDrawable(pDrawables+i, drawables[i], client, 0,
-				   DixGetAttrAccess);
-	    if (rc != Success) {
+        for (i = 0; i < stuff->n; i++) {
+            rc = dixLookupDrawable(pDrawables + i, drawables[i], client, 0,
+                                   DixGetAttrAccess);
+            if (rc != Success) {
                 free(pDrawables);
                 return rc;
             }
@@ -683,8 +635,7 @@ ProcDbeGetVisualInfo(ClientPtr client)
     }
 
     count = (stuff->n == 0) ? screenInfo.numScreens : stuff->n;
-    if (!(pScrVisInfo = calloc(count, sizeof(XdbeScreenVisualInfo))))
-    {
+    if (!(pScrVisInfo = calloc(count, sizeof(XdbeScreenVisualInfo)))) {
         free(pDrawables);
 
         return BadAlloc;
@@ -692,22 +643,20 @@ ProcDbeGetVisualInfo(ClientPtr client)
 
     length = 0;
 
-    for (i = 0; i < count; i++)
-    {
+    for (i = 0; i < count; i++) {
         pScreen = (stuff->n == 0) ? screenInfo.screens[i] :
-                                    pDrawables[i]->pScreen;
+            pDrawables[i]->pScreen;
         pDbeScreenPriv = DBE_SCREEN_PRIV(pScreen);
 
-	rc = XaceHook(XACE_SCREEN_ACCESS, client, pScreen, DixGetAttrAccess);
+        rc = XaceHook(XACE_SCREEN_ACCESS, client, pScreen, DixGetAttrAccess);
         if (rc != Success)
             goto freeScrVisInfo;
 
-        if (!(*pDbeScreenPriv->GetVisualInfo)(pScreen, &pScrVisInfo[i]))
-        {
+        if (!(*pDbeScreenPriv->GetVisualInfo) (pScreen, &pScrVisInfo[i])) {
             /* We failed to alloc pScrVisInfo[i].visinfo. */
             rc = BadAlloc;
 
-            /* Free visinfos that we allocated for previous screen infos.*/
+            /* Free visinfos that we allocated for previous screen infos. */
             goto freeScrVisInfo;
         }
 
@@ -718,53 +667,48 @@ ProcDbeGetVisualInfo(ClientPtr client)
         length += pScrVisInfo[i].count * sizeof(xDbeVisInfo);
     }
 
-    rep.type           = X_Reply;
+    rep.type = X_Reply;
     rep.sequenceNumber = client->sequence;
-    rep.length         = bytes_to_int32(length);
-    rep.m              = count;
+    rep.length = bytes_to_int32(length);
+    rep.m = count;
 
-    if (client->swapped)
-    {
+    if (client->swapped) {
         swaps(&rep.sequenceNumber);
         swapl(&rep.length);
         swapl(&rep.m);
     }
 
     /* Send off reply. */
-    WriteToClient(client, sizeof(xDbeGetVisualInfoReply), (char *)&rep);
+    WriteToClient(client, sizeof(xDbeGetVisualInfoReply), (char *) &rep);
 
-    for (i = 0; i < count; i++)
-    {
-        CARD32	data32;
+    for (i = 0; i < count; i++) {
+        CARD32 data32;
 
         /* For each screen in the reply, send off the visual info */
 
         /* Send off number of visuals. */
-        data32 = (CARD32)pScrVisInfo[i].count;
+        data32 = (CARD32) pScrVisInfo[i].count;
 
-        if (client->swapped)
-        {
+        if (client->swapped) {
             swapl(&data32);
         }
 
-        WriteToClient(client, sizeof(CARD32), (char *)&data32);
+        WriteToClient(client, sizeof(CARD32), (char *) &data32);
 
         /* Now send off visual info items. */
-        for (j = 0; j < pScrVisInfo[i].count; j++)
-        {
-            xDbeVisInfo		visInfo;
+        for (j = 0; j < pScrVisInfo[i].count; j++) {
+            xDbeVisInfo visInfo;
 
             /* Copy the data in the client data structure to a protocol
              * data structure.  We will send data to the client from the
              * protocol data structure.
              */
 
-            visInfo.visualID  = (CARD32)pScrVisInfo[i].visinfo[j].visual;
-            visInfo.depth     = (CARD8) pScrVisInfo[i].visinfo[j].depth;
+            visInfo.visualID = (CARD32) pScrVisInfo[i].visinfo[j].visual;
+            visInfo.depth = (CARD8) pScrVisInfo[i].visinfo[j].depth;
             visInfo.perfLevel = (CARD8) pScrVisInfo[i].visinfo[j].perflevel;
 
-            if (client->swapped)
-            {
+            if (client->swapped) {
                 swapl(&visInfo.visualID);
 
                 /* We do not need to swap depth and perfLevel since they are
@@ -773,16 +717,16 @@ ProcDbeGetVisualInfo(ClientPtr client)
             }
 
             /* Write visualID(32), depth(8), perfLevel(8), and pad(16). */
-            WriteToClient(client, 2*sizeof(CARD32), (char *)&visInfo.visualID);
+            WriteToClient(client, 2 * sizeof(CARD32),
+                          (char *) &visInfo.visualID);
         }
     }
 
     rc = Success;
 
-  freeScrVisInfo:
+ freeScrVisInfo:
     /* Clean up memory. */
-    for (i = 0; i < count; i++)
-    {
+    for (i = 0; i < count; i++) {
         free(pScrVisInfo[i].visinfo);
     }
     free(pScrVisInfo);
@@ -791,8 +735,7 @@ ProcDbeGetVisualInfo(ClientPtr client)
 
     return rc;
 
-} /* ProcDbeGetVisualInfo() */
-
+}                               /* ProcDbeGetVisualInfo() */
 
 /******************************************************************************
  *
@@ -813,42 +756,37 @@ static int
 ProcDbeGetBackBufferAttributes(ClientPtr client)
 {
     REQUEST(xDbeGetBackBufferAttributesReq);
-    xDbeGetBackBufferAttributesReply	rep;
-    DbeWindowPrivPtr			pDbeWindowPriv;
-    int					rc;
-
+    xDbeGetBackBufferAttributesReply rep;
+    DbeWindowPrivPtr pDbeWindowPriv;
+    int rc;
 
     REQUEST_SIZE_MATCH(xDbeGetBackBufferAttributesReq);
 
-    rc = dixLookupResourceByType((pointer *)&pDbeWindowPriv, stuff->buffer,
-				 dbeWindowPrivResType, client,
-				 DixGetAttrAccess);
-    if (rc == Success)
-    {
+    rc = dixLookupResourceByType((pointer *) &pDbeWindowPriv, stuff->buffer,
+                                 dbeWindowPrivResType, client,
+                                 DixGetAttrAccess);
+    if (rc == Success) {
         rep.attributes = pDbeWindowPriv->pWindow->drawable.id;
     }
-    else
-    {
+    else {
         rep.attributes = None;
     }
-        
-    rep.type           = X_Reply;
+
+    rep.type = X_Reply;
     rep.sequenceNumber = client->sequence;
-    rep.length         = 0;
-    
-    if (client->swapped)
-    {
+    rep.length = 0;
+
+    if (client->swapped) {
         swaps(&rep.sequenceNumber);
         swapl(&rep.length);
         swapl(&rep.attributes);
     }
 
     WriteToClient(client, sizeof(xDbeGetBackBufferAttributesReply),
-                  (char *)&rep);
+                  (char *) &rep);
     return Success;
 
-} /* ProcDbeGetbackBufferAttributes() */
-
+}                               /* ProcDbeGetbackBufferAttributes() */
 
 /******************************************************************************
  *
@@ -865,39 +803,36 @@ ProcDbeDispatch(ClientPtr client)
 {
     REQUEST(xReq);
 
+    switch (stuff->data) {
+    case X_DbeGetVersion:
+        return (ProcDbeGetVersion(client));
 
-    switch (stuff->data)
-    {
-        case X_DbeGetVersion:
-            return(ProcDbeGetVersion(client));
+    case X_DbeAllocateBackBufferName:
+        return (ProcDbeAllocateBackBufferName(client));
 
-        case X_DbeAllocateBackBufferName:
-            return(ProcDbeAllocateBackBufferName(client));
+    case X_DbeDeallocateBackBufferName:
+        return (ProcDbeDeallocateBackBufferName(client));
 
-        case X_DbeDeallocateBackBufferName:
-            return(ProcDbeDeallocateBackBufferName(client));
+    case X_DbeSwapBuffers:
+        return (ProcDbeSwapBuffers(client));
 
-        case X_DbeSwapBuffers:
-            return(ProcDbeSwapBuffers(client));
+    case X_DbeBeginIdiom:
+        return (ProcDbeBeginIdiom(client));
 
-        case X_DbeBeginIdiom:
-            return(ProcDbeBeginIdiom(client));
-
-        case X_DbeEndIdiom:
-            return Success;
+    case X_DbeEndIdiom:
+        return Success;
 
-        case X_DbeGetVisualInfo:
-            return(ProcDbeGetVisualInfo(client));
+    case X_DbeGetVisualInfo:
+        return (ProcDbeGetVisualInfo(client));
 
-        case X_DbeGetBackBufferAttributes:
-            return(ProcDbeGetBackBufferAttributes(client));
+    case X_DbeGetBackBufferAttributes:
+        return (ProcDbeGetBackBufferAttributes(client));
 
-        default:
-            return BadRequest;
+    default:
+        return BadRequest;
     }
 
-} /* ProcDbeDispatch() */
-
+}                               /* ProcDbeDispatch() */
 
 /******************************************************************************
  *
@@ -921,10 +856,9 @@ SProcDbeGetVersion(ClientPtr client)
     REQUEST(xDbeGetVersionReq);
 
     swaps(&stuff->length);
-    return(ProcDbeGetVersion(client));
-
-} /* SProcDbeGetVersion() */
+    return (ProcDbeGetVersion(client));
 
+}                               /* SProcDbeGetVersion() */
 
 /******************************************************************************
  *
@@ -961,10 +895,9 @@ SProcDbeAllocateBackBufferName(ClientPtr client)
     swapl(&stuff->buffer);
     /* stuff->swapAction is a byte.  We do not need to swap this field. */
 
-    return(ProcDbeAllocateBackBufferName(client));
-
-} /* SProcDbeAllocateBackBufferName() */
+    return (ProcDbeAllocateBackBufferName(client));
 
+}                               /* SProcDbeAllocateBackBufferName() */
 
 /******************************************************************************
  *
@@ -986,17 +919,16 @@ SProcDbeAllocateBackBufferName(ClientPtr client)
 static int
 SProcDbeDeallocateBackBufferName(ClientPtr client)
 {
-    REQUEST (xDbeDeallocateBackBufferNameReq);
+    REQUEST(xDbeDeallocateBackBufferNameReq);
 
     swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xDbeDeallocateBackBufferNameReq);
 
     swapl(&stuff->buffer);
 
-    return(ProcDbeDeallocateBackBufferName(client));
-
-} /* SProcDbeDeallocateBackBufferName() */
+    return (ProcDbeDeallocateBackBufferName(client));
 
+}                               /* SProcDbeDeallocateBackBufferName() */
 
 /******************************************************************************
  *
@@ -1023,33 +955,29 @@ static int
 SProcDbeSwapBuffers(ClientPtr client)
 {
     REQUEST(xDbeSwapBuffersReq);
-    register int	i;
-    xDbeSwapInfo	*pSwapInfo;
-
+    register int i;
+    xDbeSwapInfo *pSwapInfo;
 
     swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xDbeSwapBuffersReq);
 
     swapl(&stuff->n);
 
-    if (stuff->n != 0)
-    { 
-        pSwapInfo = (xDbeSwapInfo *)stuff+1;
+    if (stuff->n != 0) {
+        pSwapInfo = (xDbeSwapInfo *) stuff + 1;
 
         /* The swap info following the fix part of this request is a window(32)
          * followed by a 1 byte swap action and then 3 pad bytes.  We only need
          * to swap the window information.
          */
-        for (i = 0; i < stuff->n; i++)
-        {
+        for (i = 0; i < stuff->n; i++) {
             swapl(&pSwapInfo->window);
         }
     }
 
-    return(ProcDbeSwapBuffers(client));
-
-} /* SProcDbeSwapBuffers() */
+    return (ProcDbeSwapBuffers(client));
 
+}                               /* SProcDbeSwapBuffers() */
 
 /******************************************************************************
  *
@@ -1073,10 +1001,9 @@ SProcDbeBeginIdiom(ClientPtr client)
     REQUEST(xDbeBeginIdiomReq);
 
     swaps(&stuff->length);
-    return(ProcDbeBeginIdiom(client));
-
-} /* SProcDbeBeginIdiom() */
+    return (ProcDbeBeginIdiom(client));
 
+}                               /* SProcDbeBeginIdiom() */
 
 /******************************************************************************
  *
@@ -1106,10 +1033,9 @@ SProcDbeGetVisualInfo(ClientPtr client)
     swapl(&stuff->n);
     SwapRestL(stuff);
 
-    return(ProcDbeGetVisualInfo(client));
-
-} /* SProcDbeGetVisualInfo() */
+    return (ProcDbeGetVisualInfo(client));
 
+}                               /* SProcDbeGetVisualInfo() */
 
 /******************************************************************************
  *
@@ -1130,17 +1056,16 @@ SProcDbeGetVisualInfo(ClientPtr client)
 static int
 SProcDbeGetBackBufferAttributes(ClientPtr client)
 {
-    REQUEST (xDbeGetBackBufferAttributesReq);
+    REQUEST(xDbeGetBackBufferAttributesReq);
 
     swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xDbeGetBackBufferAttributesReq);
 
     swapl(&stuff->buffer);
 
-    return(ProcDbeGetBackBufferAttributes(client));
-
-} /* SProcDbeGetBackBufferAttributes() */
+    return (ProcDbeGetBackBufferAttributes(client));
 
+}                               /* SProcDbeGetBackBufferAttributes() */
 
 /******************************************************************************
  *
@@ -1157,39 +1082,36 @@ SProcDbeDispatch(ClientPtr client)
 {
     REQUEST(xReq);
 
+    switch (stuff->data) {
+    case X_DbeGetVersion:
+        return (SProcDbeGetVersion(client));
 
-    switch (stuff->data)
-    {
-        case X_DbeGetVersion:
-            return(SProcDbeGetVersion(client));
+    case X_DbeAllocateBackBufferName:
+        return (SProcDbeAllocateBackBufferName(client));
 
-        case X_DbeAllocateBackBufferName:
-            return(SProcDbeAllocateBackBufferName(client));
+    case X_DbeDeallocateBackBufferName:
+        return (SProcDbeDeallocateBackBufferName(client));
 
-        case X_DbeDeallocateBackBufferName:
-            return(SProcDbeDeallocateBackBufferName(client));
+    case X_DbeSwapBuffers:
+        return (SProcDbeSwapBuffers(client));
 
-        case X_DbeSwapBuffers:
-            return(SProcDbeSwapBuffers(client));
+    case X_DbeBeginIdiom:
+        return (SProcDbeBeginIdiom(client));
 
-        case X_DbeBeginIdiom:
-            return(SProcDbeBeginIdiom(client));
-
-        case X_DbeEndIdiom:
-            return Success;
+    case X_DbeEndIdiom:
+        return Success;
 
-        case X_DbeGetVisualInfo:
-            return(SProcDbeGetVisualInfo(client));
+    case X_DbeGetVisualInfo:
+        return (SProcDbeGetVisualInfo(client));
 
-        case X_DbeGetBackBufferAttributes:
-            return(SProcDbeGetBackBufferAttributes(client));
+    case X_DbeGetBackBufferAttributes:
+        return (SProcDbeGetBackBufferAttributes(client));
 
-        default:
-            return BadRequest;
+    default:
+        return BadRequest;
     }
 
-} /* SProcDbeDispatch() */
-
+}                               /* SProcDbeDispatch() */
 
 /******************************************************************************
  *
@@ -1209,12 +1131,11 @@ SProcDbeDispatch(ClientPtr client)
 static Bool
 DbeSetupBackgroundPainter(WindowPtr pWin, GCPtr pGC)
 {
-    ChangeGCVal	gcvalues[4];
-    int		ts_x_origin, ts_y_origin;
-    PixUnion	background;
-    int		backgroundState;
-    Mask	gcmask;
-
+    ChangeGCVal gcvalues[4];
+    int ts_x_origin, ts_y_origin;
+    PixUnion background;
+    int backgroundState;
+    Mask gcmask;
 
     /* First take care of any ParentRelative stuff by altering the
      * tile/stipple origin to match the coordinates of the upper-left
@@ -1222,40 +1143,37 @@ DbeSetupBackgroundPainter(WindowPtr pWin, GCPtr pGC)
      * This coordinate is, of course, negative.
      */
     ts_x_origin = ts_y_origin = 0;
-    while (pWin->backgroundState == ParentRelative)
-    {
+    while (pWin->backgroundState == ParentRelative) {
         ts_x_origin -= pWin->origin.x;
         ts_y_origin -= pWin->origin.y;
 
         pWin = pWin->parent;
     }
     backgroundState = pWin->backgroundState;
-    background      = pWin->background;
-
-    switch (backgroundState)
-    {
-        case BackgroundPixel:
-            gcvalues[0].val = background.pixel;
-            gcvalues[1].val = FillSolid;
-            gcmask = GCForeground|GCFillStyle;
-            break;
-
-        case BackgroundPixmap:
-            gcvalues[0].val = FillTiled;
-            gcvalues[1].ptr = background.pixmap;
-            gcvalues[2].val = ts_x_origin;
-            gcvalues[3].val = ts_y_origin;
-            gcmask = GCFillStyle|GCTile|GCTileStipXOrigin|GCTileStipYOrigin;
-            break;
-
-        default:
-            /* pWin->backgroundState == None */
-            return FALSE;
+    background = pWin->background;
+
+    switch (backgroundState) {
+    case BackgroundPixel:
+        gcvalues[0].val = background.pixel;
+        gcvalues[1].val = FillSolid;
+        gcmask = GCForeground | GCFillStyle;
+        break;
+
+    case BackgroundPixmap:
+        gcvalues[0].val = FillTiled;
+        gcvalues[1].ptr = background.pixmap;
+        gcvalues[2].val = ts_x_origin;
+        gcvalues[3].val = ts_y_origin;
+        gcmask = GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin;
+        break;
+
+    default:
+        /* pWin->backgroundState == None */
+        return FALSE;
     }
 
     return ChangeGC(NullClient, pGC, gcmask, gcvalues) == 0;
-} /* DbeSetupBackgroundPainter() */
-
+}                               /* DbeSetupBackgroundPainter() */
 
 /******************************************************************************
  *
@@ -1278,8 +1196,7 @@ DbeDrawableDelete(pointer pDrawable, XID id)
 {
     return Success;
 
-} /* DbeDrawableDelete() */
-
+}                               /* DbeDrawableDelete() */
 
 /******************************************************************************
  *
@@ -1295,10 +1212,9 @@ DbeDrawableDelete(pointer pDrawable, XID id)
 static int
 DbeWindowPrivDelete(pointer pDbeWinPriv, XID id)
 {
-    DbeScreenPrivPtr	pDbeScreenPriv;
-    DbeWindowPrivPtr	pDbeWindowPriv = (DbeWindowPrivPtr)pDbeWinPriv;
-    int			i;
-
+    DbeScreenPrivPtr pDbeScreenPriv;
+    DbeWindowPrivPtr pDbeWindowPriv = (DbeWindowPrivPtr) pDbeWinPriv;
+    int i;
 
     /*
      **************************************************************************
@@ -1308,27 +1224,23 @@ DbeWindowPrivDelete(pointer pDbeWinPriv, XID id)
 
     /* Find the ID in the ID array. */
     i = 0;
-    while ((i < pDbeWindowPriv->nBufferIDs) && (pDbeWindowPriv->IDs[i] != id))
-    {
+    while ((i < pDbeWindowPriv->nBufferIDs) && (pDbeWindowPriv->IDs[i] != id)) {
         i++;
     }
 
-    if (i == pDbeWindowPriv->nBufferIDs)
-    {
+    if (i == pDbeWindowPriv->nBufferIDs) {
         /* We did not find the ID in the array.  We should never get here. */
         return BadValue;
     }
 
     /* Remove the ID from the array. */
 
-    if (i < (pDbeWindowPriv->nBufferIDs - 1))
-    {
+    if (i < (pDbeWindowPriv->nBufferIDs - 1)) {
         /* Compress the buffer ID array, overwriting the ID in the process. */
-        memmove(&pDbeWindowPriv->IDs[i], &pDbeWindowPriv->IDs[i+1],
-            (pDbeWindowPriv->nBufferIDs - i - 1) * sizeof(XID));
+        memmove(&pDbeWindowPriv->IDs[i], &pDbeWindowPriv->IDs[i + 1],
+                (pDbeWindowPriv->nBufferIDs - i - 1) * sizeof(XID));
     }
-    else
-    {
+    else {
         /* We are removing the last ID in the array, in which case, the
          * assignement below is all that we need to do.
          */
@@ -1341,9 +1253,8 @@ DbeWindowPrivDelete(pointer pDbeWinPriv, XID id)
      * buffer IDs will fit in the static array.
      */
 
-    if ((pDbeWindowPriv->maxAvailableIDs >  DBE_INIT_MAX_IDS) &&
-        (pDbeWindowPriv->nBufferIDs      == DBE_INIT_MAX_IDS))
-    {
+    if ((pDbeWindowPriv->maxAvailableIDs > DBE_INIT_MAX_IDS) &&
+        (pDbeWindowPriv->nBufferIDs == DBE_INIT_MAX_IDS)) {
         /* Copy the IDs back into the static array. */
         memcpy(pDbeWindowPriv->initIDs, pDbeWindowPriv->IDs,
                DBE_INIT_MAX_IDS * sizeof(XID));
@@ -1354,17 +1265,15 @@ DbeWindowPrivDelete(pointer pDbeWinPriv, XID id)
         pDbeWindowPriv->maxAvailableIDs = DBE_INIT_MAX_IDS;
     }
 
-
     /*
      **************************************************************************
      ** Perform DDX level tasks.
      **************************************************************************
      */
 
-    pDbeScreenPriv = DBE_SCREEN_PRIV_FROM_WINDOW_PRIV(
-                         (DbeWindowPrivPtr)pDbeWindowPriv);
-    (*pDbeScreenPriv->WinPrivDelete)((DbeWindowPrivPtr)pDbeWindowPriv, id);
-
+    pDbeScreenPriv = DBE_SCREEN_PRIV_FROM_WINDOW_PRIV((DbeWindowPrivPtr)
+                                                      pDbeWindowPriv);
+    (*pDbeScreenPriv->WinPrivDelete) ((DbeWindowPrivPtr) pDbeWindowPriv, id);
 
     /*
      **************************************************************************
@@ -1373,20 +1282,18 @@ DbeWindowPrivDelete(pointer pDbeWinPriv, XID id)
      **************************************************************************
      */
 
-    if (pDbeWindowPriv->nBufferIDs == 0)
-    {
+    if (pDbeWindowPriv->nBufferIDs == 0) {
         /* Reset the DBE window priv pointer. */
-	dixSetPrivate(&pDbeWindowPriv->pWindow->devPrivates, dbeWindowPrivKey,
-		      NULL);
+        dixSetPrivate(&pDbeWindowPriv->pWindow->devPrivates, dbeWindowPrivKey,
+                      NULL);
 
         /* We are done with the window priv. */
-	dixFreeObjectWithPrivates(pDbeWindowPriv, PRIVATE_DBE_WINDOW);
+        dixFreeObjectWithPrivates(pDbeWindowPriv, PRIVATE_DBE_WINDOW);
     }
 
     return Success;
 
-} /* DbeWindowPrivDelete() */
-
+}                               /* DbeWindowPrivDelete() */
 
 /******************************************************************************
  *
@@ -1400,30 +1307,27 @@ DbeWindowPrivDelete(pointer pDbeWinPriv, XID id)
  *
  *****************************************************************************/
 static void
-DbeResetProc(ExtensionEntry *extEntry)
+DbeResetProc(ExtensionEntry * extEntry)
 {
-    int			i;
-    ScreenPtr		pScreen;
-    DbeScreenPrivPtr	pDbeScreenPriv;
-    
-    for (i = 0; i < screenInfo.numScreens; i++)
-    {
-	pScreen = screenInfo.screens[i];
-	pDbeScreenPriv = DBE_SCREEN_PRIV(pScreen);
-
-	if (pDbeScreenPriv)
-	{
-            /* Unwrap DestroyWindow, which was wrapped in DbeExtensionInit().*/
+    int i;
+    ScreenPtr pScreen;
+    DbeScreenPrivPtr pDbeScreenPriv;
+
+    for (i = 0; i < screenInfo.numScreens; i++) {
+        pScreen = screenInfo.screens[i];
+        pDbeScreenPriv = DBE_SCREEN_PRIV(pScreen);
+
+        if (pDbeScreenPriv) {
+            /* Unwrap DestroyWindow, which was wrapped in DbeExtensionInit(). */
             pScreen->DestroyWindow = pDbeScreenPriv->DestroyWindow;
 
-	    if (pDbeScreenPriv->ResetProc)
-		(*pDbeScreenPriv->ResetProc)(pScreen);
+            if (pDbeScreenPriv->ResetProc)
+                (*pDbeScreenPriv->ResetProc) (pScreen);
 
-	    free(pDbeScreenPriv);
-	}
+            free(pDbeScreenPriv);
+        }
     }
-} /* DbeResetProc() */
-
+}                               /* DbeResetProc() */
 
 /******************************************************************************
  *
@@ -1440,11 +1344,10 @@ DbeResetProc(ExtensionEntry *extEntry)
 static Bool
 DbeDestroyWindow(WindowPtr pWin)
 {
-    DbeScreenPrivPtr	pDbeScreenPriv;
-    DbeWindowPrivPtr	pDbeWindowPriv;
-    ScreenPtr		pScreen;
-    Bool		ret;
-
+    DbeScreenPrivPtr pDbeScreenPriv;
+    DbeWindowPrivPtr pDbeWindowPriv;
+    ScreenPtr pScreen;
+    Bool ret;
 
     /*
      **************************************************************************
@@ -1452,8 +1355,8 @@ DbeDestroyWindow(WindowPtr pWin)
      **************************************************************************
      */
 
-    pScreen                = pWin->drawable.pScreen;
-    pDbeScreenPriv         = DBE_SCREEN_PRIV(pScreen);
+    pScreen = pWin->drawable.pScreen;
+    pDbeScreenPriv = DBE_SCREEN_PRIV(pScreen);
     pScreen->DestroyWindow = pDbeScreenPriv->DestroyWindow;
 
     /*
@@ -1465,10 +1368,8 @@ DbeDestroyWindow(WindowPtr pWin)
      **************************************************************************
      */
 
-    if ((pDbeWindowPriv = DBE_WINDOW_PRIV(pWin)))
-    {
-        while (pDbeWindowPriv)
-        {
+    if ((pDbeWindowPriv = DBE_WINDOW_PRIV(pWin))) {
+        while (pDbeWindowPriv) {
             /* *DbeWinPrivDelete() will free the window private and set it to
              * NULL if there are no more buffer IDs associated with this
              * window.
@@ -1484,7 +1385,7 @@ DbeDestroyWindow(WindowPtr pWin)
      **************************************************************************
      */
 
-    ret = (*pScreen->DestroyWindow)(pWin);
+    ret = (*pScreen->DestroyWindow) (pWin);
 
     /*
      **************************************************************************
@@ -1506,8 +1407,7 @@ DbeDestroyWindow(WindowPtr pWin)
 
     return ret;
 
-} /* DbeDestroyWindow() */
-
+}                               /* DbeDestroyWindow() */
 
 /******************************************************************************
  *
@@ -1522,67 +1422,65 @@ DbeDestroyWindow(WindowPtr pWin)
 void
 DbeExtensionInit(void)
 {
-    ExtensionEntry	*extEntry;
-    register int	i, j;
-    ScreenPtr		pScreen = NULL;
-    DbeScreenPrivPtr	pDbeScreenPriv;
-    int			nStubbedScreens = 0;
-    Bool		ddxInitSuccess;
+    ExtensionEntry *extEntry;
+    register int i, j;
+    ScreenPtr pScreen = NULL;
+    DbeScreenPrivPtr pDbeScreenPriv;
+    int nStubbedScreens = 0;
+    Bool ddxInitSuccess;
 
 #ifdef PANORAMIX
-    if(!noPanoramiXExtension) return;
+    if (!noPanoramiXExtension)
+        return;
 #endif
 
     /* Create the resource types. */
     dbeDrawableResType =
         CreateNewResourceType(DbeDrawableDelete, "dbeDrawable");
     if (!dbeDrawableResType)
-	return;
+        return;
     dbeDrawableResType |= RC_DRAWABLE;
 
     dbeWindowPrivResType =
         CreateNewResourceType(DbeWindowPrivDelete, "dbeWindow");
     if (!dbeWindowPrivResType)
-	return;
+        return;
 
     if (!dixRegisterPrivateKey(&dbeScreenPrivKeyRec, PRIVATE_SCREEN, 0))
-	return;
+        return;
 
     if (!dixRegisterPrivateKey(&dbeWindowPrivKeyRec, PRIVATE_WINDOW, 0))
-	return;
+        return;
 
-    for (i = 0; i < screenInfo.numScreens; i++)
-    {
+    for (i = 0; i < screenInfo.numScreens; i++) {
         /* For each screen, set up DBE screen privates and init DIX and DDX
          * interface.
          */
 
-	pScreen = screenInfo.screens[i];
+        pScreen = screenInfo.screens[i];
 
-	if (!(pDbeScreenPriv = malloc (sizeof (DbeScreenPrivRec))))
-	{
+        if (!(pDbeScreenPriv = malloc(sizeof(DbeScreenPrivRec)))) {
             /* If we can not alloc a window or screen private,
              * then free any privates that we already alloc'ed and return
              */
 
-	    for (j = 0; j < i; j++)
-	    {
-		free(dixLookupPrivate(&screenInfo.screens[j]->devPrivates,
-				       dbeScreenPrivKey));
-		dixSetPrivate(&screenInfo.screens[j]->devPrivates,
-			      dbeScreenPrivKey, NULL);
-	    }
-	    return;
-	}
+            for (j = 0; j < i; j++) {
+                free(dixLookupPrivate(&screenInfo.screens[j]->devPrivates,
+                                      dbeScreenPrivKey));
+                dixSetPrivate(&screenInfo.screens[j]->devPrivates,
+                              dbeScreenPrivKey, NULL);
+            }
+            return;
+        }
 
-	dixSetPrivate(&pScreen->devPrivates, dbeScreenPrivKey, pDbeScreenPriv);
+        dixSetPrivate(&pScreen->devPrivates, dbeScreenPrivKey, pDbeScreenPriv);
 
         {
             /* We don't have DDX support for DBE anymore */
 
 #ifndef DISABLE_MI_DBE_BY_DEFAULT
             /* Setup DIX. */
-            pDbeScreenPriv->SetupBackgroundPainter = DbeSetupBackgroundPainter; 
+            pDbeScreenPriv->SetupBackgroundPainter = DbeSetupBackgroundPainter;
 
             /* Setup DDX. */
             ddxInitSuccess = miDbeInit(pScreen, pDbeScreenPriv);
@@ -1592,17 +1490,15 @@ DbeExtensionInit(void)
              */
             pDbeScreenPriv = DBE_SCREEN_PRIV(pScreen);
 
-            if (ddxInitSuccess)
-            {
+            if (ddxInitSuccess) {
                 /* Wrap DestroyWindow.  The DDX initialization function
                  * already wrapped PositionWindow for us.
                  */
 
                 pDbeScreenPriv->DestroyWindow = pScreen->DestroyWindow;
-                pScreen->DestroyWindow        = DbeDestroyWindow;
+                pScreen->DestroyWindow = DbeDestroyWindow;
             }
-            else
-            {
+            else {
                 /* DDX initialization failed.  Stub the screen. */
                 DbeStubScreen(pDbeScreenPriv, &nStubbedScreens);
             }
@@ -1612,31 +1508,27 @@ DbeExtensionInit(void)
 
         }
 
-    } /* for (i = 0; i < screenInfo.numScreens; i++) */
-
+    }                           /* for (i = 0; i < screenInfo.numScreens; i++) */
 
-    if (nStubbedScreens == screenInfo.numScreens)
-    {
-	/* All screens stubbed.  Clean up and return. */
+    if (nStubbedScreens == screenInfo.numScreens) {
+        /* All screens stubbed.  Clean up and return. */
 
-        for (i = 0; i < screenInfo.numScreens; i++)
-        {
-		free(dixLookupPrivate(&screenInfo.screens[i]->devPrivates,
-				       dbeScreenPrivKey));
-		dixSetPrivate(&pScreen->devPrivates, dbeScreenPrivKey, NULL);
+        for (i = 0; i < screenInfo.numScreens; i++) {
+            free(dixLookupPrivate(&screenInfo.screens[i]->devPrivates,
+                                  dbeScreenPrivKey));
+            dixSetPrivate(&pScreen->devPrivates, dbeScreenPrivKey, NULL);
         }
         return;
     }
 
-
     /* Now add the extension. */
-    extEntry = AddExtension(DBE_PROTOCOL_NAME, DbeNumberEvents, 
+    extEntry = AddExtension(DBE_PROTOCOL_NAME, DbeNumberEvents,
                             DbeNumberErrors, ProcDbeDispatch, SProcDbeDispatch,
                             DbeResetProc, StandardMinorOpcode);
 
     dbeErrorBase = extEntry->errorBase;
-    SetResourceTypeErrorValue(dbeWindowPrivResType, dbeErrorBase + DbeBadBuffer);
+    SetResourceTypeErrorValue(dbeWindowPrivResType,
+                              dbeErrorBase + DbeBadBuffer);
     SetResourceTypeErrorValue(dbeDrawableResType, dbeErrorBase + DbeBadBuffer);
 
-} /* DbeExtensionInit() */
-
+}                               /* DbeExtensionInit() */
diff --git a/xorg-server/dbe/dbestruct.h b/xorg-server/dbe/dbestruct.h
index 089719ba7..9ea9eb695 100644
--- a/xorg-server/dbe/dbestruct.h
+++ b/xorg-server/dbe/dbestruct.h
@@ -1,214 +1,197 @@
-/******************************************************************************

- * 

- * Copyright (c) 1994, 1995  Hewlett-Packard Company

- *

- * Permission is hereby granted, free of charge, to any person obtaining

- * a copy of this software and associated documentation files (the

- * "Software"), to deal in the Software without restriction, including

- * without limitation the rights to use, copy, modify, merge, publish,

- * distribute, sublicense, and/or sell copies of the Software, and to

- * permit persons to whom the Software is furnished to do so, subject to

- * the following conditions:

- * 

- * The above copyright notice and this permission notice shall be included

- * in all copies or substantial portions of the Software.

- * 

- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

- * IN NO EVENT SHALL HEWLETT-PACKARD COMPANY BE LIABLE FOR ANY CLAIM,

- * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR

- * THE USE OR OTHER DEALINGS IN THE SOFTWARE.

- * 

- * Except as contained in this notice, the name of the Hewlett-Packard

- * Company shall not be used in advertising or otherwise to promote the

- * sale, use or other dealings in this Software without prior written

- * authorization from the Hewlett-Packard Company.

- * 

- *     Header file for DIX-related DBE

- *

- *****************************************************************************/

-

-#ifndef DBE_STRUCT_H

-#define DBE_STRUCT_H

-

-

-/* INCLUDES */

-

-#define NEED_DBE_PROTOCOL

-#include <X11/extensions/dbeproto.h>

-#include "windowstr.h"

-#include "privates.h"

-

-typedef struct

-{

-    VisualID    visual;    /* one visual ID that supports double-buffering */

-    int         depth;     /* depth of visual in bits                      */

-    int         perflevel; /* performance level of visual                  */

-}

-XdbeVisualInfo;

-

-typedef struct

-{

-    int                 count;          /* number of items in visual_depth   */

-    XdbeVisualInfo      *visinfo;       /* list of visuals & depths for scrn */

-}

-XdbeScreenVisualInfo;

-

-/* DEFINES */

-

-#define DBE_SCREEN_PRIV(pScreen) ((DbeScreenPrivPtr) \

-    dixLookupPrivate(&(pScreen)->devPrivates, dbeScreenPrivKey))

-

-#define DBE_SCREEN_PRIV_FROM_DRAWABLE(pDrawable) \

-    DBE_SCREEN_PRIV((pDrawable)->pScreen)

-

-#define DBE_SCREEN_PRIV_FROM_WINDOW_PRIV(pDbeWindowPriv) \

-    DBE_SCREEN_PRIV((pDbeWindowPriv)->pWindow->drawable.pScreen)

-

-#define DBE_SCREEN_PRIV_FROM_WINDOW(pWindow) \

-    DBE_SCREEN_PRIV((pWindow)->drawable.pScreen)

-

-#define DBE_SCREEN_PRIV_FROM_PIXMAP(pPixmap) \

-    DBE_SCREEN_PRIV((pPixmap)->drawable.pScreen)

-

-#define DBE_SCREEN_PRIV_FROM_GC(pGC)\

-    DBE_SCREEN_PRIV((pGC)->pScreen)

-

-#define DBE_WINDOW_PRIV(pWin) ((DbeWindowPrivPtr) \

-    dixLookupPrivate(&(pWin)->devPrivates, dbeWindowPrivKey))

-

-/* Initial size of the buffer ID array in the window priv. */

-#define DBE_INIT_MAX_IDS	2

-

-/* Reallocation increment for the buffer ID array. */

-#define DBE_INCR_MAX_IDS	4

-

-/* Marker for free elements in the buffer ID array. */

-#define DBE_FREE_ID_ELEMENT	0

-

-extern _X_EXPORT void DbeExtensionInit (void);

-

-/* TYPEDEFS */

-

-/* Record used to pass swap information between DIX and DDX swapping

- * procedures.

- */

-typedef struct _DbeSwapInfoRec

-{

-    WindowPtr		pWindow;

-    unsigned char	swapAction;

-

-} DbeSwapInfoRec, *DbeSwapInfoPtr;

-

-/*

- ******************************************************************************

- ** Per-window data

- ******************************************************************************

- */

-

-typedef struct _DbeWindowPrivRec

-{

-    /* A pointer to the window with which the DBE window private (buffer) is

-     * associated.

-     */

-    WindowPtr		pWindow;

-

-    /* Last known swap action for this buffer.  Legal values for this field

-     * are XdbeUndefined, XdbeBackground, XdbeUntouched, and XdbeCopied.

-     */

-    unsigned char	swapAction;

-

-    /* Last known buffer size.

-     */

-    unsigned short	width, height;

-

-    /* Coordinates used for static gravity when the window is positioned.

-     */

-    short		x, y;

-

-    /* Number of XIDs associated with this buffer.

-     */

-    int			nBufferIDs;

-

-    /* Capacity of the current buffer ID array, IDs. */

-    int			maxAvailableIDs;

-

-    /* Pointer to the array of buffer IDs.  This initially points to initIDs.

-     * When the static limit of the initIDs array is reached, the array is

-     * reallocated and this pointer is set to the new array instead of initIDs.

-     */

-    XID			*IDs;

-

-    /* Initial array of buffer IDs.  We are defining the XID array within the

-     * window priv to optimize for data locality.  In most cases, only one

-     * buffer will be associated with a window.  Having the array declared

-     * here can prevent us from accessing the data in another memory page,

-     * possibly resulting in a page swap and loss of performance.  Initially we

-     * will use this array to store buffer IDs.  For situations where we have

-     * more IDs than can fit in this static array, we will allocate a larger

-     * array to use, possibly suffering a performance loss. 

-     */

-    XID			initIDs[DBE_INIT_MAX_IDS];

-

-    /* Device-specific private information.

-     */

-    PrivateRec		*devPrivates;

-

-} DbeWindowPrivRec, *DbeWindowPrivPtr;

-

-

-/*

- ******************************************************************************

- ** Per-screen data

- ******************************************************************************

- */

-

-typedef struct _DbeScreenPrivRec

-{

-    /* Wrapped functions

-     * It is the responsibilty of the DDX layer to wrap PositionWindow().

-     * DbeExtensionInit wraps DestroyWindow().

-     */

-    PositionWindowProcPtr PositionWindow;

-    DestroyWindowProcPtr  DestroyWindow;

-

-    /* Per-screen DIX routines */

-    Bool	(*SetupBackgroundPainter)(

-		WindowPtr /*pWin*/,

-		GCPtr /*pGC*/

-);

-

-    /* Per-screen DDX routines */

-    Bool	(*GetVisualInfo)(

-		ScreenPtr /*pScreen*/,

-		XdbeScreenVisualInfo * /*pVisInfo*/

-);

-    int		(*AllocBackBufferName)(

-		WindowPtr /*pWin*/,

-		XID /*bufId*/,

-		int /*swapAction*/

-);

-    int		(*SwapBuffers)(

-		ClientPtr /*client*/,

-		int * /*pNumWindows*/,

-		DbeSwapInfoPtr /*swapInfo*/

-);

-    void	(*BeginIdiom)(

-		ClientPtr /*client*/

-);

-    void	(*EndIdiom)(

-		ClientPtr /*client*/

-);

-    void	(*WinPrivDelete)(

-		DbeWindowPrivPtr /*pDbeWindowPriv*/,

-		XID /*bufId*/

-);

-    void	(*ResetProc)(

-		ScreenPtr /*pScreen*/

-);

-

-} DbeScreenPrivRec, *DbeScreenPrivPtr;

-

-#endif /* DBE_STRUCT_H */

+/******************************************************************************
+ * 
+ * Copyright (c) 1994, 1995  Hewlett-Packard Company
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL HEWLETT-PACKARD COMPANY BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ * Except as contained in this notice, the name of the Hewlett-Packard
+ * Company shall not be used in advertising or otherwise to promote the
+ * sale, use or other dealings in this Software without prior written
+ * authorization from the Hewlett-Packard Company.
+ * 
+ *     Header file for DIX-related DBE
+ *
+ *****************************************************************************/
+
+#ifndef DBE_STRUCT_H
+#define DBE_STRUCT_H
+
+/* INCLUDES */
+
+#define NEED_DBE_PROTOCOL
+#include <X11/extensions/dbeproto.h>
+#include "windowstr.h"
+#include "privates.h"
+
+typedef struct {
+    VisualID visual;            /* one visual ID that supports double-buffering */
+    int depth;                  /* depth of visual in bits                      */
+    int perflevel;              /* performance level of visual                  */
+} XdbeVisualInfo;
+
+typedef struct {
+    int count;                  /* number of items in visual_depth   */
+    XdbeVisualInfo *visinfo;    /* list of visuals & depths for scrn */
+} XdbeScreenVisualInfo;
+
+/* DEFINES */
+
+#define DBE_SCREEN_PRIV(pScreen) ((DbeScreenPrivPtr) \
+    dixLookupPrivate(&(pScreen)->devPrivates, dbeScreenPrivKey))
+
+#define DBE_SCREEN_PRIV_FROM_DRAWABLE(pDrawable) \
+    DBE_SCREEN_PRIV((pDrawable)->pScreen)
+
+#define DBE_SCREEN_PRIV_FROM_WINDOW_PRIV(pDbeWindowPriv) \
+    DBE_SCREEN_PRIV((pDbeWindowPriv)->pWindow->drawable.pScreen)
+
+#define DBE_SCREEN_PRIV_FROM_WINDOW(pWindow) \
+    DBE_SCREEN_PRIV((pWindow)->drawable.pScreen)
+
+#define DBE_SCREEN_PRIV_FROM_PIXMAP(pPixmap) \
+    DBE_SCREEN_PRIV((pPixmap)->drawable.pScreen)
+
+#define DBE_SCREEN_PRIV_FROM_GC(pGC)\
+    DBE_SCREEN_PRIV((pGC)->pScreen)
+
+#define DBE_WINDOW_PRIV(pWin) ((DbeWindowPrivPtr) \
+    dixLookupPrivate(&(pWin)->devPrivates, dbeWindowPrivKey))
+
+/* Initial size of the buffer ID array in the window priv. */
+#define DBE_INIT_MAX_IDS	2
+
+/* Reallocation increment for the buffer ID array. */
+#define DBE_INCR_MAX_IDS	4
+
+/* Marker for free elements in the buffer ID array. */
+#define DBE_FREE_ID_ELEMENT	0
+
+extern _X_EXPORT void DbeExtensionInit(void);
+
+/* TYPEDEFS */
+
+/* Record used to pass swap information between DIX and DDX swapping
+ * procedures.
+ */
+typedef struct _DbeSwapInfoRec {
+    WindowPtr pWindow;
+    unsigned char swapAction;
+
+} DbeSwapInfoRec, *DbeSwapInfoPtr;
+
+/*
+ ******************************************************************************
+ ** Per-window data
+ ******************************************************************************
+ */
+
+typedef struct _DbeWindowPrivRec {
+    /* A pointer to the window with which the DBE window private (buffer) is
+     * associated.
+     */
+    WindowPtr pWindow;
+
+    /* Last known swap action for this buffer.  Legal values for this field
+     * are XdbeUndefined, XdbeBackground, XdbeUntouched, and XdbeCopied.
+     */
+    unsigned char swapAction;
+
+    /* Last known buffer size.
+     */
+    unsigned short width, height;
+
+    /* Coordinates used for static gravity when the window is positioned.
+     */
+    short x, y;
+
+    /* Number of XIDs associated with this buffer.
+     */
+    int nBufferIDs;
+
+    /* Capacity of the current buffer ID array, IDs. */
+    int maxAvailableIDs;
+
+    /* Pointer to the array of buffer IDs.  This initially points to initIDs.
+     * When the static limit of the initIDs array is reached, the array is
+     * reallocated and this pointer is set to the new array instead of initIDs.
+     */
+    XID *IDs;
+
+    /* Initial array of buffer IDs.  We are defining the XID array within the
+     * window priv to optimize for data locality.  In most cases, only one
+     * buffer will be associated with a window.  Having the array declared
+     * here can prevent us from accessing the data in another memory page,
+     * possibly resulting in a page swap and loss of performance.  Initially we
+     * will use this array to store buffer IDs.  For situations where we have
+     * more IDs than can fit in this static array, we will allocate a larger
+     * array to use, possibly suffering a performance loss. 
+     */
+    XID initIDs[DBE_INIT_MAX_IDS];
+
+    /* Device-specific private information.
+     */
+    PrivateRec *devPrivates;
+
+} DbeWindowPrivRec, *DbeWindowPrivPtr;
+
+/*
+ ******************************************************************************
+ ** Per-screen data
+ ******************************************************************************
+ */
+
+typedef struct _DbeScreenPrivRec {
+    /* Wrapped functions
+     * It is the responsibilty of the DDX layer to wrap PositionWindow().
+     * DbeExtensionInit wraps DestroyWindow().
+     */
+    PositionWindowProcPtr PositionWindow;
+    DestroyWindowProcPtr DestroyWindow;
+
+    /* Per-screen DIX routines */
+    Bool (*SetupBackgroundPainter) (WindowPtr /*pWin */ ,
+                                    GCPtr       /*pGC */
+        );
+
+    /* Per-screen DDX routines */
+    Bool (*GetVisualInfo) (ScreenPtr /*pScreen */ ,
+                           XdbeScreenVisualInfo *       /*pVisInfo */
+        );
+    int (*AllocBackBufferName) (WindowPtr /*pWin */ ,
+                                XID /*bufId */ ,
+                                int     /*swapAction */
+        );
+    int (*SwapBuffers) (ClientPtr /*client */ ,
+                        int * /*pNumWindows */ ,
+                        DbeSwapInfoPtr  /*swapInfo */
+        );
+    void (*BeginIdiom) (ClientPtr       /*client */
+        );
+    void (*EndIdiom) (ClientPtr /*client */
+        );
+    void (*WinPrivDelete) (DbeWindowPrivPtr /*pDbeWindowPriv */ ,
+                           XID  /*bufId */
+        );
+    void (*ResetProc) (ScreenPtr        /*pScreen */
+        );
+
+} DbeScreenPrivRec, *DbeScreenPrivPtr;
+
+#endif                          /* DBE_STRUCT_H */
diff --git a/xorg-server/dbe/midbe.c b/xorg-server/dbe/midbe.c
index 76d2e00aa..d810d992e 100644
--- a/xorg-server/dbe/midbe.c
+++ b/xorg-server/dbe/midbe.c
@@ -1,797 +1,739 @@
-/******************************************************************************

- * 

- * Copyright (c) 1994, 1995  Hewlett-Packard Company

- *

- * Permission is hereby granted, free of charge, to any person obtaining

- * a copy of this software and associated documentation files (the

- * "Software"), to deal in the Software without restriction, including

- * without limitation the rights to use, copy, modify, merge, publish,

- * distribute, sublicense, and/or sell copies of the Software, and to

- * permit persons to whom the Software is furnished to do so, subject to

- * the following conditions:

- * 

- * The above copyright notice and this permission notice shall be included

- * in all copies or substantial portions of the Software.

- * 

- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

- * IN NO EVENT SHALL HEWLETT-PACKARD COMPANY BE LIABLE FOR ANY CLAIM,

- * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR

- * THE USE OR OTHER DEALINGS IN THE SOFTWARE.

- * 

- * Except as contained in this notice, the name of the Hewlett-Packard

- * Company shall not be used in advertising or otherwise to promote the

- * sale, use or other dealings in this Software without prior written

- * authorization from the Hewlett-Packard Company.

- * 

- *     Machine-independent DBE code

- *

- *****************************************************************************/

-

-

-/* INCLUDES */

-

-#ifdef HAVE_DIX_CONFIG_H

-#include <dix-config.h>

-#endif

-

-#include <X11/X.h>

-#include <X11/Xproto.h>

-#include "misc.h"

-#include "os.h"

-#include "windowstr.h"

-#include "scrnintstr.h"

-#include "pixmapstr.h"

-#include "extnsionst.h"

-#include "dixstruct.h"

-#include "resource.h"

-#include "opaque.h"

-#include "dbestruct.h"

-#include "midbestr.h"

-#include "regionstr.h"

-#include "gcstruct.h"

-#include "inputstr.h"

-#include "midbe.h"

-#include "xace.h"

-

-#include <stdio.h>

-

-static DevPrivateKeyRec miDbeWindowPrivPrivKeyRec;

-#define miDbeWindowPrivPrivKey (&miDbeWindowPrivPrivKeyRec)

-

-

-/******************************************************************************

- *

- * DBE MI Procedure: miDbeGetVisualInfo

- *

- * Description:

- *

- *     This is the MI function for the DbeGetVisualInfo request.  This function

- *     is called through pDbeScreenPriv->GetVisualInfo.  This function is also

- *     called for the DbeAllocateBackBufferName request at the extension level;

- *     it is called by ProcDbeAllocateBackBufferName() in dbe.c.

- *

- *     If memory allocation fails or we can not get the visual info, this

- *     function returns FALSE.  Otherwise, it returns TRUE for success.

- *

- *****************************************************************************/

-

-static Bool

-miDbeGetVisualInfo(ScreenPtr pScreen, XdbeScreenVisualInfo *pScrVisInfo)

-{

-    register int	i, j, k;

-    register int	count;

-    DepthPtr		pDepth;

-    XdbeVisualInfo	*visInfo;

-

-

-    /* Determine number of visuals for this screen. */

-    for (i = 0, count = 0; i < pScreen->numDepths; i++)

-    {

-        count += pScreen->allowedDepths[i].numVids;

-    }

-

-    /* Allocate an array of XdbeVisualInfo items. */

-    if (!(visInfo = (XdbeVisualInfo *)malloc(count * sizeof(XdbeVisualInfo))))

-    {

-        return FALSE; /* memory alloc failure */

-    }

-

-    for (i = 0, k = 0; i < pScreen->numDepths; i++)

-    {

-        /* For each depth of this screen, get visual information. */

-

-        pDepth = &pScreen->allowedDepths[i];

-

-        for (j = 0; j < pDepth->numVids; j++)

-        {

-            /* For each visual for this depth of this screen, get visual ID

-             * and visual depth.  Since this is MI code, we will always return

-             * the same performance level for all visuals (0).  A higher

-             * performance level value indicates higher performance.

-             */

-            visInfo[k].visual    = pDepth->vids[j];

-            visInfo[k].depth     = pDepth->depth;

-            visInfo[k].perflevel = 0;

-            k++;

-        }

-    }

-

-    /* Record the number of visuals and point visual_depth to

-     * the array of visual info.

-     */

-    pScrVisInfo->count   = count;

-    pScrVisInfo->visinfo = visInfo;

-

-    return TRUE; /* success */

-

-} /* miDbeGetVisualInfo() */

-

-

-/******************************************************************************

- *

- * DBE MI Procedure: miAllocBackBufferName

- *

- * Description:

- *

- *     This is the MI function for the DbeAllocateBackBufferName request.

- *

- *****************************************************************************/

-

-static int

-miDbeAllocBackBufferName(WindowPtr pWin, XID bufId, int swapAction)

-{

-    ScreenPtr			pScreen;

-    DbeWindowPrivPtr		pDbeWindowPriv;

-    MiDbeWindowPrivPrivPtr	pDbeWindowPrivPriv; 

-    DbeScreenPrivPtr		pDbeScreenPriv;

-    GCPtr			pGC;

-    xRectangle			clearRect;

-    int				rc;

-

-

-    pScreen = pWin->drawable.pScreen;

-    pDbeWindowPriv = DBE_WINDOW_PRIV(pWin);

-

-    if (pDbeWindowPriv->nBufferIDs == 0)

-    {

-        /* There is no buffer associated with the window.

-         * We have to create the window priv priv.  Remember, the window

-         * priv was created at the DIX level, so all we need to do is

-         * create the priv priv and attach it to the priv.

-         */

-

-        pDbeScreenPriv = DBE_SCREEN_PRIV(pScreen);

-

-        /* Setup the window priv priv. */

-        pDbeWindowPrivPriv = MI_DBE_WINDOW_PRIV_PRIV(pDbeWindowPriv);

-        pDbeWindowPrivPriv->pDbeWindowPriv = pDbeWindowPriv;

-

-        /* Get a front pixmap. */

-        if (!(pDbeWindowPrivPriv->pFrontBuffer =

-            (*pScreen->CreatePixmap)(pScreen, pDbeWindowPriv->width,

-                                     pDbeWindowPriv->height,

-                                     pWin->drawable.depth, 0)))

-        {

-            return BadAlloc;

-        }

-

-        /* Get a back pixmap. */

-        if (!(pDbeWindowPrivPriv->pBackBuffer =

-            (*pScreen->CreatePixmap)(pScreen, pDbeWindowPriv->width,

-                                     pDbeWindowPriv->height,

-                                     pWin->drawable.depth, 0)))

-        {

-            (*pScreen->DestroyPixmap)(pDbeWindowPrivPriv->pFrontBuffer); 

-            return BadAlloc;

-        }

-

-	/* Security creation/labeling check. */

-	rc = XaceHook(XACE_RESOURCE_ACCESS, serverClient, bufId,

-		      dbeDrawableResType, pDbeWindowPrivPriv->pBackBuffer,

-		      RT_WINDOW, pWin, DixCreateAccess);

-

-        /* Make the back pixmap a DBE drawable resource. */

-        if (rc != Success || !AddResource(bufId, dbeDrawableResType,

-					  pDbeWindowPrivPriv->pBackBuffer))

-        {

-            /* free the buffer and the drawable resource */

-            FreeResource(bufId, RT_NONE);

-            return (rc == Success) ? BadAlloc : rc;

-        }

-

-        /* Clear the back buffer. */

-        pGC = GetScratchGC(pWin->drawable.depth, pWin->drawable.pScreen);

-        if ((*pDbeScreenPriv->SetupBackgroundPainter)(pWin, pGC))

-        {

-            ValidateGC((DrawablePtr)pDbeWindowPrivPriv->pBackBuffer, pGC);

-            clearRect.x = clearRect.y = 0;

-            clearRect.width  = pDbeWindowPrivPriv->pBackBuffer->drawable.width;

-            clearRect.height = pDbeWindowPrivPriv->pBackBuffer->drawable.height;

-            (*pGC->ops->PolyFillRect)(

-                (DrawablePtr)pDbeWindowPrivPriv->pBackBuffer, pGC, 1,

-                &clearRect);

-        }

-        FreeScratchGC(pGC);

-

-    } /* if no buffer associated with the window */

-

-    else

-    {

-        /* A buffer is already associated with the window.

-         * Place the new buffer ID information at the head of the ID list.

-         */

-

-        /* Associate the new ID with an existing pixmap. */

-        pDbeWindowPrivPriv = MI_DBE_WINDOW_PRIV_PRIV(pDbeWindowPriv);

-        if (!AddResource(bufId, dbeDrawableResType,

-                         (pointer)pDbeWindowPrivPriv->pBackBuffer))

-        {

-            return BadAlloc;

-        }

-

-    }

-

-    return Success;

-

-} /* miDbeAllocBackBufferName() */

-

-

-/******************************************************************************

- *

- * DBE MI Procedure: miDbeAliasBuffers

- *

- * Description:

- *

- *     This function associates all XIDs of a buffer with the back pixmap

- *     stored in the window priv.

- *

- *****************************************************************************/

-

-static void

-miDbeAliasBuffers(DbeWindowPrivPtr pDbeWindowPriv)

-{

-    int				i;

-    MiDbeWindowPrivPrivPtr	pDbeWindowPrivPriv =

-                                    MI_DBE_WINDOW_PRIV_PRIV(pDbeWindowPriv);

-

-    for (i = 0; i < pDbeWindowPriv->nBufferIDs; i++)

-    {

-        ChangeResourceValue(pDbeWindowPriv->IDs[i], dbeDrawableResType,

-                            (pointer)pDbeWindowPrivPriv->pBackBuffer);

-    }

-

-} /* miDbeAliasBuffers() */

-

-

-/******************************************************************************

- *

- * DBE MI Procedure: miDbeSwapBuffers

- *

- * Description:

- *

- *     This is the MI function for the DbeSwapBuffers request.

- *

- *****************************************************************************/

-

-static int

-miDbeSwapBuffers(ClientPtr client, int *pNumWindows, DbeSwapInfoPtr swapInfo)

-{

-    DbeScreenPrivPtr		pDbeScreenPriv;

-    GCPtr		    	pGC;

-    WindowPtr		    	pWin;

-    MiDbeWindowPrivPrivPtr	pDbeWindowPrivPriv; 

-    PixmapPtr			pTmpBuffer;

-    xRectangle			clearRect;

-

-

-    pWin               = swapInfo[0].pWindow;

-    pDbeScreenPriv     = DBE_SCREEN_PRIV_FROM_WINDOW(pWin);

-    pDbeWindowPrivPriv = MI_DBE_WINDOW_PRIV_PRIV_FROM_WINDOW(pWin);

-    pGC = GetScratchGC(pWin->drawable.depth, pWin->drawable.pScreen);

-

-    /*

-     **********************************************************************

-     ** Setup before swap.

-     **********************************************************************

-     */

-

-    switch(swapInfo[0].swapAction)

-    {

-        case XdbeUndefined:

-            break;

-

-        case XdbeBackground:

-            break;

-

-        case XdbeUntouched:

-            ValidateGC((DrawablePtr)pDbeWindowPrivPriv->pFrontBuffer, pGC);

-            (*pGC->ops->CopyArea)((DrawablePtr)pWin,

-                                  (DrawablePtr)pDbeWindowPrivPriv->pFrontBuffer,

-                                  pGC, 0, 0, pWin->drawable.width,

-                                  pWin->drawable.height, 0, 0);

-            break;

-

-        case XdbeCopied:

-            break;

-

-    }

-

-    /*

-     **********************************************************************

-     ** Swap.

-     **********************************************************************

-     */

-

-    ValidateGC((DrawablePtr)pWin, pGC);

-    (*pGC->ops->CopyArea)((DrawablePtr)pDbeWindowPrivPriv->pBackBuffer,

-                          (DrawablePtr)pWin, pGC, 0, 0,

-                          pWin->drawable.width, pWin->drawable.height,

-                          0, 0);

-

-    /*

-     **********************************************************************

-     ** Tasks after swap.

-     **********************************************************************

-     */

-

-    switch(swapInfo[0].swapAction)

-    {

-        case XdbeUndefined:

-            break;

-

-        case XdbeBackground:

-            if ((*pDbeScreenPriv->SetupBackgroundPainter)(pWin, pGC))

-            {

-                ValidateGC((DrawablePtr)pDbeWindowPrivPriv->pBackBuffer, pGC);

-                clearRect.x = 0;

-                clearRect.y = 0;

-                clearRect.width =

-                    pDbeWindowPrivPriv->pBackBuffer->drawable.width;

-                clearRect.height =

-                    pDbeWindowPrivPriv->pBackBuffer->drawable.height;

-                (*pGC->ops->PolyFillRect)(

-				(DrawablePtr)pDbeWindowPrivPriv->pBackBuffer,

-				pGC, 1, &clearRect);

-	    }

-            break;

-

-        case XdbeUntouched:

-            /* Swap pixmap pointers. */

-            pTmpBuffer = pDbeWindowPrivPriv->pBackBuffer;

-            pDbeWindowPrivPriv->pBackBuffer =

-                pDbeWindowPrivPriv->pFrontBuffer;

-            pDbeWindowPrivPriv->pFrontBuffer = pTmpBuffer;

-

-            miDbeAliasBuffers(pDbeWindowPrivPriv->pDbeWindowPriv);

-

-            break;

-

-        case XdbeCopied:

-            break;

-

-    }

-

-    /* Remove the swapped window from the swap information array and decrement

-     * pNumWindows to indicate to the DIX level how many windows were actually

-     * swapped.

-     */

-

-    if (*pNumWindows > 1)

-    {

-        /* We were told to swap more than one window, but we only swapped the

-         * first one.  Remove the first window in the list by moving the last

-         * window to the beginning.

-         */

-        swapInfo[0].pWindow    = swapInfo[*pNumWindows - 1].pWindow;

-        swapInfo[0].swapAction = swapInfo[*pNumWindows - 1].swapAction;

-

-        /* Clear the last window information just to be safe. */

-        swapInfo[*pNumWindows - 1].pWindow    = (WindowPtr)NULL;

-        swapInfo[*pNumWindows - 1].swapAction = 0;

-    }

-    else

-    {

-        /* Clear the window information just to be safe. */

-        swapInfo[0].pWindow    = (WindowPtr)NULL;

-        swapInfo[0].swapAction = 0;

-    }

-

-    (*pNumWindows)--;

-

-    FreeScratchGC(pGC);

-

-    return Success;

-

-} /* miSwapBuffers() */

-

-

-/******************************************************************************

- *

- * DBE MI Procedure: miDbeWinPrivDelete

- *

- * Description:

- *

- *     This is the MI function for deleting the dbeWindowPrivResType resource.

- *     This function is invoked indirectly by calling FreeResource() to free

- *     the resources associated with a DBE buffer ID.  There are 5 ways that

- *     miDbeWinPrivDelete() can be called by FreeResource().  They are:

- *

- *     - A DBE window is destroyed, in which case the DbeDestroyWindow()

- *       wrapper is invoked.  The wrapper calls FreeResource() for all DBE

- *       buffer IDs.

- *

- *     - miDbeAllocBackBufferName() calls FreeResource() to clean up resources

- *       after a buffer allocation failure.

- *

- *     - The PositionWindow wrapper, miDbePositionWindow(), calls

- *       FreeResource() when it fails to create buffers of the new size.

- *       FreeResource() is called for all DBE buffer IDs.

- *

- *     - FreeClientResources() calls FreeResource() when a client dies or the

- *       the server resets.

- *

- *     When FreeResource() is called for a DBE buffer ID, the delete function

- *     for the only other type of DBE resource, dbeDrawableResType, is also

- *     invoked.  This delete function (DbeDrawableDelete) is a NOOP to make

- *     resource deletion easier.  It is not guaranteed which delete function is

- *     called first.  Hence, we will let miDbeWinPrivDelete() free all DBE

- *     resources.

- *     

- *     This function deletes/frees the following stuff associated with

- *     the window private:

- *

- *     - the ID node in the ID list representing the passed in ID.

- *

- *     In addition, pDbeWindowPriv->nBufferIDs is decremented.

- *

- *     If this function is called for the last/only buffer ID for a window,

- *     these are additionally deleted/freed:

- *

- *     - the front and back pixmaps

- *     - the window priv itself

- *

- *****************************************************************************/

-

-static void

-miDbeWinPrivDelete(DbeWindowPrivPtr pDbeWindowPriv, XID bufId)

-{

-    MiDbeWindowPrivPrivPtr	pDbeWindowPrivPriv;

-

-

-    if (pDbeWindowPriv->nBufferIDs != 0)

-    {

-        /* We still have at least one more buffer ID associated with this

-         * window.

-         */

-        return;

-    }

-

-

-    /* We have no more buffer IDs associated with this window.  We need to

-     * free some stuff.

-     */

-

-    pDbeWindowPrivPriv = MI_DBE_WINDOW_PRIV_PRIV(pDbeWindowPriv);

-

-    /* Destroy the front and back pixmaps. */

-    if (pDbeWindowPrivPriv->pFrontBuffer)

-    {

-        (*pDbeWindowPriv->pWindow->drawable.pScreen->DestroyPixmap)(

-            pDbeWindowPrivPriv->pFrontBuffer);

-    }

-    if (pDbeWindowPrivPriv->pBackBuffer)

-    {

-        (*pDbeWindowPriv->pWindow->drawable.pScreen->DestroyPixmap)(

-            pDbeWindowPrivPriv->pBackBuffer);

-    }

-

-} /* miDbeWinPrivDelete() */

-

-

-/******************************************************************************

- *

- * DBE MI Procedure: miDbePositionWindow

- *

- * Description:

- *

- *     This function was cloned from miMbxPositionWindow() in mimultibuf.c. 

- *     This function resizes the buffer when the window is resized.

- *

- *****************************************************************************/

-

-static Bool

-miDbePositionWindow(WindowPtr pWin, int x, int y)

-{

-    ScreenPtr			pScreen;

-    DbeScreenPrivPtr		pDbeScreenPriv;

-    DbeWindowPrivPtr		pDbeWindowPriv;

-    int				width, height;

-    int				dx, dy, dw, dh;

-    int				sourcex, sourcey;

-    int				destx, desty;

-    int				savewidth, saveheight;

-    PixmapPtr			pFrontBuffer;

-    PixmapPtr			pBackBuffer;

-    Bool			clear;

-    GCPtr			pGC;

-    xRectangle			clearRect;

-    Bool			ret;

-

-

-    /*

-     **************************************************************************

-     ** 1. Unwrap the member routine.

-     **************************************************************************

-     */

-     

-    pScreen                 = pWin->drawable.pScreen;

-    pDbeScreenPriv          = DBE_SCREEN_PRIV(pScreen);

-    pScreen->PositionWindow = pDbeScreenPriv->PositionWindow;

-

-    /*

-     **************************************************************************

-     ** 2. Do any work necessary before the member routine is called.

-     **

-     **    In this case we do not need to do anything.

-     **************************************************************************

-     */

-     

-    /*

-     **************************************************************************

-     ** 3. Call the member routine, saving its result if necessary.

-     **************************************************************************

-     */

-     

-    ret = (*pScreen->PositionWindow)(pWin, x, y);

-

-    /*

-     **************************************************************************

-     ** 4. Rewrap the member routine, restoring the wrapper value first in case

-     **    the wrapper (or something that it wrapped) change this value.

-     **************************************************************************

-     */

-

-    pDbeScreenPriv->PositionWindow = pScreen->PositionWindow;

-    pScreen->PositionWindow = miDbePositionWindow;

-

-    /*

-     **************************************************************************

-     ** 5. Do any work necessary after the member routine has been called.

-     **************************************************************************

-     */

-     

-    if (!(pDbeWindowPriv = DBE_WINDOW_PRIV(pWin)))

-    {

-	return ret;

-    }

-

-    if (pDbeWindowPriv->width  == pWin->drawable.width &&

-        pDbeWindowPriv->height == pWin->drawable.height)

-    {

-	return ret;

-    }

-

-    width  = pWin->drawable.width;

-    height = pWin->drawable.height;

-

-    dx = pWin->drawable.x - pDbeWindowPriv->x;

-    dy = pWin->drawable.y - pDbeWindowPriv->y;

-    dw = width  - pDbeWindowPriv->width;

-    dh = height - pDbeWindowPriv->height;

-

-    GravityTranslate (0, 0, -dx, -dy, dw, dh, pWin->bitGravity, &destx, &desty);

-

-    clear = ((pDbeWindowPriv->width  < (unsigned short)width ) ||

-             (pDbeWindowPriv->height < (unsigned short)height) ||

-             (pWin->bitGravity == ForgetGravity));

-

-    sourcex = 0;

-    sourcey = 0;

-    savewidth  = pDbeWindowPriv->width;

-    saveheight = pDbeWindowPriv->height;

-

-    /* Clip rectangle to source and destination. */

-    if (destx < 0)

-    {

-	savewidth += destx;

-	sourcex   -= destx;

-	destx      = 0;

-    }

-

-    if (destx + savewidth > width)

-    {

-	savewidth = width - destx;

-    }

-

-    if (desty < 0)

-    {

-	saveheight += desty;

-	sourcey    -= desty;

-	desty       = 0;

-    }

-

-    if (desty + saveheight > height)

-    {

-	saveheight = height - desty;

-    }

-

-    pDbeWindowPriv->width  = width;

-    pDbeWindowPriv->height = height;

-    pDbeWindowPriv->x = pWin->drawable.x;

-    pDbeWindowPriv->y = pWin->drawable.y;

-

-    pGC = GetScratchGC (pWin->drawable.depth, pScreen);

-

-    if (clear)

-    {

-	if ((*pDbeScreenPriv->SetupBackgroundPainter)(pWin, pGC))

-	{

-	    clearRect.x = 0;

-	    clearRect.y = 0;

-	    clearRect.width  = width;

-	    clearRect.height = height;

-	}

-	else

-	{ 

-	    clear = FALSE;

-	}

-    }

-

-    /* Create DBE buffer pixmaps equal to size of resized window. */

-    pFrontBuffer = (*pScreen->CreatePixmap)(pScreen, width, height,

-					    pWin->drawable.depth, 0);

-

-    pBackBuffer = (*pScreen->CreatePixmap)(pScreen, width, height,

-					   pWin->drawable.depth, 0);

-

-    if (!pFrontBuffer || !pBackBuffer)

-    {

-        /* We failed at creating 1 or 2 of the pixmaps. */

-

-        if (pFrontBuffer)

-        {

-	    (*pScreen->DestroyPixmap)(pFrontBuffer);

-        }

-

-        if (pBackBuffer)

-        {

-	    (*pScreen->DestroyPixmap)(pBackBuffer);

-        }

-

-        /* Destroy all buffers for this window. */

-        while (pDbeWindowPriv)

-        {

-            /* DbeWindowPrivDelete() will free the window private if there no

-             * more buffer IDs associated with this window.

-             */

-            FreeResource(pDbeWindowPriv->IDs[0], RT_NONE);

-            pDbeWindowPriv = DBE_WINDOW_PRIV(pWin);

-        }

-

-        FreeScratchGC(pGC);

-        return FALSE;

-    }

-

-    else

-    {

-        /* Clear out the new DBE buffer pixmaps. */

-

-        MiDbeWindowPrivPrivPtr	pDbeWindowPrivPriv;

-

-

-        pDbeWindowPrivPriv = MI_DBE_WINDOW_PRIV_PRIV(pDbeWindowPriv);

-

-	/* I suppose this could avoid quite a bit of work if

-	 * it computed the minimal area required.

-	 */

-	ValidateGC(&pFrontBuffer->drawable, pGC);

-	if (clear)

-        {

-	    (*pGC->ops->PolyFillRect)((DrawablePtr)pFrontBuffer, pGC, 1,

-				      &clearRect);

-	}

-	/* Copy the contents of the old front pixmap to the new one. */

-	if (pWin->bitGravity != ForgetGravity)

-	{

-	    (*pGC->ops->CopyArea)((DrawablePtr)pDbeWindowPrivPriv->pFrontBuffer,

-                                  (DrawablePtr)pFrontBuffer, pGC, sourcex,

-                                  sourcey, savewidth, saveheight, destx, desty);

-        }

-

-	ValidateGC(&pBackBuffer->drawable, pGC);

-	if (clear)

-	{

-	    (*pGC->ops->PolyFillRect)((DrawablePtr)pBackBuffer , pGC, 1,

-				      &clearRect);

-	}

-	/* Copy the contents of the old back pixmap to the new one. */

-	if (pWin->bitGravity != ForgetGravity)

-	{

-	    (*pGC->ops->CopyArea)((DrawablePtr)pDbeWindowPrivPriv->pBackBuffer,

-                                  (DrawablePtr)pBackBuffer, pGC, sourcex,

-                                  sourcey, savewidth, saveheight, destx, desty);

-	}

-

-        /* Destroy the old pixmaps, and point the DBE window priv to the new

-         * pixmaps.

-         */

-

-	(*pScreen->DestroyPixmap)(pDbeWindowPrivPriv->pFrontBuffer);

-	(*pScreen->DestroyPixmap)(pDbeWindowPrivPriv->pBackBuffer);

-

-        pDbeWindowPrivPriv->pFrontBuffer = pFrontBuffer;

-        pDbeWindowPrivPriv->pBackBuffer  = pBackBuffer;

-

-	/* Make sure all XID are associated with the new back pixmap. */

-        miDbeAliasBuffers(pDbeWindowPriv);

-

-        FreeScratchGC(pGC);

-    }

-

-    return ret;

-

-} /* miDbePositionWindow() */

-

-

-/******************************************************************************

- *

- * DBE MI Procedure: miDbeResetProc

- *

- * Description:

- *

- *     This function is called from DbeResetProc(), which is called at the end

- *     of every server generation.  This function peforms any MI-specific

- *     shutdown tasks.

- *

- *****************************************************************************/

-

-static void

-miDbeResetProc(ScreenPtr pScreen)

-{

-    DbeScreenPrivPtr    pDbeScreenPriv;

-

-

-    pDbeScreenPriv = DBE_SCREEN_PRIV(pScreen);

-

-    /* Unwrap wrappers */

-    pScreen->PositionWindow = pDbeScreenPriv->PositionWindow;

-

-} /* miDbeResetProc() */

-

-

-/******************************************************************************

- *

- * DBE MI Procedure: miDbeInit

- *

- * Description:

- *

- *     This is the MI initialization function called by DbeExtensionInit().

- *

- *****************************************************************************/

-

-Bool

-miDbeInit(ScreenPtr pScreen, DbeScreenPrivPtr pDbeScreenPriv)

-{

-    if (!dixRegisterPrivateKey(&miDbeWindowPrivPrivKeyRec, PRIVATE_DBE_WINDOW,

-			       sizeof(MiDbeWindowPrivPrivRec)))

-        return FALSE;

-

-    /* Wrap functions. */

-    pDbeScreenPriv->PositionWindow = pScreen->PositionWindow;

-    pScreen->PositionWindow        = miDbePositionWindow;

-

-    /* Initialize the per-screen DBE function pointers. */

-    pDbeScreenPriv->GetVisualInfo         = miDbeGetVisualInfo;

-    pDbeScreenPriv->AllocBackBufferName   = miDbeAllocBackBufferName;

-    pDbeScreenPriv->SwapBuffers           = miDbeSwapBuffers;

-    pDbeScreenPriv->BeginIdiom            = 0;

-    pDbeScreenPriv->EndIdiom              = 0;

-    pDbeScreenPriv->ResetProc             = miDbeResetProc;

-    pDbeScreenPriv->WinPrivDelete         = miDbeWinPrivDelete;

-

-    return TRUE;

-

-} /* miDbeInit() */

+/******************************************************************************
+ * 
+ * Copyright (c) 1994, 1995  Hewlett-Packard Company
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL HEWLETT-PACKARD COMPANY BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ * Except as contained in this notice, the name of the Hewlett-Packard
+ * Company shall not be used in advertising or otherwise to promote the
+ * sale, use or other dealings in this Software without prior written
+ * authorization from the Hewlett-Packard Company.
+ * 
+ *     Machine-independent DBE code
+ *
+ *****************************************************************************/
+
+/* INCLUDES */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#include "misc.h"
+#include "os.h"
+#include "windowstr.h"
+#include "scrnintstr.h"
+#include "pixmapstr.h"
+#include "extnsionst.h"
+#include "dixstruct.h"
+#include "resource.h"
+#include "opaque.h"
+#include "dbestruct.h"
+#include "midbestr.h"
+#include "regionstr.h"
+#include "gcstruct.h"
+#include "inputstr.h"
+#include "midbe.h"
+#include "xace.h"
+
+#include <stdio.h>
+
+static DevPrivateKeyRec miDbeWindowPrivPrivKeyRec;
+
+#define miDbeWindowPrivPrivKey (&miDbeWindowPrivPrivKeyRec)
+
+/******************************************************************************
+ *
+ * DBE MI Procedure: miDbeGetVisualInfo
+ *
+ * Description:
+ *
+ *     This is the MI function for the DbeGetVisualInfo request.  This function
+ *     is called through pDbeScreenPriv->GetVisualInfo.  This function is also
+ *     called for the DbeAllocateBackBufferName request at the extension level;
+ *     it is called by ProcDbeAllocateBackBufferName() in dbe.c.
+ *
+ *     If memory allocation fails or we can not get the visual info, this
+ *     function returns FALSE.  Otherwise, it returns TRUE for success.
+ *
+ *****************************************************************************/
+
+static Bool
+miDbeGetVisualInfo(ScreenPtr pScreen, XdbeScreenVisualInfo * pScrVisInfo)
+{
+    register int i, j, k;
+    register int count;
+    DepthPtr pDepth;
+    XdbeVisualInfo *visInfo;
+
+    /* Determine number of visuals for this screen. */
+    for (i = 0, count = 0; i < pScreen->numDepths; i++) {
+        count += pScreen->allowedDepths[i].numVids;
+    }
+
+    /* Allocate an array of XdbeVisualInfo items. */
+    if (!(visInfo = (XdbeVisualInfo *) malloc(count * sizeof(XdbeVisualInfo)))) {
+        return FALSE;           /* memory alloc failure */
+    }
+
+    for (i = 0, k = 0; i < pScreen->numDepths; i++) {
+        /* For each depth of this screen, get visual information. */
+
+        pDepth = &pScreen->allowedDepths[i];
+
+        for (j = 0; j < pDepth->numVids; j++) {
+            /* For each visual for this depth of this screen, get visual ID
+             * and visual depth.  Since this is MI code, we will always return
+             * the same performance level for all visuals (0).  A higher
+             * performance level value indicates higher performance.
+             */
+            visInfo[k].visual = pDepth->vids[j];
+            visInfo[k].depth = pDepth->depth;
+            visInfo[k].perflevel = 0;
+            k++;
+        }
+    }
+
+    /* Record the number of visuals and point visual_depth to
+     * the array of visual info.
+     */
+    pScrVisInfo->count = count;
+    pScrVisInfo->visinfo = visInfo;
+
+    return TRUE;                /* success */
+
+}                               /* miDbeGetVisualInfo() */
+
+/******************************************************************************
+ *
+ * DBE MI Procedure: miAllocBackBufferName
+ *
+ * Description:
+ *
+ *     This is the MI function for the DbeAllocateBackBufferName request.
+ *
+ *****************************************************************************/
+
+static int
+miDbeAllocBackBufferName(WindowPtr pWin, XID bufId, int swapAction)
+{
+    ScreenPtr pScreen;
+    DbeWindowPrivPtr pDbeWindowPriv;
+    MiDbeWindowPrivPrivPtr pDbeWindowPrivPriv;
+    DbeScreenPrivPtr pDbeScreenPriv;
+    GCPtr pGC;
+    xRectangle clearRect;
+    int rc;
+
+    pScreen = pWin->drawable.pScreen;
+    pDbeWindowPriv = DBE_WINDOW_PRIV(pWin);
+
+    if (pDbeWindowPriv->nBufferIDs == 0) {
+        /* There is no buffer associated with the window.
+         * We have to create the window priv priv.  Remember, the window
+         * priv was created at the DIX level, so all we need to do is
+         * create the priv priv and attach it to the priv.
+         */
+
+        pDbeScreenPriv = DBE_SCREEN_PRIV(pScreen);
+
+        /* Setup the window priv priv. */
+        pDbeWindowPrivPriv = MI_DBE_WINDOW_PRIV_PRIV(pDbeWindowPriv);
+        pDbeWindowPrivPriv->pDbeWindowPriv = pDbeWindowPriv;
+
+        /* Get a front pixmap. */
+        if (!(pDbeWindowPrivPriv->pFrontBuffer =
+              (*pScreen->CreatePixmap) (pScreen, pDbeWindowPriv->width,
+                                        pDbeWindowPriv->height,
+                                        pWin->drawable.depth, 0))) {
+            return BadAlloc;
+        }
+
+        /* Get a back pixmap. */
+        if (!(pDbeWindowPrivPriv->pBackBuffer =
+              (*pScreen->CreatePixmap) (pScreen, pDbeWindowPriv->width,
+                                        pDbeWindowPriv->height,
+                                        pWin->drawable.depth, 0))) {
+            (*pScreen->DestroyPixmap) (pDbeWindowPrivPriv->pFrontBuffer);
+            return BadAlloc;
+        }
+
+        /* Security creation/labeling check. */
+        rc = XaceHook(XACE_RESOURCE_ACCESS, serverClient, bufId,
+                      dbeDrawableResType, pDbeWindowPrivPriv->pBackBuffer,
+                      RT_WINDOW, pWin, DixCreateAccess);
+
+        /* Make the back pixmap a DBE drawable resource. */
+        if (rc != Success || !AddResource(bufId, dbeDrawableResType,
+                                          pDbeWindowPrivPriv->pBackBuffer)) {
+            /* free the buffer and the drawable resource */
+            FreeResource(bufId, RT_NONE);
+            return (rc == Success) ? BadAlloc : rc;
+        }
+
+        /* Clear the back buffer. */
+        pGC = GetScratchGC(pWin->drawable.depth, pWin->drawable.pScreen);
+        if ((*pDbeScreenPriv->SetupBackgroundPainter) (pWin, pGC)) {
+            ValidateGC((DrawablePtr) pDbeWindowPrivPriv->pBackBuffer, pGC);
+            clearRect.x = clearRect.y = 0;
+            clearRect.width = pDbeWindowPrivPriv->pBackBuffer->drawable.width;
+            clearRect.height = pDbeWindowPrivPriv->pBackBuffer->drawable.height;
+            (*pGC->ops->PolyFillRect) ((DrawablePtr) pDbeWindowPrivPriv->
+                                       pBackBuffer, pGC, 1, &clearRect);
+        }
+        FreeScratchGC(pGC);
+
+    }                           /* if no buffer associated with the window */
+
+    else {
+        /* A buffer is already associated with the window.
+         * Place the new buffer ID information at the head of the ID list.
+         */
+
+        /* Associate the new ID with an existing pixmap. */
+        pDbeWindowPrivPriv = MI_DBE_WINDOW_PRIV_PRIV(pDbeWindowPriv);
+        if (!AddResource(bufId, dbeDrawableResType,
+                         (pointer) pDbeWindowPrivPriv->pBackBuffer)) {
+            return BadAlloc;
+        }
+
+    }
+
+    return Success;
+
+}                               /* miDbeAllocBackBufferName() */
+
+/******************************************************************************
+ *
+ * DBE MI Procedure: miDbeAliasBuffers
+ *
+ * Description:
+ *
+ *     This function associates all XIDs of a buffer with the back pixmap
+ *     stored in the window priv.
+ *
+ *****************************************************************************/
+
+static void
+miDbeAliasBuffers(DbeWindowPrivPtr pDbeWindowPriv)
+{
+    int i;
+    MiDbeWindowPrivPrivPtr pDbeWindowPrivPriv =
+        MI_DBE_WINDOW_PRIV_PRIV(pDbeWindowPriv);
+
+    for (i = 0; i < pDbeWindowPriv->nBufferIDs; i++) {
+        ChangeResourceValue(pDbeWindowPriv->IDs[i], dbeDrawableResType,
+                            (pointer) pDbeWindowPrivPriv->pBackBuffer);
+    }
+
+}                               /* miDbeAliasBuffers() */
+
+/******************************************************************************
+ *
+ * DBE MI Procedure: miDbeSwapBuffers
+ *
+ * Description:
+ *
+ *     This is the MI function for the DbeSwapBuffers request.
+ *
+ *****************************************************************************/
+
+static int
+miDbeSwapBuffers(ClientPtr client, int *pNumWindows, DbeSwapInfoPtr swapInfo)
+{
+    DbeScreenPrivPtr pDbeScreenPriv;
+    GCPtr pGC;
+    WindowPtr pWin;
+    MiDbeWindowPrivPrivPtr pDbeWindowPrivPriv;
+    PixmapPtr pTmpBuffer;
+    xRectangle clearRect;
+
+    pWin = swapInfo[0].pWindow;
+    pDbeScreenPriv = DBE_SCREEN_PRIV_FROM_WINDOW(pWin);
+    pDbeWindowPrivPriv = MI_DBE_WINDOW_PRIV_PRIV_FROM_WINDOW(pWin);
+    pGC = GetScratchGC(pWin->drawable.depth, pWin->drawable.pScreen);
+
+    /*
+     **********************************************************************
+     ** Setup before swap.
+     **********************************************************************
+     */
+
+    switch (swapInfo[0].swapAction) {
+    case XdbeUndefined:
+        break;
+
+    case XdbeBackground:
+        break;
+
+    case XdbeUntouched:
+        ValidateGC((DrawablePtr) pDbeWindowPrivPriv->pFrontBuffer, pGC);
+        (*pGC->ops->CopyArea) ((DrawablePtr) pWin,
+                               (DrawablePtr) pDbeWindowPrivPriv->pFrontBuffer,
+                               pGC, 0, 0, pWin->drawable.width,
+                               pWin->drawable.height, 0, 0);
+        break;
+
+    case XdbeCopied:
+        break;
+
+    }
+
+    /*
+     **********************************************************************
+     ** Swap.
+     **********************************************************************
+     */
+
+    ValidateGC((DrawablePtr) pWin, pGC);
+    (*pGC->ops->CopyArea) ((DrawablePtr) pDbeWindowPrivPriv->pBackBuffer,
+                           (DrawablePtr) pWin, pGC, 0, 0,
+                           pWin->drawable.width, pWin->drawable.height, 0, 0);
+
+    /*
+     **********************************************************************
+     ** Tasks after swap.
+     **********************************************************************
+     */
+
+    switch (swapInfo[0].swapAction) {
+    case XdbeUndefined:
+        break;
+
+    case XdbeBackground:
+        if ((*pDbeScreenPriv->SetupBackgroundPainter) (pWin, pGC)) {
+            ValidateGC((DrawablePtr) pDbeWindowPrivPriv->pBackBuffer, pGC);
+            clearRect.x = 0;
+            clearRect.y = 0;
+            clearRect.width = pDbeWindowPrivPriv->pBackBuffer->drawable.width;
+            clearRect.height = pDbeWindowPrivPriv->pBackBuffer->drawable.height;
+            (*pGC->ops->PolyFillRect) ((DrawablePtr) pDbeWindowPrivPriv->
+                                       pBackBuffer, pGC, 1, &clearRect);
+        }
+        break;
+
+    case XdbeUntouched:
+        /* Swap pixmap pointers. */
+        pTmpBuffer = pDbeWindowPrivPriv->pBackBuffer;
+        pDbeWindowPrivPriv->pBackBuffer = pDbeWindowPrivPriv->pFrontBuffer;
+        pDbeWindowPrivPriv->pFrontBuffer = pTmpBuffer;
+
+        miDbeAliasBuffers(pDbeWindowPrivPriv->pDbeWindowPriv);
+
+        break;
+
+    case XdbeCopied:
+        break;
+
+    }
+
+    /* Remove the swapped window from the swap information array and decrement
+     * pNumWindows to indicate to the DIX level how many windows were actually
+     * swapped.
+     */
+
+    if (*pNumWindows > 1) {
+        /* We were told to swap more than one window, but we only swapped the
+         * first one.  Remove the first window in the list by moving the last
+         * window to the beginning.
+         */
+        swapInfo[0].pWindow = swapInfo[*pNumWindows - 1].pWindow;
+        swapInfo[0].swapAction = swapInfo[*pNumWindows - 1].swapAction;
+
+        /* Clear the last window information just to be safe. */
+        swapInfo[*pNumWindows - 1].pWindow = (WindowPtr) NULL;
+        swapInfo[*pNumWindows - 1].swapAction = 0;
+    }
+    else {
+        /* Clear the window information just to be safe. */
+        swapInfo[0].pWindow = (WindowPtr) NULL;
+        swapInfo[0].swapAction = 0;
+    }
+
+    (*pNumWindows)--;
+
+    FreeScratchGC(pGC);
+
+    return Success;
+
+}                               /* miSwapBuffers() */
+
+/******************************************************************************
+ *
+ * DBE MI Procedure: miDbeWinPrivDelete
+ *
+ * Description:
+ *
+ *     This is the MI function for deleting the dbeWindowPrivResType resource.
+ *     This function is invoked indirectly by calling FreeResource() to free
+ *     the resources associated with a DBE buffer ID.  There are 5 ways that
+ *     miDbeWinPrivDelete() can be called by FreeResource().  They are:
+ *
+ *     - A DBE window is destroyed, in which case the DbeDestroyWindow()
+ *       wrapper is invoked.  The wrapper calls FreeResource() for all DBE
+ *       buffer IDs.
+ *
+ *     - miDbeAllocBackBufferName() calls FreeResource() to clean up resources
+ *       after a buffer allocation failure.
+ *
+ *     - The PositionWindow wrapper, miDbePositionWindow(), calls
+ *       FreeResource() when it fails to create buffers of the new size.
+ *       FreeResource() is called for all DBE buffer IDs.
+ *
+ *     - FreeClientResources() calls FreeResource() when a client dies or the
+ *       the server resets.
+ *
+ *     When FreeResource() is called for a DBE buffer ID, the delete function
+ *     for the only other type of DBE resource, dbeDrawableResType, is also
+ *     invoked.  This delete function (DbeDrawableDelete) is a NOOP to make
+ *     resource deletion easier.  It is not guaranteed which delete function is
+ *     called first.  Hence, we will let miDbeWinPrivDelete() free all DBE
+ *     resources.
+ *     
+ *     This function deletes/frees the following stuff associated with
+ *     the window private:
+ *
+ *     - the ID node in the ID list representing the passed in ID.
+ *
+ *     In addition, pDbeWindowPriv->nBufferIDs is decremented.
+ *
+ *     If this function is called for the last/only buffer ID for a window,
+ *     these are additionally deleted/freed:
+ *
+ *     - the front and back pixmaps
+ *     - the window priv itself
+ *
+ *****************************************************************************/
+
+static void
+miDbeWinPrivDelete(DbeWindowPrivPtr pDbeWindowPriv, XID bufId)
+{
+    MiDbeWindowPrivPrivPtr pDbeWindowPrivPriv;
+
+    if (pDbeWindowPriv->nBufferIDs != 0) {
+        /* We still have at least one more buffer ID associated with this
+         * window.
+         */
+        return;
+    }
+
+    /* We have no more buffer IDs associated with this window.  We need to
+     * free some stuff.
+     */
+
+    pDbeWindowPrivPriv = MI_DBE_WINDOW_PRIV_PRIV(pDbeWindowPriv);
+
+    /* Destroy the front and back pixmaps. */
+    if (pDbeWindowPrivPriv->pFrontBuffer) {
+        (*pDbeWindowPriv->pWindow->drawable.pScreen->
+         DestroyPixmap) (pDbeWindowPrivPriv->pFrontBuffer);
+    }
+    if (pDbeWindowPrivPriv->pBackBuffer) {
+        (*pDbeWindowPriv->pWindow->drawable.pScreen->
+         DestroyPixmap) (pDbeWindowPrivPriv->pBackBuffer);
+    }
+
+}                               /* miDbeWinPrivDelete() */
+
+/******************************************************************************
+ *
+ * DBE MI Procedure: miDbePositionWindow
+ *
+ * Description:
+ *
+ *     This function was cloned from miMbxPositionWindow() in mimultibuf.c. 
+ *     This function resizes the buffer when the window is resized.
+ *
+ *****************************************************************************/
+
+static Bool
+miDbePositionWindow(WindowPtr pWin, int x, int y)
+{
+    ScreenPtr pScreen;
+    DbeScreenPrivPtr pDbeScreenPriv;
+    DbeWindowPrivPtr pDbeWindowPriv;
+    int width, height;
+    int dx, dy, dw, dh;
+    int sourcex, sourcey;
+    int destx, desty;
+    int savewidth, saveheight;
+    PixmapPtr pFrontBuffer;
+    PixmapPtr pBackBuffer;
+    Bool clear;
+    GCPtr pGC;
+    xRectangle clearRect;
+    Bool ret;
+
+    /*
+     **************************************************************************
+     ** 1. Unwrap the member routine.
+     **************************************************************************
+     */
+
+    pScreen = pWin->drawable.pScreen;
+    pDbeScreenPriv = DBE_SCREEN_PRIV(pScreen);
+    pScreen->PositionWindow = pDbeScreenPriv->PositionWindow;
+
+    /*
+     **************************************************************************
+     ** 2. Do any work necessary before the member routine is called.
+     **
+     **    In this case we do not need to do anything.
+     **************************************************************************
+     */
+
+    /*
+     **************************************************************************
+     ** 3. Call the member routine, saving its result if necessary.
+     **************************************************************************
+     */
+
+    ret = (*pScreen->PositionWindow) (pWin, x, y);
+
+    /*
+     **************************************************************************
+     ** 4. Rewrap the member routine, restoring the wrapper value first in case
+     **    the wrapper (or something that it wrapped) change this value.
+     **************************************************************************
+     */
+
+    pDbeScreenPriv->PositionWindow = pScreen->PositionWindow;
+    pScreen->PositionWindow = miDbePositionWindow;
+
+    /*
+     **************************************************************************
+     ** 5. Do any work necessary after the member routine has been called.
+     **************************************************************************
+     */
+
+    if (!(pDbeWindowPriv = DBE_WINDOW_PRIV(pWin))) {
+        return ret;
+    }
+
+    if (pDbeWindowPriv->width == pWin->drawable.width &&
+        pDbeWindowPriv->height == pWin->drawable.height) {
+        return ret;
+    }
+
+    width = pWin->drawable.width;
+    height = pWin->drawable.height;
+
+    dx = pWin->drawable.x - pDbeWindowPriv->x;
+    dy = pWin->drawable.y - pDbeWindowPriv->y;
+    dw = width - pDbeWindowPriv->width;
+    dh = height - pDbeWindowPriv->height;
+
+    GravityTranslate(0, 0, -dx, -dy, dw, dh, pWin->bitGravity, &destx, &desty);
+
+    clear = ((pDbeWindowPriv->width < (unsigned short) width) ||
+             (pDbeWindowPriv->height < (unsigned short) height) ||
+             (pWin->bitGravity == ForgetGravity));
+
+    sourcex = 0;
+    sourcey = 0;
+    savewidth = pDbeWindowPriv->width;
+    saveheight = pDbeWindowPriv->height;
+
+    /* Clip rectangle to source and destination. */
+    if (destx < 0) {
+        savewidth += destx;
+        sourcex -= destx;
+        destx = 0;
+    }
+
+    if (destx + savewidth > width) {
+        savewidth = width - destx;
+    }
+
+    if (desty < 0) {
+        saveheight += desty;
+        sourcey -= desty;
+        desty = 0;
+    }
+
+    if (desty + saveheight > height) {
+        saveheight = height - desty;
+    }
+
+    pDbeWindowPriv->width = width;
+    pDbeWindowPriv->height = height;
+    pDbeWindowPriv->x = pWin->drawable.x;
+    pDbeWindowPriv->y = pWin->drawable.y;
+
+    pGC = GetScratchGC(pWin->drawable.depth, pScreen);
+
+    if (clear) {
+        if ((*pDbeScreenPriv->SetupBackgroundPainter) (pWin, pGC)) {
+            clearRect.x = 0;
+            clearRect.y = 0;
+            clearRect.width = width;
+            clearRect.height = height;
+        }
+        else {
+            clear = FALSE;
+        }
+    }
+
+    /* Create DBE buffer pixmaps equal to size of resized window. */
+    pFrontBuffer = (*pScreen->CreatePixmap) (pScreen, width, height,
+                                             pWin->drawable.depth, 0);
+
+    pBackBuffer = (*pScreen->CreatePixmap) (pScreen, width, height,
+                                            pWin->drawable.depth, 0);
+
+    if (!pFrontBuffer || !pBackBuffer) {
+        /* We failed at creating 1 or 2 of the pixmaps. */
+
+        if (pFrontBuffer) {
+            (*pScreen->DestroyPixmap) (pFrontBuffer);
+        }
+
+        if (pBackBuffer) {
+            (*pScreen->DestroyPixmap) (pBackBuffer);
+        }
+
+        /* Destroy all buffers for this window. */
+        while (pDbeWindowPriv) {
+            /* DbeWindowPrivDelete() will free the window private if there no
+             * more buffer IDs associated with this window.
+             */
+            FreeResource(pDbeWindowPriv->IDs[0], RT_NONE);
+            pDbeWindowPriv = DBE_WINDOW_PRIV(pWin);
+        }
+
+        FreeScratchGC(pGC);
+        return FALSE;
+    }
+
+    else {
+        /* Clear out the new DBE buffer pixmaps. */
+
+        MiDbeWindowPrivPrivPtr pDbeWindowPrivPriv;
+
+        pDbeWindowPrivPriv = MI_DBE_WINDOW_PRIV_PRIV(pDbeWindowPriv);
+
+        /* I suppose this could avoid quite a bit of work if
+         * it computed the minimal area required.
+         */
+        ValidateGC(&pFrontBuffer->drawable, pGC);
+        if (clear) {
+            (*pGC->ops->PolyFillRect) ((DrawablePtr) pFrontBuffer, pGC, 1,
+                                       &clearRect);
+        }
+        /* Copy the contents of the old front pixmap to the new one. */
+        if (pWin->bitGravity != ForgetGravity) {
+            (*pGC->ops->CopyArea) ((DrawablePtr) pDbeWindowPrivPriv->
+                                   pFrontBuffer, (DrawablePtr) pFrontBuffer,
+                                   pGC, sourcex, sourcey, savewidth, saveheight,
+                                   destx, desty);
+        }
+
+        ValidateGC(&pBackBuffer->drawable, pGC);
+        if (clear) {
+            (*pGC->ops->PolyFillRect) ((DrawablePtr) pBackBuffer, pGC, 1,
+                                       &clearRect);
+        }
+        /* Copy the contents of the old back pixmap to the new one. */
+        if (pWin->bitGravity != ForgetGravity) {
+            (*pGC->ops->CopyArea) ((DrawablePtr) pDbeWindowPrivPriv->
+                                   pBackBuffer, (DrawablePtr) pBackBuffer, pGC,
+                                   sourcex, sourcey, savewidth, saveheight,
+                                   destx, desty);
+        }
+
+        /* Destroy the old pixmaps, and point the DBE window priv to the new
+         * pixmaps.
+         */
+
+        (*pScreen->DestroyPixmap) (pDbeWindowPrivPriv->pFrontBuffer);
+        (*pScreen->DestroyPixmap) (pDbeWindowPrivPriv->pBackBuffer);
+
+        pDbeWindowPrivPriv->pFrontBuffer = pFrontBuffer;
+        pDbeWindowPrivPriv->pBackBuffer = pBackBuffer;
+
+        /* Make sure all XID are associated with the new back pixmap. */
+        miDbeAliasBuffers(pDbeWindowPriv);
+
+        FreeScratchGC(pGC);
+    }
+
+    return ret;
+
+}                               /* miDbePositionWindow() */
+
+/******************************************************************************
+ *
+ * DBE MI Procedure: miDbeResetProc
+ *
+ * Description:
+ *
+ *     This function is called from DbeResetProc(), which is called at the end
+ *     of every server generation.  This function peforms any MI-specific
+ *     shutdown tasks.
+ *
+ *****************************************************************************/
+
+static void
+miDbeResetProc(ScreenPtr pScreen)
+{
+    DbeScreenPrivPtr pDbeScreenPriv;
+
+    pDbeScreenPriv = DBE_SCREEN_PRIV(pScreen);
+
+    /* Unwrap wrappers */
+    pScreen->PositionWindow = pDbeScreenPriv->PositionWindow;
+
+}                               /* miDbeResetProc() */
+
+/******************************************************************************
+ *
+ * DBE MI Procedure: miDbeInit
+ *
+ * Description:
+ *
+ *     This is the MI initialization function called by DbeExtensionInit().
+ *
+ *****************************************************************************/
+
+Bool
+miDbeInit(ScreenPtr pScreen, DbeScreenPrivPtr pDbeScreenPriv)
+{
+    if (!dixRegisterPrivateKey(&miDbeWindowPrivPrivKeyRec, PRIVATE_DBE_WINDOW,
+                               sizeof(MiDbeWindowPrivPrivRec)))
+        return FALSE;
+
+    /* Wrap functions. */
+    pDbeScreenPriv->PositionWindow = pScreen->PositionWindow;
+    pScreen->PositionWindow = miDbePositionWindow;
+
+    /* Initialize the per-screen DBE function pointers. */
+    pDbeScreenPriv->GetVisualInfo = miDbeGetVisualInfo;
+    pDbeScreenPriv->AllocBackBufferName = miDbeAllocBackBufferName;
+    pDbeScreenPriv->SwapBuffers = miDbeSwapBuffers;
+    pDbeScreenPriv->BeginIdiom = 0;
+    pDbeScreenPriv->EndIdiom = 0;
+    pDbeScreenPriv->ResetProc = miDbeResetProc;
+    pDbeScreenPriv->WinPrivDelete = miDbeWinPrivDelete;
+
+    return TRUE;
+
+}                               /* miDbeInit() */
diff --git a/xorg-server/dbe/midbe.h b/xorg-server/dbe/midbe.h
index 4f09bf432..4eed538d0 100644
--- a/xorg-server/dbe/midbe.h
+++ b/xorg-server/dbe/midbe.h
@@ -1,58 +1,56 @@
-/******************************************************************************

- * Copyright (c) 1994, 1995  Hewlett-Packard Company

- *

- * Permission is hereby granted, free of charge, to any person obtaining

- * a copy of this software and associated documentation files (the

- * "Software"), to deal in the Software without restriction, including

- * without limitation the rights to use, copy, modify, merge, publish,

- * distribute, sublicense, and/or sell copies of the Software, and to

- * permit persons to whom the Software is furnished to do so, subject to

- * the following conditions:

- * 

- * The above copyright notice and this permission notice shall be included

- * in all copies or substantial portions of the Software.

- * 

- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

- * IN NO EVENT SHALL HEWLETT-PACKARD COMPANY BE LIABLE FOR ANY CLAIM,

- * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR

- * THE USE OR OTHER DEALINGS IN THE SOFTWARE.

- * 

- * Except as contained in this notice, the name of the Hewlett-Packard

- * Company shall not be used in advertising or otherwise to promote the

- * sale, use or other dealings in this Software without prior written

- * authorization from the Hewlett-Packard Company.

- * 

- *     Header file for users of machine-independent DBE code

- *

- *****************************************************************************/

-

-#ifdef HAVE_DIX_CONFIG_H

-#include <dix-config.h>

-#endif

-

-#ifndef MIDBE_H

-#define MIDBE_H

-

-#include "privates.h"

-

-/* EXTERNS */

-

-extern Bool miDbeInit(

-    ScreenPtr           pScreen,

-    DbeScreenPrivPtr    pDbeScreenPriv

-);

-

-extern DevPrivateKeyRec dbeScreenPrivKeyRec;

-#define dbeScreenPrivKey (&dbeScreenPrivKeyRec)

-

-extern DevPrivateKeyRec dbeWindowPrivKeyRec;

-#define dbeWindowPrivKey (&dbeWindowPrivKeyRec)

-

-extern RESTYPE	dbeDrawableResType;

-extern RESTYPE	dbeWindowPrivResType;

-

-#endif /* MIDBE_H */

-

+/******************************************************************************
+ * Copyright (c) 1994, 1995  Hewlett-Packard Company
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL HEWLETT-PACKARD COMPANY BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ * Except as contained in this notice, the name of the Hewlett-Packard
+ * Company shall not be used in advertising or otherwise to promote the
+ * sale, use or other dealings in this Software without prior written
+ * authorization from the Hewlett-Packard Company.
+ * 
+ *     Header file for users of machine-independent DBE code
+ *
+ *****************************************************************************/
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#ifndef MIDBE_H
+#define MIDBE_H
+
+#include "privates.h"
+
+/* EXTERNS */
+
+extern Bool miDbeInit(ScreenPtr pScreen, DbeScreenPrivPtr pDbeScreenPriv);
+
+extern DevPrivateKeyRec dbeScreenPrivKeyRec;
+
+#define dbeScreenPrivKey (&dbeScreenPrivKeyRec)
+
+extern DevPrivateKeyRec dbeWindowPrivKeyRec;
+
+#define dbeWindowPrivKey (&dbeWindowPrivKeyRec)
+
+extern RESTYPE dbeDrawableResType;
+extern RESTYPE dbeWindowPrivResType;
+
+#endif                          /* MIDBE_H */
diff --git a/xorg-server/dbe/midbestr.h b/xorg-server/dbe/midbestr.h
index efbe9b28e..70017b045 100644
--- a/xorg-server/dbe/midbestr.h
+++ b/xorg-server/dbe/midbestr.h
@@ -1,79 +1,75 @@
-/******************************************************************************

- * 

- * Copyright (c) 1994, 1995  Hewlett-Packard Company

- *

- * Permission is hereby granted, free of charge, to any person obtaining

- * a copy of this software and associated documentation files (the

- * "Software"), to deal in the Software without restriction, including

- * without limitation the rights to use, copy, modify, merge, publish,

- * distribute, sublicense, and/or sell copies of the Software, and to

- * permit persons to whom the Software is furnished to do so, subject to

- * the following conditions:

- * 

- * The above copyright notice and this permission notice shall be included

- * in all copies or substantial portions of the Software.

- * 

- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

- * IN NO EVENT SHALL HEWLETT-PACKARD COMPANY BE LIABLE FOR ANY CLAIM,

- * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR

- * THE USE OR OTHER DEALINGS IN THE SOFTWARE.

- * 

- * Except as contained in this notice, the name of the Hewlett-Packard

- * Company shall not be used in advertising or otherwise to promote the

- * sale, use or other dealings in this Software without prior written

- * authorization from the Hewlett-Packard Company.

- * 

- *     Header file for users of machine-independent DBE code

- * 

- *****************************************************************************/

-

-

-#ifdef HAVE_DIX_CONFIG_H

-#include <dix-config.h>

-#endif

-

-#ifndef MIDBE_STRUCT_H

-#define MIDBE_STRUCT_H

-

-

-/* DEFINES */

-

-#define MI_DBE_WINDOW_PRIV_PRIV(pDbeWindowPriv) \

-    (!(pDbeWindowPriv) ? NULL : (MiDbeWindowPrivPrivPtr) \

-     dixLookupPrivate(&(pDbeWindowPriv)->devPrivates, miDbeWindowPrivPrivKey))

-

-#define MI_DBE_WINDOW_PRIV_PRIV_FROM_WINDOW(pWin)\

-    MI_DBE_WINDOW_PRIV_PRIV(DBE_WINDOW_PRIV(pWin))

-

-/* TYPEDEFS */

-

-typedef struct _MiDbeWindowPrivPrivRec

-{

-    /* Place machine-specific fields in here.

-     * Since this is mi code, we do not really have machine-specific fields.

-     */

-

-    /* Pointer to a drawable that contains the contents of the back buffer.

-     */

-    PixmapPtr		pBackBuffer;

-

-    /* Pointer to a drawable that contains the contents of the front buffer.

-     * This pointer is only used for the XdbeUntouched swap action.  For that

-     * swap action, we need to copy the front buffer (window) contents into

-     * this drawable, copy the contents of current back buffer drawable (the

-     * back buffer) into the window, swap the front and back drawable pointers,

-     * and then swap the drawable/resource associations in the resource

-     * database.

-     */

-    PixmapPtr		pFrontBuffer;

-

-    /* Pointer back to our window private with which we are associated. */

-    DbeWindowPrivPtr	pDbeWindowPriv;

-

-} MiDbeWindowPrivPrivRec, *MiDbeWindowPrivPrivPtr;

-

-#endif /* MIDBE_STRUCT_H */

-

+/******************************************************************************
+ * 
+ * Copyright (c) 1994, 1995  Hewlett-Packard Company
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL HEWLETT-PACKARD COMPANY BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ * Except as contained in this notice, the name of the Hewlett-Packard
+ * Company shall not be used in advertising or otherwise to promote the
+ * sale, use or other dealings in this Software without prior written
+ * authorization from the Hewlett-Packard Company.
+ * 
+ *     Header file for users of machine-independent DBE code
+ * 
+ *****************************************************************************/
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#ifndef MIDBE_STRUCT_H
+#define MIDBE_STRUCT_H
+
+/* DEFINES */
+
+#define MI_DBE_WINDOW_PRIV_PRIV(pDbeWindowPriv) \
+    (!(pDbeWindowPriv) ? NULL : (MiDbeWindowPrivPrivPtr) \
+     dixLookupPrivate(&(pDbeWindowPriv)->devPrivates, miDbeWindowPrivPrivKey))
+
+#define MI_DBE_WINDOW_PRIV_PRIV_FROM_WINDOW(pWin)\
+    MI_DBE_WINDOW_PRIV_PRIV(DBE_WINDOW_PRIV(pWin))
+
+/* TYPEDEFS */
+
+typedef struct _MiDbeWindowPrivPrivRec {
+    /* Place machine-specific fields in here.
+     * Since this is mi code, we do not really have machine-specific fields.
+     */
+
+    /* Pointer to a drawable that contains the contents of the back buffer.
+     */
+    PixmapPtr pBackBuffer;
+
+    /* Pointer to a drawable that contains the contents of the front buffer.
+     * This pointer is only used for the XdbeUntouched swap action.  For that
+     * swap action, we need to copy the front buffer (window) contents into
+     * this drawable, copy the contents of current back buffer drawable (the
+     * back buffer) into the window, swap the front and back drawable pointers,
+     * and then swap the drawable/resource associations in the resource
+     * database.
+     */
+    PixmapPtr pFrontBuffer;
+
+    /* Pointer back to our window private with which we are associated. */
+    DbeWindowPrivPtr pDbeWindowPriv;
+
+} MiDbeWindowPrivPrivRec, *MiDbeWindowPrivPrivPtr;
+
+#endif                          /* MIDBE_STRUCT_H */