svn merge -r595:HEAD "^/branches/released" .1.8.1

1 files changed, 1677 insertions, 1679 deletions

diff --git a/xorg-server/dbe/dbe.c b/xorg-server/dbe/dbe.c
index a6c1c4f56..a49a46d69 100644
--- a/xorg-server/dbe/dbe.c
+++ b/xorg-server/dbe/dbe.c
@@ -1,1679 +1,1677 @@
-/******************************************************************************

- * 

- * 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.

- * 

- *     DIX DBE code

- *

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

-

-

-/* INCLUDES */

-

-#ifdef HAVE_DIX_CONFIG_H

-#include <dix-config.h>

-#endif

-

-#include <string.h>

-#if HAVE_STDINT_H

-#include <stdint.h>

-#elif !defined(UINT32_MAX)

-#define UINT32_MAX 0xffffffffU

-#endif

-

-#include <X11/X.h>

-#include <X11/Xproto.h>

-#include "scrnintstr.h"

-#include "extnsionst.h"

-#include "gcstruct.h"

-#include "dixstruct.h"

-#define NEED_DBE_PROTOCOL

-#include "dbestruct.h"

-#include "midbe.h"

-#include "xace.h"

-

-/* GLOBALS */

-

-/* These are static globals copied to DBE's screen private for use by DDX */

-static int dbeScreenPrivKeyIndex;

-static DevPrivateKey dbeScreenPrivKey = &dbeScreenPrivKeyIndex;

-static int dbeWindowPrivKeyIndex;

-static DevPrivateKey dbeWindowPrivKey = &dbeWindowPrivKeyIndex;

-

-/* These are static globals copied to DBE's screen private for use by DDX */

-static RESTYPE	dbeDrawableResType;

-static RESTYPE	dbeWindowPrivResType;

-

-/* Used to generate DBE's BadBuffer error. */

-static int	dbeErrorBase;

-

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

- *

- * DBE DIX Procedure: DbeStubScreen

- *

- * Description:

- *

- *     This is function stubs the function pointers in the given DBE screen

- *     private and increments the number of stubbed screens.

- *

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

-

-static void

-DbeStubScreen(DbeScreenPrivPtr pDbeScreenPriv, int *nStubbedScreens)

-{

-    /* Stub DIX. */

-    pDbeScreenPriv->SetupBackgroundPainter = NULL;

-

-    /* Do not unwrap PositionWindow nor DestroyWindow.  If the DDX

-     * initialization function failed, we assume that it did not wrap

-     * PositionWindow.  Also, DestroyWindow is only wrapped if the DDX

-     * initialization function succeeded.

-     */

-

-    /* Stub DDX. */

-    pDbeScreenPriv->GetVisualInfo       = NULL;

-    pDbeScreenPriv->AllocBackBufferName = NULL;

-    pDbeScreenPriv->SwapBuffers         = NULL;

-    pDbeScreenPriv->BeginIdiom          = NULL;

-    pDbeScreenPriv->EndIdiom            = NULL;

-    pDbeScreenPriv->WinPrivDelete       = NULL;

-    pDbeScreenPriv->ResetProc           = NULL;

-

-    (*nStubbedScreens)++;

-

-} /* DbeStubScreen() */

-

-

-

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

- *

- * DBE DIX Procedure: ProcDbeGetVersion

- *

- * Description:

- *

- *     This function is for processing a DbeGetVersion request.

- *     This request returns the major and minor version numbers of this

- *     extension.

- *

- * Return Values:

- *

- *     Success

- *

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

-

-static int

-ProcDbeGetVersion(ClientPtr client)

-{

-    /* REQUEST(xDbeGetVersionReq); */

-    xDbeGetVersionReply	rep;

-    register int	n;

-

-

-    REQUEST_SIZE_MATCH(xDbeGetVersionReq);

-

-    rep.type           = X_Reply;

-    rep.length         = 0;

-    rep.sequenceNumber = client->sequence;

-    rep.majorVersion   = DBE_MAJOR_VERSION;

-    rep.minorVersion   = DBE_MINOR_VERSION;

-

-    if (client->swapped)

-    {

-        swaps(&rep.sequenceNumber, n);

-    }

-

-    WriteToClient(client, sizeof(xDbeGetVersionReply), (char *)&rep);

-

-    return Success;

-

-} /* ProcDbeGetVersion() */

-

-

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

- *

- * DBE DIX Procedure: ProcDbeAllocateBackBufferName

- *

- * Description:

- *

- *     This function is for processing a DbeAllocateBackBufferName request.

- *     This request allocates a drawable ID used to refer to the back buffer

- *     of a window.

- *

- * Return Values:

- *

- *     BadAlloc    - server can not allocate resources

- *     BadIDChoice - id is out of range for client; id is already in use

- *     BadMatch    - window is not an InputOutput window;

- *                   visual of window is not on list returned by

- *                   DBEGetVisualInfo; 

- *     BadValue    - invalid swap action is specified

- *     BadWindow   - window is not a valid window

- *     Success

- *

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

-

-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;

-

-

-    REQUEST_SIZE_MATCH(xDbeAllocateBackBufferNameReq);

-

-    /* The window must be valid. */

-    status = dixLookupWindow(&pWin, stuff->window, client, DixManageAccess);

-    if (status != Success)

-	return status;

-

-    /* The window must be InputOutput. */

-    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 != XdbeBackground) &&

-        (swapAction != XdbeUntouched ) &&

-        (swapAction != XdbeCopied    ))

-    {

-        return(BadValue);

-    }

-

-    /* The id must be in range and not already in use. */

-    LEGAL_NEW_RESOURCE(stuff->buffer, client);

-

-    /* The visual of the window must be in the list returned by

-     * GetVisualInfo.

-     */

-    pDbeScreenPriv = DBE_SCREEN_PRIV_FROM_WINDOW(pWin);

-    if (!pDbeScreenPriv->GetVisualInfo)

-	return(BadMatch); /* screen doesn't support double buffering */

-

-    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;

-	}

-    }

-

-    /* Free what was allocated by the GetVisualInfo() call above. */

-    free(scrVisInfo.visinfo);

-

-    if (!visualMatched)

-    {

-	return(BadMatch);

-    }

-

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

-    {

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

-         * Allocate a window priv.

-         */

-

-        pDbeWindowPriv = calloc(1, sizeof(DbeWindowPrivRec));

-	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;

-

-        /* Set the buffer ID array pointer to the initial (static) array). */

-        pDbeWindowPriv->IDs = pDbeWindowPriv->initIDs;

-

-        /* 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++)

-        {

-            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. */

-

-    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)

-            {

-                /* There is still room in the ID array. */

-                break;

-            }

-        }

- 

-        if (i == pDbeWindowPriv->maxAvailableIDs)

-        {

-            /* No more room in the ID array -- reallocate another array. */

-            XID	*pIDs;

-

-            /* Setup an array pointer for the realloc operation below. */

-            if (pDbeWindowPriv->maxAvailableIDs == DBE_INIT_MAX_IDS)

-            {

-                /* We will malloc a new array. */

-                pIDs = NULL;

-            }

-            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)

-            {

-                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)

-            {

-                /* 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.

-                 */

-                memcpy(pDbeWindowPriv->IDs, pDbeWindowPriv->initIDs,

-                       DBE_INIT_MAX_IDS * sizeof(XID));

-            }

-

-            pDbeWindowPriv->maxAvailableIDs += DBE_INCR_MAX_IDS;

-        }

-

-	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);

-

-    if (status == Success)

-    {

-	pDbeWindowPriv->IDs[add_index] = stuff->buffer;

-        if (!AddResource(stuff->buffer, dbeWindowPrivResType,

-                         (pointer)pDbeWindowPriv))

-	{

-            pDbeWindowPriv->IDs[add_index] = DBE_FREE_ID_ELEMENT;

-

-            if (pDbeWindowPriv->nBufferIDs == 0) {

-                status = BadAlloc;

-                goto out_free;

-            }

-        }

-    } else {

-        /* The DDX buffer allocation routine failed for the first buffer of

-         * this window.

-         */

-        if (pDbeWindowPriv->nBufferIDs == 0) {

-            goto out_free;

-        }

-    }

-

-    /* Increment the number of buffers (XIDs) associated with this window. */

-    pDbeWindowPriv->nBufferIDs++;

-

-    /* Set swap action on all calls. */

-    pDbeWindowPriv->swapAction = stuff->swapAction;

-

-    return(status);

-

-out_free:

-    dixSetPrivate(&pWin->devPrivates, dbeWindowPrivKey, NULL);

-    free(pDbeWindowPriv);

-    return (status);

-

-} /* ProcDbeAllocateBackBufferName() */

-

-

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

- *

- * DBE DIX Procedure: ProcDbeDeallocateBackBufferName

- *

- * Description:

- *

- *     This function is for processing a DbeDeallocateBackBufferName request.

- *     This request frees a drawable ID that was obtained by a

- *     DbeAllocateBackBufferName request.

- *

- * Return Values:

- *

- *     BadBuffer - buffer to deallocate is not associated with a window

- *     Success

- *

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

-

-static int

-ProcDbeDeallocateBackBufferName(ClientPtr client)

-{

-    REQUEST(xDbeDeallocateBackBufferNameReq);

-    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);

-    if (rc != Success)

-	return (rc == BadValue) ? dbeErrorBase + DbeBadBuffer : rc;

-

-    rc = dixLookupResourceByType(&val, stuff->buffer, dbeDrawableResType,

-				 client, DixDestroyAccess);

-    if (rc != Success)

-	return (rc == BadValue) ? dbeErrorBase + DbeBadBuffer : 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++)

-    {

-        /* Loop through the ID list to find the ID. */

-        if (pDbeWindowPriv->IDs[i] == stuff->buffer)

-        {

-            break;

-        }

-    }

-

-    if (i == pDbeWindowPriv->nBufferIDs)

-    {

-        /* We did not find the ID in the ID list. */

-        client->errorValue = stuff->buffer;

-        return(dbeErrorBase + DbeBadBuffer);

-    }

-

-    FreeResource(stuff->buffer, RT_NONE);

-

-    return(Success);

-

-} /* ProcDbeDeallocateBackBufferName() */

-

-

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

- *

- * DBE DIX Procedure: ProcDbeSwapBuffers

- *

- * Description:

- *

- *     This function is for processing a DbeSwapBuffers request.

- *     This request swaps the buffers for all windows listed, applying the

- *     appropriate swap action for each window.

- *

- * Return Values:

- *

- *     BadAlloc  - local allocation failed; this return value is not defined

- *                 by the protocol

- *     BadMatch  - a window in request is not double-buffered; a window in

- *                 request is listed more than once

- *     BadValue  - invalid swap action is specified; no swap action is

- *                 specified

- *     BadWindow - a window in request is not valid

- *     Success

- *

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

-

-static int

-ProcDbeSwapBuffers(ClientPtr client)

-{

-    REQUEST(xDbeSwapBuffersReq);

-    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. */

-

-    if (nStuff == 0)

-    {

-        return(Success);

-    }

-

-    if (nStuff > UINT32_MAX / sizeof(DbeSwapInfoRec))

-	    return BadAlloc;

-

-    /* Get to the swap info appended to the end of the request. */

-    dbeSwapInfo = (xDbeSwapInfo *)&stuff[1];

-

-    /* Allocate array to record swap information. */ 

-    swapInfo = (DbeSwapInfoPtr)malloc(nStuff * sizeof(DbeSwapInfoRec));

-    if (swapInfo == NULL)

-    {

-        return(BadAlloc);

-    }

-

-

-    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) {

-            free(swapInfo);

-	    return error;

-        }

-

-        /* Each window must be double-buffered - BadMatch. */

-        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)

-            {

-                free(swapInfo);

-                return(BadMatch);

-	    }

-        }

-

-        /* Each swap action must be valid - BadValue. */

-        if ((dbeSwapInfo[i].swapAction != XdbeUndefined ) &&

-            (dbeSwapInfo[i].swapAction != XdbeBackground) &&

-            (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++) */

-

-

-    /* 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

-     * handle, delete them from the list, and update nStuff to indicate how

-     * many windows it did not handle.

-     *

-     * This scheme allows a range of sophistication in the DDX SwapBuffers()

-     * implementation.  Naive implementations could just swap the first buffer

-     * in the list, move the last buffer to the front, decrement nStuff, and

-     * return.  The next level of sophistication could be to scan the whole

-     * list for windows on the same screen.  Up another level, the DDX routine

-     * could deal with cross-screen synchronization.

-     */

-

-    while (nStuff > 0)

-    {

-        pDbeScreenPriv = DBE_SCREEN_PRIV_FROM_WINDOW(swapInfo[0].pWindow);

-        error = (*pDbeScreenPriv->SwapBuffers)(client, &nStuff, swapInfo);

-        if (error != Success)

-        {

-            free(swapInfo);

-            return(error);

-        }

-    }

-    

-    free(swapInfo);

-    return(Success);

-

-} /* ProcDbeSwapBuffers() */

-

-

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

- *

- * DBE DIX Procedure: ProcDbeBeginIdiom

- *

- * Description:

- *

- *     This function is for processing a DbeBeginIdiom request.

- *     This request informs the server that a complex swap will immediately

- *     follow this request.

- *

- * Return Values:

- *

- *     Success

- *

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

-

-static int

-ProcDbeBeginIdiom(ClientPtr client)

-{

-    /* REQUEST(xDbeBeginIdiomReq); */

-    DbeScreenPrivPtr	pDbeScreenPriv;

-    register int	i;

-

-

-    REQUEST_SIZE_MATCH(xDbeBeginIdiomReq);

-

-    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);

-        }

-    }

-

-    return(Success);

-

-} /* ProcDbeBeginIdiom() */

-

-

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

- *

- * DBE DIX Procedure: ProcDbeGetVisualInfo

- *

- * Description:

- *

- *     This function is for processing a ProcDbeGetVisualInfo request.

- *     This request returns information about which visuals support

- *     double buffering.

- *

- * Return Values:

- *

- *     BadDrawable - value in screen specifiers is not a valid drawable

- *     Success

- *

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

-

-static int

-ProcDbeGetVisualInfo(ClientPtr client)

-{

-    REQUEST(xDbeGetVisualInfoReq);

-    DbeScreenPrivPtr		pDbeScreenPriv;

-    xDbeGetVisualInfoReply	rep;

-    Drawable			*drawables;

-    DrawablePtr			*pDrawables = NULL;

-    register int		i, j, n, 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;

-    /* Make sure any specified drawables are valid. */

-    if (stuff->n != 0)

-    {

-        if (!(pDrawables = (DrawablePtr *)malloc(stuff->n *

-                                                 sizeof(DrawablePtr))))

-        {

-            return(BadAlloc);

-        }

-

-        drawables = (Drawable *)&stuff[1];

-

-        for (i = 0; i < stuff->n; i++)

-        {

-	    rc = dixLookupDrawable(pDrawables+i, drawables[i], client, 0,

-				   DixGetAttrAccess);

-	    if (rc != Success) {

-                free(pDrawables);

-                return rc;

-            }

-        }

-    }

-

-    count = (stuff->n == 0) ? screenInfo.numScreens : stuff->n;

-    if (!(pScrVisInfo = (XdbeScreenVisualInfo *)malloc(count *

-                        sizeof(XdbeScreenVisualInfo))))

-    {

-        if (pDrawables)

-        {

-            free(pDrawables);

-        }

-

-        return(BadAlloc);

-    }

-

-    length = 0;

-

-    for (i = 0; i < count; i++)

-    {

-        pScreen = (stuff->n == 0) ? screenInfo.screens[i] :

-                                    pDrawables[i]->pScreen;

-        pDbeScreenPriv = DBE_SCREEN_PRIV(pScreen);

-

-	rc = XaceHook(XACE_SCREEN_ACCESS, client, pScreen, DixGetAttrAccess);

-	if ((rc != Success) ||

-	    !(*pDbeScreenPriv->GetVisualInfo)(pScreen, &pScrVisInfo[i]))

-        {

-            /* We failed to alloc pScrVisInfo[i].visinfo. */

-

-            /* Free visinfos that we allocated for previous screen infos.*/

-            for (j = 0; j < i; j++)

-            {

-                free(pScrVisInfo[j].visinfo);

-            }

-

-            /* Free pDrawables if we needed to allocate it above. */

-            if (pDrawables)

-            {

-                free(pDrawables);

-            }

-

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

-        }

-

-        /* Account for n, number of xDbeVisInfo items in list. */

-        length += sizeof(CARD32);

-

-        /* Account for n xDbeVisInfo items */

-        length += pScrVisInfo[i].count * sizeof(xDbeVisInfo);

-    }

-

-    rep.type           = X_Reply;

-    rep.sequenceNumber = client->sequence;

-    rep.length         = bytes_to_int32(length);

-    rep.m              = count;

-

-    if (client->swapped)

-    {

-        swaps(&rep.sequenceNumber, n);

-        swapl(&rep.length, n);

-        swapl(&rep.m, n);

-    }

-

-    /* Send off reply. */

-    WriteToClient(client, sizeof(xDbeGetVisualInfoReply), (char *)&rep);

-

-    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;

-

-        if (client->swapped)

-        {

-            swapl(&data32, n);

-        }

-

-        WriteToClient(client, sizeof(CARD32), (char *)&data32);

-

-        /* Now send off visual info items. */

-        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.perfLevel = (CARD8) pScrVisInfo[i].visinfo[j].perflevel;

-

-            if (client->swapped)

-            {

-                swapl(&visInfo.visualID, n);

-

-                /* We do not need to swap depth and perfLevel since they are

-                 * already 1 byte quantities.

-                 */

-            }

-

-            /* Write visualID(32), depth(8), perfLevel(8), and pad(16). */

-            WriteToClient(client, 2*sizeof(CARD32), (char *)&visInfo.visualID);

-        }

-    }

-

-    /* Clean up memory. */

-    for (i = 0; i < count; i++)

-    {

-        free(pScrVisInfo[i].visinfo);

-    }

-    free(pScrVisInfo);

-

-    if (pDrawables)

-    {

-        free(pDrawables);

-    }

-

-    return Success;

-

-} /* ProcDbeGetVisualInfo() */

-

-

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

- *

- * DBE DIX Procedure: ProcDbeGetbackBufferAttributes

- *

- * Description:

- *

- *     This function is for processing a ProcDbeGetbackBufferAttributes

- *     request.  This request returns information about a back buffer.

- *

- * Return Values:

- *

- *     Success

- *

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

-

-static int

-ProcDbeGetBackBufferAttributes(ClientPtr client)

-{

-    REQUEST(xDbeGetBackBufferAttributesReq);

-    xDbeGetBackBufferAttributesReply	rep;

-    DbeWindowPrivPtr			pDbeWindowPriv;

-    int					rc, n;

-

-

-    REQUEST_SIZE_MATCH(xDbeGetBackBufferAttributesReq);

-

-    rc = dixLookupResourceByType((pointer *)&pDbeWindowPriv, stuff->buffer,

-				 dbeWindowPrivResType, client,

-				 DixGetAttrAccess);

-    if (rc == Success)

-    {

-        rep.attributes = pDbeWindowPriv->pWindow->drawable.id;

-    }

-    else

-    {

-        rep.attributes = None;

-    }

-        

-    rep.type           = X_Reply;

-    rep.sequenceNumber = client->sequence;

-    rep.length         = 0;

-    

-    if (client->swapped)

-    {

-        swaps(&rep.sequenceNumber, n);

-        swapl(&rep.length, n);

-        swapl(&rep.attributes, n);

-    }

-

-    WriteToClient(client, sizeof(xDbeGetBackBufferAttributesReply),

-                  (char *)&rep);

-    return Success;

-

-} /* ProcDbeGetbackBufferAttributes() */

-

-

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

- *

- * DBE DIX Procedure: ProcDbeDispatch

- *

- * Description:

- *

- *     This function dispatches DBE requests.

- *

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

-

-static int

-ProcDbeDispatch(ClientPtr client)

-{

-    REQUEST(xReq);

-

-

-    switch (stuff->data)

-    {

-        case X_DbeGetVersion:

-            return(ProcDbeGetVersion(client));

-

-        case X_DbeAllocateBackBufferName:

-            return(ProcDbeAllocateBackBufferName(client));

-

-        case X_DbeDeallocateBackBufferName:

-            return(ProcDbeDeallocateBackBufferName(client));

-

-        case X_DbeSwapBuffers:

-            return(ProcDbeSwapBuffers(client));

-

-        case X_DbeBeginIdiom:

-            return(ProcDbeBeginIdiom(client));

-

-        case X_DbeEndIdiom:

-            return(Success);

-

-        case X_DbeGetVisualInfo:

-            return(ProcDbeGetVisualInfo(client));

-

-        case X_DbeGetBackBufferAttributes:

-            return(ProcDbeGetBackBufferAttributes(client));

-

-        default:

-            return(BadRequest);

-    }

-

-} /* ProcDbeDispatch() */

-

-

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

- *

- * DBE DIX Procedure: SProcDbeGetVersion

- *

- * Description:

- *

- *     This function is for processing a DbeGetVersion request on a swapped

- *     server.  This request returns the major and minor version numbers of

- *     this extension.

- *

- * Return Values:

- *

- *     Success

- *

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

-

-static int

-SProcDbeGetVersion(ClientPtr client)

-{

-    REQUEST(xDbeGetVersionReq);

-    register int	n;

-

-

-    swaps(&stuff->length, n);

-    return(ProcDbeGetVersion(client));

-

-} /* SProcDbeGetVersion() */

-

-

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

- *

- * DBE DIX Procedure: SProcDbeAllocateBackBufferName

- *

- * Description:

- *

- *     This function is for processing a DbeAllocateBackBufferName request on

- *     a swapped server.  This request allocates a drawable ID used to refer

- *     to the back buffer of a window.

- *

- * Return Values:

- *

- *     BadAlloc    - server can not allocate resources

- *     BadIDChoice - id is out of range for client; id is already in use

- *     BadMatch    - window is not an InputOutput window;

- *                   visual of window is not on list returned by

- *                   DBEGetVisualInfo; 

- *     BadValue    - invalid swap action is specified

- *     BadWindow   - window is not a valid window

- *     Success

- *

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

-

-static int

-SProcDbeAllocateBackBufferName(ClientPtr client)

-{

-    REQUEST(xDbeAllocateBackBufferNameReq);

-    register int	n;

-

-    swaps(&stuff->length, n);

-    REQUEST_SIZE_MATCH(xDbeAllocateBackBufferNameReq);

-

-    swapl(&stuff->window, n);

-    swapl(&stuff->buffer, n);

-    /* stuff->swapAction is a byte.  We do not need to swap this field. */

-

-    return(ProcDbeAllocateBackBufferName(client));

-

-} /* SProcDbeAllocateBackBufferName() */

-

-

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

- *

- * DBE DIX Procedure: SProcDbeDeallocateBackBufferName

- *

- * Description:

- *

- *     This function is for processing a DbeDeallocateBackBufferName request

- *     on a swapped server.  This request frees a drawable ID that was

- *     obtained by a DbeAllocateBackBufferName request.

- *

- * Return Values:

- *

- *     BadBuffer - buffer to deallocate is not associated with a window

- *     Success

- *

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

-

-static int

-SProcDbeDeallocateBackBufferName(ClientPtr client)

-{

-    REQUEST (xDbeDeallocateBackBufferNameReq);

-    register int	n;

-

-

-    swaps(&stuff->length, n);

-    REQUEST_SIZE_MATCH(xDbeDeallocateBackBufferNameReq);

-

-    swapl(&stuff->buffer, n);

-

-    return(ProcDbeDeallocateBackBufferName(client));

-

-} /* SProcDbeDeallocateBackBufferName() */

-

-

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

- *

- * DBE DIX Procedure: SProcDbeSwapBuffers

- *

- * Description:

- *

- *     This function is for processing a DbeSwapBuffers request on a swapped

- *     server.  This request swaps the buffers for all windows listed,

- *     applying the appropriate swap action for each window.

- *

- * Return Values:

- *

- *     BadMatch  - a window in request is not double-buffered; a window in

- *                 request is listed more than once; all windows in request do

- *                 not have the same root

- *     BadValue  - invalid swap action is specified

- *     BadWindow - a window in request is not valid

- *     Success

- *

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

-

-static int

-SProcDbeSwapBuffers(ClientPtr client)

-{

-    REQUEST(xDbeSwapBuffersReq);

-    register int	i, n;

-    xDbeSwapInfo	*pSwapInfo;

-

-

-    swaps(&stuff->length, n);

-    REQUEST_AT_LEAST_SIZE(xDbeSwapBuffersReq);

-

-    swapl(&stuff->n, n);

-

-    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++)

-        {

-            swapl(&pSwapInfo->window, n);

-        }

-    }

-

-    return(ProcDbeSwapBuffers(client));

-

-} /* SProcDbeSwapBuffers() */

-

-

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

- *

- * DBE DIX Procedure: SProcDbeBeginIdiom

- *

- * Description:

- *

- *     This function is for processing a DbeBeginIdiom request on a swapped

- *     server.  This request informs the server that a complex swap will

- *     immediately follow this request.

- *

- * Return Values:

- *

- *     Success

- *

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

-

-static int

-SProcDbeBeginIdiom(ClientPtr client)

-{

-    REQUEST(xDbeBeginIdiomReq);

-    register int	n;

-

-    swaps(&stuff->length, n);

-    return(ProcDbeBeginIdiom(client));

-

-} /* SProcDbeBeginIdiom() */

-

-

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

- *

- * DBE DIX Procedure: SProcDbeGetVisualInfo

- *

- * Description:

- *

- *     This function is for processing a ProcDbeGetVisualInfo request on a

- *     swapped server.  This request returns information about which visuals

- *     support double buffering.

- *

- * Return Values:

- *

- *     BadDrawable - value in screen specifiers is not a valid drawable

- *     Success

- *

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

-

-static int

-SProcDbeGetVisualInfo(ClientPtr client)

-{

-    REQUEST(xDbeGetVisualInfoReq);

-    register int	n;

-

-

-    swaps(&stuff->length, n);

-    REQUEST_AT_LEAST_SIZE(xDbeGetVisualInfoReq);

-

-    swapl(&stuff->n, n);

-    SwapRestL(stuff);

-

-    return(ProcDbeGetVisualInfo(client));

-

-} /* SProcDbeGetVisualInfo() */

-

-

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

- *

- * DBE DIX Procedure: SProcDbeGetbackBufferAttributes

- *

- * Description:

- *

- *     This function is for processing a ProcDbeGetbackBufferAttributes

- *     request on a swapped server.  This request returns information about a

- *     back buffer.

- *

- * Return Values:

- *

- *     Success

- *

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

-

-static int

-SProcDbeGetBackBufferAttributes(ClientPtr client)

-{

-    REQUEST (xDbeGetBackBufferAttributesReq);

-    register int	n;

-

-    swaps(&stuff->length, n);

-    REQUEST_SIZE_MATCH(xDbeGetBackBufferAttributesReq);

-

-    swapl(&stuff->buffer, n);

-

-    return(ProcDbeGetBackBufferAttributes(client));

-

-} /* SProcDbeGetBackBufferAttributes() */

-

-

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

- *

- * DBE DIX Procedure: SProcDbeDispatch

- *

- * Description:

- *

- *     This function dispatches DBE requests on a swapped server.

- *

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

-

-static int

-SProcDbeDispatch(ClientPtr client)

-{

-    REQUEST(xReq);

-

-

-    switch (stuff->data)

-    {

-        case X_DbeGetVersion:

-            return(SProcDbeGetVersion(client));

-

-        case X_DbeAllocateBackBufferName:

-            return(SProcDbeAllocateBackBufferName(client));

-

-        case X_DbeDeallocateBackBufferName:

-            return(SProcDbeDeallocateBackBufferName(client));

-

-        case X_DbeSwapBuffers:

-            return(SProcDbeSwapBuffers(client));

-

-        case X_DbeBeginIdiom:

-            return(SProcDbeBeginIdiom(client));

-

-        case X_DbeEndIdiom:

-            return(Success);

-

-        case X_DbeGetVisualInfo:

-            return(SProcDbeGetVisualInfo(client));

-

-        case X_DbeGetBackBufferAttributes:

-            return(SProcDbeGetBackBufferAttributes(client));

-

-        default:

-            return (BadRequest);

-    }

-

-} /* SProcDbeDispatch() */

-

-

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

- *

- * DBE DIX Procedure: DbeSetupBackgroundPainter

- *

- * Description:

- *

- *     This function sets up pGC to clear pixmaps.

- *

- * Return Values:

- *

- *     TRUE  - setup was successful

- *     FALSE - the window's background state is NONE

- * 

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

-

-static Bool

-DbeSetupBackgroundPainter(WindowPtr pWin, GCPtr pGC)

-{

-    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

-     * corner of the first ancestor without a ParentRelative background.

-     * This coordinate is, of course, negative.

-     */

-    ts_x_origin = ts_y_origin = 0;

-    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);

-    }

-

-    return ChangeGC(NullClient, pGC, gcmask, gcvalues) == 0;

-} /* DbeSetupBackgroundPainter() */

-

-

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

- *

- * DBE DIX Procedure: DbeDrawableDelete

- *

- * Description:

- *

- *     This is the resource delete function for dbeDrawableResType.

- *     It is registered when the drawable resource type is created in

- *     DbeExtensionInit().

- *

- *     To make resource deletion simple, we do not do anything in this function

- *     and leave all resource deleteion to DbeWindowPrivDelete(), which will

- *     eventually be called or already has been called.  Deletion functions are

- *     not guaranteed to be called in any particular order.

- *

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

-static int

-DbeDrawableDelete(pointer pDrawable, XID id)

-{

-    return(Success);

-

-} /* DbeDrawableDelete() */

-

-

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

- *

- * DBE DIX Procedure: DbeWindowPrivDelete

- *

- * Description:

- *

- *     This is the resource delete function for dbeWindowPrivResType.

- *     It is registered when the drawable resource type is created in

- *     DbeExtensionInit().

- *

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

-static int

-DbeWindowPrivDelete(pointer pDbeWinPriv, XID id)

-{

-    DbeScreenPrivPtr	pDbeScreenPriv;

-    DbeWindowPrivPtr	pDbeWindowPriv = (DbeWindowPrivPtr)pDbeWinPriv;

-    int			i;

-

-

-    /*

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

-     ** Remove the buffer ID from the ID array.

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

-     */

-

-    /* Find the ID in the ID array. */

-    i = 0;

-    while ((i < pDbeWindowPriv->nBufferIDs) && (pDbeWindowPriv->IDs[i] != id))

-    {

-        i++;

-    }

-

-    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))

-    {

-        /* 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));

-    }

-    else

-    {

-        /* We are removing the last ID in the array, in which case, the

-         * assignement below is all that we need to do.

-         */

-    }

-    pDbeWindowPriv->IDs[pDbeWindowPriv->nBufferIDs - 1] = DBE_FREE_ID_ELEMENT;

-

-    pDbeWindowPriv->nBufferIDs--;

-

-    /* If an extended array was allocated, then check to see if the remaining

-     * buffer IDs will fit in the static array.

-     */

-

-    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));

-

-        /* Free the extended array; use the static array. */

-        free(pDbeWindowPriv->IDs);

-        pDbeWindowPriv->IDs = pDbeWindowPriv->initIDs;

-        pDbeWindowPriv->maxAvailableIDs = DBE_INIT_MAX_IDS;

-    }

-

-

-    /*

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

-     ** Perform DDX level tasks.

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

-     */

-

-    pDbeScreenPriv = DBE_SCREEN_PRIV_FROM_WINDOW_PRIV(

-                         (DbeWindowPrivPtr)pDbeWindowPriv);

-    (*pDbeScreenPriv->WinPrivDelete)((DbeWindowPrivPtr)pDbeWindowPriv, id);

-

-

-    /*

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

-     ** Perform miscellaneous tasks if this is the last buffer associated

-     ** with the window.

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

-     */

-

-    if (pDbeWindowPriv->nBufferIDs == 0)

-    {

-        /* Reset the DBE window priv pointer. */

-	dixSetPrivate(&pDbeWindowPriv->pWindow->devPrivates, dbeWindowPrivKey,

-		      NULL);

-

-        /* We are done with the window priv. */

-	dixFreePrivates(pDbeWindowPriv->devPrivates);

-        free(pDbeWindowPriv);

-    }

-

-    return(Success);

-

-} /* DbeWindowPrivDelete() */

-

-

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

- *

- * DBE DIX Procedure: DbeResetProc

- *

- * Description:

- *

- *     This routine is called at the end of every server generation.

- *     It deallocates any memory reserved for the extension and performs any

- *     other tasks related to shutting down the extension.

- *

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

-static void

-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().*/

-            pScreen->DestroyWindow = pDbeScreenPriv->DestroyWindow;

-

-	    if (pDbeScreenPriv->ResetProc)

-		(*pDbeScreenPriv->ResetProc)(pScreen);

-

-	    dixFreePrivates(pDbeScreenPriv->devPrivates);

-	    free(pDbeScreenPriv);

-	}

-    }

-} /* DbeResetProc() */

-

-

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

- *

- * DBE DIX Procedure: DbeDestroyWindow

- *

- * Description:

- *

- *     This is the wrapper for pScreen->DestroyWindow.

- *     This function frees buffer resources for a window before it is

- *     destroyed.

- *

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

-

-static Bool

-DbeDestroyWindow(WindowPtr pWin)

-{

-    DbeScreenPrivPtr	pDbeScreenPriv;

-    DbeWindowPrivPtr	pDbeWindowPriv;

-    ScreenPtr		pScreen;

-    Bool		ret;

-

-

-    /*

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

-     ** 1. Unwrap the member routine.

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

-     */

-

-    pScreen                = pWin->drawable.pScreen;

-    pDbeScreenPriv         = DBE_SCREEN_PRIV(pScreen);

-    pScreen->DestroyWindow = pDbeScreenPriv->DestroyWindow;

-

-    /*

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

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

-     **

-     **    Call the window priv delete function for all buffer IDs associated

-     **    with this window.

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

-     */

-

-    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.

-             */

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

-            pDbeWindowPriv = DBE_WINDOW_PRIV(pWin);

-        }

-    }

-

-    /*

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

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

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

-     */

-

-    ret = (*pScreen->DestroyWindow)(pWin);

-

-    /*

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

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

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

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

-     */

-

-    pDbeScreenPriv->DestroyWindow = pScreen->DestroyWindow;

-    pScreen->DestroyWindow = DbeDestroyWindow;

-

-    /*

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

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

-     **

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

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

-     */

-

-    return(ret);

-

-} /* DbeDestroyWindow() */

-

-

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

- *

- * DBE DIX Procedure: DbeExtensionInit

- *

- * Description:

- *

- *     Called from InitExtensions in main()

- *

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

-

-void

-DbeExtensionInit(void)

-{

-    ExtensionEntry	*extEntry;

-    register int	i, j;

-    ScreenPtr		pScreen = NULL;

-    DbeScreenPrivPtr	pDbeScreenPriv;

-    int			nStubbedScreens = 0;

-    Bool		ddxInitSuccess;

-

-#ifdef PANORAMIX

-    if(!noPanoramiXExtension) return;

-#endif

-

-    /* Create the resource types. */

-    dbeDrawableResType =

-        CreateNewResourceType(DbeDrawableDelete, "dbeDrawable");

-    if (!dbeDrawableResType)

-	return;

-    dbeDrawableResType |= RC_DRAWABLE;

-

-    dbeWindowPrivResType =

-        CreateNewResourceType(DbeWindowPrivDelete, "dbeWindow");

-    if (!dbeWindowPrivResType)

-	return;

-

-    if (!dixRegisterPrivateOffset(dbeDrawableResType,

-				  offsetof(PixmapRec, devPrivates)))

-	return;

-

-    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];

-

-	if (!(pDbeScreenPriv =

-              (DbeScreenPrivPtr)calloc(1, 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;

-	}

-

-	dixSetPrivate(&pScreen->devPrivates, dbeScreenPrivKey, pDbeScreenPriv);

-

-        /* Copy the resource types */

-        pDbeScreenPriv->dbeDrawableResType   = dbeDrawableResType;

-        pDbeScreenPriv->dbeWindowPrivResType = dbeWindowPrivResType;

-

-        /* Copy the private indices */

-        pDbeScreenPriv->dbeScreenPrivKey = dbeScreenPrivKey;

-        pDbeScreenPriv->dbeWindowPrivKey = dbeWindowPrivKey;

-

-        {

-            /* We don't have DDX support for DBE anymore */

-

-#ifndef DISABLE_MI_DBE_BY_DEFAULT

-            /* Setup DIX. */

-            pDbeScreenPriv->SetupBackgroundPainter = DbeSetupBackgroundPainter; 

-

-            /* Setup DDX. */

-            ddxInitSuccess = miDbeInit(pScreen, pDbeScreenPriv);

-

-            /* DDX DBE initialization may have the side affect of

-             * reallocating pDbeScreenPriv, so we need to update it.

-             */

-            pDbeScreenPriv = DBE_SCREEN_PRIV(pScreen);

-

-            if (ddxInitSuccess)

-            {

-                /* Wrap DestroyWindow.  The DDX initialization function

-                 * already wrapped PositionWindow for us.

-                 */

-

-                pDbeScreenPriv->DestroyWindow = pScreen->DestroyWindow;

-                pScreen->DestroyWindow        = DbeDestroyWindow;

-            }

-            else

-            {

-                /* DDX initialization failed.  Stub the screen. */

-                DbeStubScreen(pDbeScreenPriv, &nStubbedScreens);

-            }

-#else

-            DbeStubScreen(pDbeScreenPriv, &nStubbedScreens);

-#endif

-

-        }

-

-    } /* for (i = 0; i < screenInfo.numScreens; i++) */

-

-

-    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);

-        }

-        return;

-    }

-

-

-    /* Now add the extension. */

-    extEntry = AddExtension(DBE_PROTOCOL_NAME, DbeNumberEvents, 

-                            DbeNumberErrors, ProcDbeDispatch, SProcDbeDispatch,

-                            DbeResetProc, StandardMinorOpcode);

-

-    dbeErrorBase = extEntry->errorBase;

-

-} /* DbeExtensionInit() */

-

+/******************************************************************************
+ * 
+ * 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.
+ * 
+ *     DIX DBE code
+ *
+ *****************************************************************************/
+
+
+/* INCLUDES */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <string.h>
+#if HAVE_STDINT_H
+#include <stdint.h>
+#elif !defined(UINT32_MAX)
+#define UINT32_MAX 0xffffffffU
+#endif
+
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#include "scrnintstr.h"
+#include "extnsionst.h"
+#include "gcstruct.h"
+#include "dixstruct.h"
+#define NEED_DBE_PROTOCOL
+#include "dbestruct.h"
+#include "midbe.h"
+#include "xace.h"
+
+/* GLOBALS */
+
+/* These are static globals copied to DBE's screen private for use by DDX */
+static int dbeScreenPrivKeyIndex;
+static DevPrivateKey dbeScreenPrivKey = &dbeScreenPrivKeyIndex;
+static int dbeWindowPrivKeyIndex;
+static DevPrivateKey dbeWindowPrivKey = &dbeWindowPrivKeyIndex;
+
+/* These are static globals copied to DBE's screen private for use by DDX */
+static RESTYPE	dbeDrawableResType;
+static RESTYPE	dbeWindowPrivResType;
+
+/* Used to generate DBE's BadBuffer error. */
+static int	dbeErrorBase;
+
+/******************************************************************************
+ *
+ * DBE DIX Procedure: DbeStubScreen
+ *
+ * Description:
+ *
+ *     This is function stubs the function pointers in the given DBE screen
+ *     private and increments the number of stubbed screens.
+ *
+ *****************************************************************************/
+
+static void
+DbeStubScreen(DbeScreenPrivPtr pDbeScreenPriv, int *nStubbedScreens)
+{
+    /* Stub DIX. */
+    pDbeScreenPriv->SetupBackgroundPainter = NULL;
+
+    /* Do not unwrap PositionWindow nor DestroyWindow.  If the DDX
+     * initialization function failed, we assume that it did not wrap
+     * PositionWindow.  Also, DestroyWindow is only wrapped if the DDX
+     * initialization function succeeded.
+     */
+
+    /* Stub DDX. */
+    pDbeScreenPriv->GetVisualInfo       = NULL;
+    pDbeScreenPriv->AllocBackBufferName = NULL;
+    pDbeScreenPriv->SwapBuffers         = NULL;
+    pDbeScreenPriv->BeginIdiom          = NULL;
+    pDbeScreenPriv->EndIdiom            = NULL;
+    pDbeScreenPriv->WinPrivDelete       = NULL;
+    pDbeScreenPriv->ResetProc           = NULL;
+
+    (*nStubbedScreens)++;
+
+} /* DbeStubScreen() */
+
+
+
+/******************************************************************************
+ *
+ * DBE DIX Procedure: ProcDbeGetVersion
+ *
+ * Description:
+ *
+ *     This function is for processing a DbeGetVersion request.
+ *     This request returns the major and minor version numbers of this
+ *     extension.
+ *
+ * Return Values:
+ *
+ *     Success
+ *
+ *****************************************************************************/
+
+static int
+ProcDbeGetVersion(ClientPtr client)
+{
+    /* REQUEST(xDbeGetVersionReq); */
+    xDbeGetVersionReply	rep;
+    register int	n;
+
+
+    REQUEST_SIZE_MATCH(xDbeGetVersionReq);
+
+    rep.type           = X_Reply;
+    rep.length         = 0;
+    rep.sequenceNumber = client->sequence;
+    rep.majorVersion   = DBE_MAJOR_VERSION;
+    rep.minorVersion   = DBE_MINOR_VERSION;
+
+    if (client->swapped)
+    {
+        swaps(&rep.sequenceNumber, n);
+    }
+
+    WriteToClient(client, sizeof(xDbeGetVersionReply), (char *)&rep);
+
+    return Success;
+
+} /* ProcDbeGetVersion() */
+
+
+/******************************************************************************
+ *
+ * DBE DIX Procedure: ProcDbeAllocateBackBufferName
+ *
+ * Description:
+ *
+ *     This function is for processing a DbeAllocateBackBufferName request.
+ *     This request allocates a drawable ID used to refer to the back buffer
+ *     of a window.
+ *
+ * Return Values:
+ *
+ *     BadAlloc    - server can not allocate resources
+ *     BadIDChoice - id is out of range for client; id is already in use
+ *     BadMatch    - window is not an InputOutput window;
+ *                   visual of window is not on list returned by
+ *                   DBEGetVisualInfo; 
+ *     BadValue    - invalid swap action is specified
+ *     BadWindow   - window is not a valid window
+ *     Success
+ *
+ *****************************************************************************/
+
+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;
+
+
+    REQUEST_SIZE_MATCH(xDbeAllocateBackBufferNameReq);
+
+    /* The window must be valid. */
+    status = dixLookupWindow(&pWin, stuff->window, client, DixManageAccess);
+    if (status != Success)
+	return status;
+
+    /* The window must be InputOutput. */
+    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 != XdbeBackground) &&
+        (swapAction != XdbeUntouched ) &&
+        (swapAction != XdbeCopied    ))
+    {
+        return(BadValue);
+    }
+
+    /* The id must be in range and not already in use. */
+    LEGAL_NEW_RESOURCE(stuff->buffer, client);
+
+    /* The visual of the window must be in the list returned by
+     * GetVisualInfo.
+     */
+    pDbeScreenPriv = DBE_SCREEN_PRIV_FROM_WINDOW(pWin);
+    if (!pDbeScreenPriv->GetVisualInfo)
+	return(BadMatch); /* screen doesn't support double buffering */
+
+    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;
+	}
+    }
+
+    /* Free what was allocated by the GetVisualInfo() call above. */
+    free(scrVisInfo.visinfo);
+
+    if (!visualMatched)
+    {
+	return(BadMatch);
+    }
+
+    if ((pDbeWindowPriv = DBE_WINDOW_PRIV(pWin)) == NULL)
+    {
+        /* There is no buffer associated with the window.
+         * Allocate a window priv.
+         */
+
+        pDbeWindowPriv = calloc(1, sizeof(DbeWindowPrivRec));
+	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;
+
+        /* Set the buffer ID array pointer to the initial (static) array). */
+        pDbeWindowPriv->IDs = pDbeWindowPriv->initIDs;
+
+        /* 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++)
+        {
+            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. */
+
+    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)
+            {
+                /* There is still room in the ID array. */
+                break;
+            }
+        }
+ 
+        if (i == pDbeWindowPriv->maxAvailableIDs)
+        {
+            /* No more room in the ID array -- reallocate another array. */
+            XID	*pIDs;
+
+            /* Setup an array pointer for the realloc operation below. */
+            if (pDbeWindowPriv->maxAvailableIDs == DBE_INIT_MAX_IDS)
+            {
+                /* We will malloc a new array. */
+                pIDs = NULL;
+            }
+            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)
+            {
+                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)
+            {
+                /* 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.
+                 */
+                memcpy(pDbeWindowPriv->IDs, pDbeWindowPriv->initIDs,
+                       DBE_INIT_MAX_IDS * sizeof(XID));
+            }
+
+            pDbeWindowPriv->maxAvailableIDs += DBE_INCR_MAX_IDS;
+        }
+
+	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);
+
+    if (status == Success)
+    {
+	pDbeWindowPriv->IDs[add_index] = stuff->buffer;
+        if (!AddResource(stuff->buffer, dbeWindowPrivResType,
+                         (pointer)pDbeWindowPriv))
+	{
+            pDbeWindowPriv->IDs[add_index] = DBE_FREE_ID_ELEMENT;
+
+            if (pDbeWindowPriv->nBufferIDs == 0) {
+                status = BadAlloc;
+                goto out_free;
+            }
+        }
+    } else {
+        /* The DDX buffer allocation routine failed for the first buffer of
+         * this window.
+         */
+        if (pDbeWindowPriv->nBufferIDs == 0) {
+            goto out_free;
+        }
+    }
+
+    /* Increment the number of buffers (XIDs) associated with this window. */
+    pDbeWindowPriv->nBufferIDs++;
+
+    /* Set swap action on all calls. */
+    pDbeWindowPriv->swapAction = stuff->swapAction;
+
+    return(status);
+
+out_free:
+    dixSetPrivate(&pWin->devPrivates, dbeWindowPrivKey, NULL);
+    free(pDbeWindowPriv);
+    return (status);
+
+} /* ProcDbeAllocateBackBufferName() */
+
+
+/******************************************************************************
+ *
+ * DBE DIX Procedure: ProcDbeDeallocateBackBufferName
+ *
+ * Description:
+ *
+ *     This function is for processing a DbeDeallocateBackBufferName request.
+ *     This request frees a drawable ID that was obtained by a
+ *     DbeAllocateBackBufferName request.
+ *
+ * Return Values:
+ *
+ *     BadBuffer - buffer to deallocate is not associated with a window
+ *     Success
+ *
+ *****************************************************************************/
+
+static int
+ProcDbeDeallocateBackBufferName(ClientPtr client)
+{
+    REQUEST(xDbeDeallocateBackBufferNameReq);
+    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);
+    if (rc != Success)
+	return (rc == BadValue) ? dbeErrorBase + DbeBadBuffer : rc;
+
+    rc = dixLookupResourceByType(&val, stuff->buffer, dbeDrawableResType,
+				 client, DixDestroyAccess);
+    if (rc != Success)
+	return (rc == BadValue) ? dbeErrorBase + DbeBadBuffer : 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++)
+    {
+        /* Loop through the ID list to find the ID. */
+        if (pDbeWindowPriv->IDs[i] == stuff->buffer)
+        {
+            break;
+        }
+    }
+
+    if (i == pDbeWindowPriv->nBufferIDs)
+    {
+        /* We did not find the ID in the ID list. */
+        client->errorValue = stuff->buffer;
+        return(dbeErrorBase + DbeBadBuffer);
+    }
+
+    FreeResource(stuff->buffer, RT_NONE);
+
+    return(Success);
+
+} /* ProcDbeDeallocateBackBufferName() */
+
+
+/******************************************************************************
+ *
+ * DBE DIX Procedure: ProcDbeSwapBuffers
+ *
+ * Description:
+ *
+ *     This function is for processing a DbeSwapBuffers request.
+ *     This request swaps the buffers for all windows listed, applying the
+ *     appropriate swap action for each window.
+ *
+ * Return Values:
+ *
+ *     BadAlloc  - local allocation failed; this return value is not defined
+ *                 by the protocol
+ *     BadMatch  - a window in request is not double-buffered; a window in
+ *                 request is listed more than once
+ *     BadValue  - invalid swap action is specified; no swap action is
+ *                 specified
+ *     BadWindow - a window in request is not valid
+ *     Success
+ *
+ *****************************************************************************/
+
+static int
+ProcDbeSwapBuffers(ClientPtr client)
+{
+    REQUEST(xDbeSwapBuffersReq);
+    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. */
+
+    if (nStuff == 0)
+    {
+        return(Success);
+    }
+
+    if (nStuff > UINT32_MAX / sizeof(DbeSwapInfoRec))
+	    return BadAlloc;
+
+    /* Get to the swap info appended to the end of the request. */
+    dbeSwapInfo = (xDbeSwapInfo *)&stuff[1];
+
+    /* Allocate array to record swap information. */ 
+    swapInfo = (DbeSwapInfoPtr)malloc(nStuff * sizeof(DbeSwapInfoRec));
+    if (swapInfo == NULL)
+    {
+        return(BadAlloc);
+    }
+
+
+    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) {
+            free(swapInfo);
+	    return error;
+        }
+
+        /* Each window must be double-buffered - BadMatch. */
+        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)
+            {
+                free(swapInfo);
+                return(BadMatch);
+	    }
+        }
+
+        /* Each swap action must be valid - BadValue. */
+        if ((dbeSwapInfo[i].swapAction != XdbeUndefined ) &&
+            (dbeSwapInfo[i].swapAction != XdbeBackground) &&
+            (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++) */
+
+
+    /* 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
+     * handle, delete them from the list, and update nStuff to indicate how
+     * many windows it did not handle.
+     *
+     * This scheme allows a range of sophistication in the DDX SwapBuffers()
+     * implementation.  Naive implementations could just swap the first buffer
+     * in the list, move the last buffer to the front, decrement nStuff, and
+     * return.  The next level of sophistication could be to scan the whole
+     * list for windows on the same screen.  Up another level, the DDX routine
+     * could deal with cross-screen synchronization.
+     */
+
+    while (nStuff > 0)
+    {
+        pDbeScreenPriv = DBE_SCREEN_PRIV_FROM_WINDOW(swapInfo[0].pWindow);
+        error = (*pDbeScreenPriv->SwapBuffers)(client, &nStuff, swapInfo);
+        if (error != Success)
+        {
+            free(swapInfo);
+            return(error);
+        }
+    }
+    
+    free(swapInfo);
+    return(Success);
+
+} /* ProcDbeSwapBuffers() */
+
+
+/******************************************************************************
+ *
+ * DBE DIX Procedure: ProcDbeBeginIdiom
+ *
+ * Description:
+ *
+ *     This function is for processing a DbeBeginIdiom request.
+ *     This request informs the server that a complex swap will immediately
+ *     follow this request.
+ *
+ * Return Values:
+ *
+ *     Success
+ *
+ *****************************************************************************/
+
+static int
+ProcDbeBeginIdiom(ClientPtr client)
+{
+    /* REQUEST(xDbeBeginIdiomReq); */
+    DbeScreenPrivPtr	pDbeScreenPriv;
+    register int	i;
+
+
+    REQUEST_SIZE_MATCH(xDbeBeginIdiomReq);
+
+    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);
+        }
+    }
+
+    return(Success);
+
+} /* ProcDbeBeginIdiom() */
+
+
+/******************************************************************************
+ *
+ * DBE DIX Procedure: ProcDbeGetVisualInfo
+ *
+ * Description:
+ *
+ *     This function is for processing a ProcDbeGetVisualInfo request.
+ *     This request returns information about which visuals support
+ *     double buffering.
+ *
+ * Return Values:
+ *
+ *     BadDrawable - value in screen specifiers is not a valid drawable
+ *     Success
+ *
+ *****************************************************************************/
+
+static int
+ProcDbeGetVisualInfo(ClientPtr client)
+{
+    REQUEST(xDbeGetVisualInfoReq);
+    DbeScreenPrivPtr		pDbeScreenPriv;
+    xDbeGetVisualInfoReply	rep;
+    Drawable			*drawables;
+    DrawablePtr			*pDrawables = NULL;
+    register int		i, j, n, 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;
+    /* Make sure any specified drawables are valid. */
+    if (stuff->n != 0)
+    {
+        if (!(pDrawables = (DrawablePtr *)malloc(stuff->n *
+                                                 sizeof(DrawablePtr))))
+        {
+            return(BadAlloc);
+        }
+
+        drawables = (Drawable *)&stuff[1];
+
+        for (i = 0; i < stuff->n; i++)
+        {
+	    rc = dixLookupDrawable(pDrawables+i, drawables[i], client, 0,
+				   DixGetAttrAccess);
+	    if (rc != Success) {
+                free(pDrawables);
+                return rc;
+            }
+        }
+    }
+
+    count = (stuff->n == 0) ? screenInfo.numScreens : stuff->n;
+    if (!(pScrVisInfo = (XdbeScreenVisualInfo *)malloc(count *
+                        sizeof(XdbeScreenVisualInfo))))
+    {
+        if (pDrawables)
+        {
+            free(pDrawables);
+        }
+
+        return(BadAlloc);
+    }
+
+    length = 0;
+
+    for (i = 0; i < count; i++)
+    {
+        pScreen = (stuff->n == 0) ? screenInfo.screens[i] :
+                                    pDrawables[i]->pScreen;
+        pDbeScreenPriv = DBE_SCREEN_PRIV(pScreen);
+
+	rc = XaceHook(XACE_SCREEN_ACCESS, client, pScreen, DixGetAttrAccess);
+	if ((rc != Success) ||
+	    !(*pDbeScreenPriv->GetVisualInfo)(pScreen, &pScrVisInfo[i]))
+        {
+            /* We failed to alloc pScrVisInfo[i].visinfo. */
+
+            /* Free visinfos that we allocated for previous screen infos.*/
+            for (j = 0; j < i; j++)
+            {
+                free(pScrVisInfo[j].visinfo);
+            }
+
+            /* Free pDrawables if we needed to allocate it above. */
+            if (pDrawables)
+            {
+                free(pDrawables);
+            }
+
+            return (rc == Success) ? BadAlloc : rc;
+        }
+
+        /* Account for n, number of xDbeVisInfo items in list. */
+        length += sizeof(CARD32);
+
+        /* Account for n xDbeVisInfo items */
+        length += pScrVisInfo[i].count * sizeof(xDbeVisInfo);
+    }
+
+    rep.type           = X_Reply;
+    rep.sequenceNumber = client->sequence;
+    rep.length         = bytes_to_int32(length);
+    rep.m              = count;
+
+    if (client->swapped)
+    {
+        swaps(&rep.sequenceNumber, n);
+        swapl(&rep.length, n);
+        swapl(&rep.m, n);
+    }
+
+    /* Send off reply. */
+    WriteToClient(client, sizeof(xDbeGetVisualInfoReply), (char *)&rep);
+
+    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;
+
+        if (client->swapped)
+        {
+            swapl(&data32, n);
+        }
+
+        WriteToClient(client, sizeof(CARD32), (char *)&data32);
+
+        /* Now send off visual info items. */
+        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.perfLevel = (CARD8) pScrVisInfo[i].visinfo[j].perflevel;
+
+            if (client->swapped)
+            {
+                swapl(&visInfo.visualID, n);
+
+                /* We do not need to swap depth and perfLevel since they are
+                 * already 1 byte quantities.
+                 */
+            }
+
+            /* Write visualID(32), depth(8), perfLevel(8), and pad(16). */
+            WriteToClient(client, 2*sizeof(CARD32), (char *)&visInfo.visualID);
+        }
+    }
+
+    /* Clean up memory. */
+    for (i = 0; i < count; i++)
+    {
+        free(pScrVisInfo[i].visinfo);
+    }
+    free(pScrVisInfo);
+
+    if (pDrawables)
+    {
+        free(pDrawables);
+    }
+
+    return Success;
+
+} /* ProcDbeGetVisualInfo() */
+
+
+/******************************************************************************
+ *
+ * DBE DIX Procedure: ProcDbeGetbackBufferAttributes
+ *
+ * Description:
+ *
+ *     This function is for processing a ProcDbeGetbackBufferAttributes
+ *     request.  This request returns information about a back buffer.
+ *
+ * Return Values:
+ *
+ *     Success
+ *
+ *****************************************************************************/
+
+static int
+ProcDbeGetBackBufferAttributes(ClientPtr client)
+{
+    REQUEST(xDbeGetBackBufferAttributesReq);
+    xDbeGetBackBufferAttributesReply	rep;
+    DbeWindowPrivPtr			pDbeWindowPriv;
+    int					rc, n;
+
+
+    REQUEST_SIZE_MATCH(xDbeGetBackBufferAttributesReq);
+
+    rc = dixLookupResourceByType((pointer *)&pDbeWindowPriv, stuff->buffer,
+				 dbeWindowPrivResType, client,
+				 DixGetAttrAccess);
+    if (rc == Success)
+    {
+        rep.attributes = pDbeWindowPriv->pWindow->drawable.id;
+    }
+    else
+    {
+        rep.attributes = None;
+    }
+        
+    rep.type           = X_Reply;
+    rep.sequenceNumber = client->sequence;
+    rep.length         = 0;
+    
+    if (client->swapped)
+    {
+        swaps(&rep.sequenceNumber, n);
+        swapl(&rep.length, n);
+        swapl(&rep.attributes, n);
+    }
+
+    WriteToClient(client, sizeof(xDbeGetBackBufferAttributesReply),
+                  (char *)&rep);
+    return Success;
+
+} /* ProcDbeGetbackBufferAttributes() */
+
+
+/******************************************************************************
+ *
+ * DBE DIX Procedure: ProcDbeDispatch
+ *
+ * Description:
+ *
+ *     This function dispatches DBE requests.
+ *
+ *****************************************************************************/
+
+static int
+ProcDbeDispatch(ClientPtr client)
+{
+    REQUEST(xReq);
+
+
+    switch (stuff->data)
+    {
+        case X_DbeGetVersion:
+            return(ProcDbeGetVersion(client));
+
+        case X_DbeAllocateBackBufferName:
+            return(ProcDbeAllocateBackBufferName(client));
+
+        case X_DbeDeallocateBackBufferName:
+            return(ProcDbeDeallocateBackBufferName(client));
+
+        case X_DbeSwapBuffers:
+            return(ProcDbeSwapBuffers(client));
+
+        case X_DbeBeginIdiom:
+            return(ProcDbeBeginIdiom(client));
+
+        case X_DbeEndIdiom:
+            return(Success);
+
+        case X_DbeGetVisualInfo:
+            return(ProcDbeGetVisualInfo(client));
+
+        case X_DbeGetBackBufferAttributes:
+            return(ProcDbeGetBackBufferAttributes(client));
+
+        default:
+            return(BadRequest);
+    }
+
+} /* ProcDbeDispatch() */
+
+
+/******************************************************************************
+ *
+ * DBE DIX Procedure: SProcDbeGetVersion
+ *
+ * Description:
+ *
+ *     This function is for processing a DbeGetVersion request on a swapped
+ *     server.  This request returns the major and minor version numbers of
+ *     this extension.
+ *
+ * Return Values:
+ *
+ *     Success
+ *
+ *****************************************************************************/
+
+static int
+SProcDbeGetVersion(ClientPtr client)
+{
+    REQUEST(xDbeGetVersionReq);
+    register int	n;
+
+
+    swaps(&stuff->length, n);
+    return(ProcDbeGetVersion(client));
+
+} /* SProcDbeGetVersion() */
+
+
+/******************************************************************************
+ *
+ * DBE DIX Procedure: SProcDbeAllocateBackBufferName
+ *
+ * Description:
+ *
+ *     This function is for processing a DbeAllocateBackBufferName request on
+ *     a swapped server.  This request allocates a drawable ID used to refer
+ *     to the back buffer of a window.
+ *
+ * Return Values:
+ *
+ *     BadAlloc    - server can not allocate resources
+ *     BadIDChoice - id is out of range for client; id is already in use
+ *     BadMatch    - window is not an InputOutput window;
+ *                   visual of window is not on list returned by
+ *                   DBEGetVisualInfo; 
+ *     BadValue    - invalid swap action is specified
+ *     BadWindow   - window is not a valid window
+ *     Success
+ *
+ *****************************************************************************/
+
+static int
+SProcDbeAllocateBackBufferName(ClientPtr client)
+{
+    REQUEST(xDbeAllocateBackBufferNameReq);
+    register int	n;
+
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xDbeAllocateBackBufferNameReq);
+
+    swapl(&stuff->window, n);
+    swapl(&stuff->buffer, n);
+    /* stuff->swapAction is a byte.  We do not need to swap this field. */
+
+    return(ProcDbeAllocateBackBufferName(client));
+
+} /* SProcDbeAllocateBackBufferName() */
+
+
+/******************************************************************************
+ *
+ * DBE DIX Procedure: SProcDbeDeallocateBackBufferName
+ *
+ * Description:
+ *
+ *     This function is for processing a DbeDeallocateBackBufferName request
+ *     on a swapped server.  This request frees a drawable ID that was
+ *     obtained by a DbeAllocateBackBufferName request.
+ *
+ * Return Values:
+ *
+ *     BadBuffer - buffer to deallocate is not associated with a window
+ *     Success
+ *
+ *****************************************************************************/
+
+static int
+SProcDbeDeallocateBackBufferName(ClientPtr client)
+{
+    REQUEST (xDbeDeallocateBackBufferNameReq);
+    register int	n;
+
+
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xDbeDeallocateBackBufferNameReq);
+
+    swapl(&stuff->buffer, n);
+
+    return(ProcDbeDeallocateBackBufferName(client));
+
+} /* SProcDbeDeallocateBackBufferName() */
+
+
+/******************************************************************************
+ *
+ * DBE DIX Procedure: SProcDbeSwapBuffers
+ *
+ * Description:
+ *
+ *     This function is for processing a DbeSwapBuffers request on a swapped
+ *     server.  This request swaps the buffers for all windows listed,
+ *     applying the appropriate swap action for each window.
+ *
+ * Return Values:
+ *
+ *     BadMatch  - a window in request is not double-buffered; a window in
+ *                 request is listed more than once; all windows in request do
+ *                 not have the same root
+ *     BadValue  - invalid swap action is specified
+ *     BadWindow - a window in request is not valid
+ *     Success
+ *
+ *****************************************************************************/
+
+static int
+SProcDbeSwapBuffers(ClientPtr client)
+{
+    REQUEST(xDbeSwapBuffersReq);
+    register int	i, n;
+    xDbeSwapInfo	*pSwapInfo;
+
+
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xDbeSwapBuffersReq);
+
+    swapl(&stuff->n, n);
+
+    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++)
+        {
+            swapl(&pSwapInfo->window, n);
+        }
+    }
+
+    return(ProcDbeSwapBuffers(client));
+
+} /* SProcDbeSwapBuffers() */
+
+
+/******************************************************************************
+ *
+ * DBE DIX Procedure: SProcDbeBeginIdiom
+ *
+ * Description:
+ *
+ *     This function is for processing a DbeBeginIdiom request on a swapped
+ *     server.  This request informs the server that a complex swap will
+ *     immediately follow this request.
+ *
+ * Return Values:
+ *
+ *     Success
+ *
+ *****************************************************************************/
+
+static int
+SProcDbeBeginIdiom(ClientPtr client)
+{
+    REQUEST(xDbeBeginIdiomReq);
+    register int	n;
+
+    swaps(&stuff->length, n);
+    return(ProcDbeBeginIdiom(client));
+
+} /* SProcDbeBeginIdiom() */
+
+
+/******************************************************************************
+ *
+ * DBE DIX Procedure: SProcDbeGetVisualInfo
+ *
+ * Description:
+ *
+ *     This function is for processing a ProcDbeGetVisualInfo request on a
+ *     swapped server.  This request returns information about which visuals
+ *     support double buffering.
+ *
+ * Return Values:
+ *
+ *     BadDrawable - value in screen specifiers is not a valid drawable
+ *     Success
+ *
+ *****************************************************************************/
+
+static int
+SProcDbeGetVisualInfo(ClientPtr client)
+{
+    REQUEST(xDbeGetVisualInfoReq);
+    register int	n;
+
+
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xDbeGetVisualInfoReq);
+
+    swapl(&stuff->n, n);
+    SwapRestL(stuff);
+
+    return(ProcDbeGetVisualInfo(client));
+
+} /* SProcDbeGetVisualInfo() */
+
+
+/******************************************************************************
+ *
+ * DBE DIX Procedure: SProcDbeGetbackBufferAttributes
+ *
+ * Description:
+ *
+ *     This function is for processing a ProcDbeGetbackBufferAttributes
+ *     request on a swapped server.  This request returns information about a
+ *     back buffer.
+ *
+ * Return Values:
+ *
+ *     Success
+ *
+ *****************************************************************************/
+
+static int
+SProcDbeGetBackBufferAttributes(ClientPtr client)
+{
+    REQUEST (xDbeGetBackBufferAttributesReq);
+    register int	n;
+
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xDbeGetBackBufferAttributesReq);
+
+    swapl(&stuff->buffer, n);
+
+    return(ProcDbeGetBackBufferAttributes(client));
+
+} /* SProcDbeGetBackBufferAttributes() */
+
+
+/******************************************************************************
+ *
+ * DBE DIX Procedure: SProcDbeDispatch
+ *
+ * Description:
+ *
+ *     This function dispatches DBE requests on a swapped server.
+ *
+ *****************************************************************************/
+
+static int
+SProcDbeDispatch(ClientPtr client)
+{
+    REQUEST(xReq);
+
+
+    switch (stuff->data)
+    {
+        case X_DbeGetVersion:
+            return(SProcDbeGetVersion(client));
+
+        case X_DbeAllocateBackBufferName:
+            return(SProcDbeAllocateBackBufferName(client));
+
+        case X_DbeDeallocateBackBufferName:
+            return(SProcDbeDeallocateBackBufferName(client));
+
+        case X_DbeSwapBuffers:
+            return(SProcDbeSwapBuffers(client));
+
+        case X_DbeBeginIdiom:
+            return(SProcDbeBeginIdiom(client));
+
+        case X_DbeEndIdiom:
+            return(Success);
+
+        case X_DbeGetVisualInfo:
+            return(SProcDbeGetVisualInfo(client));
+
+        case X_DbeGetBackBufferAttributes:
+            return(SProcDbeGetBackBufferAttributes(client));
+
+        default:
+            return (BadRequest);
+    }
+
+} /* SProcDbeDispatch() */
+
+
+/******************************************************************************
+ *
+ * DBE DIX Procedure: DbeSetupBackgroundPainter
+ *
+ * Description:
+ *
+ *     This function sets up pGC to clear pixmaps.
+ *
+ * Return Values:
+ *
+ *     TRUE  - setup was successful
+ *     FALSE - the window's background state is NONE
+ * 
+ *****************************************************************************/
+
+static Bool
+DbeSetupBackgroundPainter(WindowPtr pWin, GCPtr pGC)
+{
+    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
+     * corner of the first ancestor without a ParentRelative background.
+     * This coordinate is, of course, negative.
+     */
+    ts_x_origin = ts_y_origin = 0;
+    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);
+    }
+
+    return ChangeGC(NullClient, pGC, gcmask, gcvalues) == 0;
+} /* DbeSetupBackgroundPainter() */
+
+
+/******************************************************************************
+ *
+ * DBE DIX Procedure: DbeDrawableDelete
+ *
+ * Description:
+ *
+ *     This is the resource delete function for dbeDrawableResType.
+ *     It is registered when the drawable resource type is created in
+ *     DbeExtensionInit().
+ *
+ *     To make resource deletion simple, we do not do anything in this function
+ *     and leave all resource deleteion to DbeWindowPrivDelete(), which will
+ *     eventually be called or already has been called.  Deletion functions are
+ *     not guaranteed to be called in any particular order.
+ *
+ *****************************************************************************/
+static int
+DbeDrawableDelete(pointer pDrawable, XID id)
+{
+    return(Success);
+
+} /* DbeDrawableDelete() */
+
+
+/******************************************************************************
+ *
+ * DBE DIX Procedure: DbeWindowPrivDelete
+ *
+ * Description:
+ *
+ *     This is the resource delete function for dbeWindowPrivResType.
+ *     It is registered when the drawable resource type is created in
+ *     DbeExtensionInit().
+ *
+ *****************************************************************************/
+static int
+DbeWindowPrivDelete(pointer pDbeWinPriv, XID id)
+{
+    DbeScreenPrivPtr	pDbeScreenPriv;
+    DbeWindowPrivPtr	pDbeWindowPriv = (DbeWindowPrivPtr)pDbeWinPriv;
+    int			i;
+
+
+    /*
+     **************************************************************************
+     ** Remove the buffer ID from the ID array.
+     **************************************************************************
+     */
+
+    /* Find the ID in the ID array. */
+    i = 0;
+    while ((i < pDbeWindowPriv->nBufferIDs) && (pDbeWindowPriv->IDs[i] != id))
+    {
+        i++;
+    }
+
+    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))
+    {
+        /* 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));
+    }
+    else
+    {
+        /* We are removing the last ID in the array, in which case, the
+         * assignement below is all that we need to do.
+         */
+    }
+    pDbeWindowPriv->IDs[pDbeWindowPriv->nBufferIDs - 1] = DBE_FREE_ID_ELEMENT;
+
+    pDbeWindowPriv->nBufferIDs--;
+
+    /* If an extended array was allocated, then check to see if the remaining
+     * buffer IDs will fit in the static array.
+     */
+
+    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));
+
+        /* Free the extended array; use the static array. */
+        free(pDbeWindowPriv->IDs);
+        pDbeWindowPriv->IDs = pDbeWindowPriv->initIDs;
+        pDbeWindowPriv->maxAvailableIDs = DBE_INIT_MAX_IDS;
+    }
+
+
+    /*
+     **************************************************************************
+     ** Perform DDX level tasks.
+     **************************************************************************
+     */
+
+    pDbeScreenPriv = DBE_SCREEN_PRIV_FROM_WINDOW_PRIV(
+                         (DbeWindowPrivPtr)pDbeWindowPriv);
+    (*pDbeScreenPriv->WinPrivDelete)((DbeWindowPrivPtr)pDbeWindowPriv, id);
+
+
+    /*
+     **************************************************************************
+     ** Perform miscellaneous tasks if this is the last buffer associated
+     ** with the window.
+     **************************************************************************
+     */
+
+    if (pDbeWindowPriv->nBufferIDs == 0)
+    {
+        /* Reset the DBE window priv pointer. */
+	dixSetPrivate(&pDbeWindowPriv->pWindow->devPrivates, dbeWindowPrivKey,
+		      NULL);
+
+        /* We are done with the window priv. */
+	dixFreePrivates(pDbeWindowPriv->devPrivates);
+        free(pDbeWindowPriv);
+    }
+
+    return(Success);
+
+} /* DbeWindowPrivDelete() */
+
+
+/******************************************************************************
+ *
+ * DBE DIX Procedure: DbeResetProc
+ *
+ * Description:
+ *
+ *     This routine is called at the end of every server generation.
+ *     It deallocates any memory reserved for the extension and performs any
+ *     other tasks related to shutting down the extension.
+ *
+ *****************************************************************************/
+static void
+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().*/
+            pScreen->DestroyWindow = pDbeScreenPriv->DestroyWindow;
+
+	    if (pDbeScreenPriv->ResetProc)
+		(*pDbeScreenPriv->ResetProc)(pScreen);
+
+	    free(pDbeScreenPriv);
+	}
+    }
+} /* DbeResetProc() */
+
+
+/******************************************************************************
+ *
+ * DBE DIX Procedure: DbeDestroyWindow
+ *
+ * Description:
+ *
+ *     This is the wrapper for pScreen->DestroyWindow.
+ *     This function frees buffer resources for a window before it is
+ *     destroyed.
+ *
+ *****************************************************************************/
+
+static Bool
+DbeDestroyWindow(WindowPtr pWin)
+{
+    DbeScreenPrivPtr	pDbeScreenPriv;
+    DbeWindowPrivPtr	pDbeWindowPriv;
+    ScreenPtr		pScreen;
+    Bool		ret;
+
+
+    /*
+     **************************************************************************
+     ** 1. Unwrap the member routine.
+     **************************************************************************
+     */
+
+    pScreen                = pWin->drawable.pScreen;
+    pDbeScreenPriv         = DBE_SCREEN_PRIV(pScreen);
+    pScreen->DestroyWindow = pDbeScreenPriv->DestroyWindow;
+
+    /*
+     **************************************************************************
+     ** 2. Do any work necessary before the member routine is called.
+     **
+     **    Call the window priv delete function for all buffer IDs associated
+     **    with this window.
+     **************************************************************************
+     */
+
+    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.
+             */
+            FreeResource(pDbeWindowPriv->IDs[0], RT_NONE);
+            pDbeWindowPriv = DBE_WINDOW_PRIV(pWin);
+        }
+    }
+
+    /*
+     **************************************************************************
+     ** 3. Call the member routine, saving its result if necessary.
+     **************************************************************************
+     */
+
+    ret = (*pScreen->DestroyWindow)(pWin);
+
+    /*
+     **************************************************************************
+     ** 4. Rewrap the member routine, restoring the wrapper value first in case
+     **    the wrapper (or something that it wrapped) change this value.
+     **************************************************************************
+     */
+
+    pDbeScreenPriv->DestroyWindow = pScreen->DestroyWindow;
+    pScreen->DestroyWindow = DbeDestroyWindow;
+
+    /*
+     **************************************************************************
+     ** 5. Do any work necessary after the member routine has been called.
+     **
+     **    In this case we do not need to do anything.
+     **************************************************************************
+     */
+
+    return(ret);
+
+} /* DbeDestroyWindow() */
+
+
+/******************************************************************************
+ *
+ * DBE DIX Procedure: DbeExtensionInit
+ *
+ * Description:
+ *
+ *     Called from InitExtensions in main()
+ *
+ *****************************************************************************/
+
+void
+DbeExtensionInit(void)
+{
+    ExtensionEntry	*extEntry;
+    register int	i, j;
+    ScreenPtr		pScreen = NULL;
+    DbeScreenPrivPtr	pDbeScreenPriv;
+    int			nStubbedScreens = 0;
+    Bool		ddxInitSuccess;
+
+#ifdef PANORAMIX
+    if(!noPanoramiXExtension) return;
+#endif
+
+    /* Create the resource types. */
+    dbeDrawableResType =
+        CreateNewResourceType(DbeDrawableDelete, "dbeDrawable");
+    if (!dbeDrawableResType)
+	return;
+    dbeDrawableResType |= RC_DRAWABLE;
+
+    dbeWindowPrivResType =
+        CreateNewResourceType(DbeWindowPrivDelete, "dbeWindow");
+    if (!dbeWindowPrivResType)
+	return;
+
+    if (!dixRegisterPrivateOffset(dbeDrawableResType,
+				  offsetof(PixmapRec, devPrivates)))
+	return;
+
+    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];
+
+	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;
+	}
+
+	dixSetPrivate(&pScreen->devPrivates, dbeScreenPrivKey, pDbeScreenPriv);
+
+        /* Copy the resource types */
+        pDbeScreenPriv->dbeDrawableResType   = dbeDrawableResType;
+        pDbeScreenPriv->dbeWindowPrivResType = dbeWindowPrivResType;
+
+        /* Copy the private indices */
+        pDbeScreenPriv->dbeScreenPrivKey = dbeScreenPrivKey;
+        pDbeScreenPriv->dbeWindowPrivKey = dbeWindowPrivKey;
+
+        {
+            /* We don't have DDX support for DBE anymore */
+
+#ifndef DISABLE_MI_DBE_BY_DEFAULT
+            /* Setup DIX. */
+            pDbeScreenPriv->SetupBackgroundPainter = DbeSetupBackgroundPainter; 
+
+            /* Setup DDX. */
+            ddxInitSuccess = miDbeInit(pScreen, pDbeScreenPriv);
+
+            /* DDX DBE initialization may have the side affect of
+             * reallocating pDbeScreenPriv, so we need to update it.
+             */
+            pDbeScreenPriv = DBE_SCREEN_PRIV(pScreen);
+
+            if (ddxInitSuccess)
+            {
+                /* Wrap DestroyWindow.  The DDX initialization function
+                 * already wrapped PositionWindow for us.
+                 */
+
+                pDbeScreenPriv->DestroyWindow = pScreen->DestroyWindow;
+                pScreen->DestroyWindow        = DbeDestroyWindow;
+            }
+            else
+            {
+                /* DDX initialization failed.  Stub the screen. */
+                DbeStubScreen(pDbeScreenPriv, &nStubbedScreens);
+            }
+#else
+            DbeStubScreen(pDbeScreenPriv, &nStubbedScreens);
+#endif
+
+        }
+
+    } /* for (i = 0; i < screenInfo.numScreens; i++) */
+
+
+    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);
+        }
+        return;
+    }
+
+
+    /* Now add the extension. */
+    extEntry = AddExtension(DBE_PROTOCOL_NAME, DbeNumberEvents, 
+                            DbeNumberErrors, ProcDbeDispatch, SProcDbeDispatch,
+                            DbeResetProc, StandardMinorOpcode);
+
+    dbeErrorBase = extEntry->errorBase;
+
+} /* DbeExtensionInit() */
+