summaryrefslogtreecommitdiff
path: root/dbe
diff options
context:
space:
mode:
authorKeith Packard <keithp@keithp.com>2012-03-21 12:55:09 -0700
committerKeith Packard <keithp@keithp.com>2012-03-21 13:54:42 -0700
commit9838b7032ea9792bec21af424c53c07078636d21 (patch)
treeb72d0827dac50f0f3b8eab29b3b7639546d735d7 /dbe
parent75199129c603fc8567185ac31866c9518193cb78 (diff)
Introduce a consistent coding style
This is strictly the application of the script 'x-indent-all.sh' from util/modular. Compared to the patch that Daniel posted in January, I've added a few indent flags: -bap -psl -T PrivatePtr -T pmWait -T _XFUNCPROTOBEGIN -T _XFUNCPROTOEND -T _X_EXPORT The typedefs were needed to make the output of sdksyms.sh match the previous output, otherwise, the code is formatted badly enough that sdksyms.sh generates incorrect output. The generated code was compared with the previous version and found to be essentially identical -- "assert" line numbers and BUILD_TIME were the only differences found. The comparison was done with this script: dir1=$1 dir2=$2 for dir in $dir1 $dir2; do (cd $dir && find . -name '*.o' | while read file; do dir=`dirname $file` base=`basename $file .o` dump=$dir/$base.dump objdump -d $file > $dump done) done find $dir1 -name '*.dump' | while read dump; do otherdump=`echo $dump | sed "s;$dir1;$dir2;"` diff -u $dump $otherdump done Signed-off-by: Keith Packard <keithp@keithp.com> Acked-by: Daniel Stone <daniel@fooishbar.org> Acked-by: Alan Coopersmith <alan.coopersmith@oracle.com>
Diffstat (limited to 'dbe')
-rw-r--r--dbe/dbe.c838
-rw-r--r--dbe/dbestruct.h117
-rw-r--r--dbe/midbe.c524
-rw-r--r--dbe/midbe.h14
-rw-r--r--dbe/midbestr.h14
5 files changed, 659 insertions, 848 deletions
diff --git a/dbe/dbe.c b/dbe/dbe.c
index a46867676..19a861822 100644
--- a/dbe/dbe.c
+++ b/dbe/dbe.c
@@ -30,7 +30,6 @@
*
*****************************************************************************/
-
/* INCLUDES */
#ifdef HAVE_DIX_CONFIG_H
@@ -57,11 +56,11 @@ DevPrivateKeyRec dbeScreenPrivKeyRec;
DevPrivateKeyRec dbeWindowPrivKeyRec;
/* These are globals for use by DDX */
-RESTYPE dbeDrawableResType;
-RESTYPE dbeWindowPrivResType;
+RESTYPE dbeDrawableResType;
+RESTYPE dbeWindowPrivResType;
/* Used to generate DBE's BadBuffer error. */
-static int dbeErrorBase;
+static int dbeErrorBase;
/******************************************************************************
*
@@ -87,19 +86,17 @@ DbeStubScreen(DbeScreenPrivPtr pDbeScreenPriv, int *nStubbedScreens)
*/
/* Stub DDX. */
- pDbeScreenPriv->GetVisualInfo = NULL;
+ pDbeScreenPriv->GetVisualInfo = NULL;
pDbeScreenPriv->AllocBackBufferName = NULL;
- pDbeScreenPriv->SwapBuffers = NULL;
- pDbeScreenPriv->BeginIdiom = NULL;
- pDbeScreenPriv->EndIdiom = NULL;
- pDbeScreenPriv->WinPrivDelete = NULL;
- pDbeScreenPriv->ResetProc = NULL;
+ pDbeScreenPriv->SwapBuffers = NULL;
+ pDbeScreenPriv->BeginIdiom = NULL;
+ pDbeScreenPriv->EndIdiom = NULL;
+ pDbeScreenPriv->WinPrivDelete = NULL;
+ pDbeScreenPriv->ResetProc = NULL;
(*nStubbedScreens)++;
-} /* DbeStubScreen() */
-
-
+} /* DbeStubScreen() */
/******************************************************************************
*
@@ -121,27 +118,25 @@ static int
ProcDbeGetVersion(ClientPtr client)
{
/* REQUEST(xDbeGetVersionReq); */
- xDbeGetVersionReply rep;
+ xDbeGetVersionReply rep;
REQUEST_SIZE_MATCH(xDbeGetVersionReq);
- rep.type = X_Reply;
- rep.length = 0;
+ rep.type = X_Reply;
+ rep.length = 0;
rep.sequenceNumber = client->sequence;
- rep.majorVersion = DBE_MAJOR_VERSION;
- rep.minorVersion = DBE_MINOR_VERSION;
+ rep.majorVersion = DBE_MAJOR_VERSION;
+ rep.minorVersion = DBE_MINOR_VERSION;
- if (client->swapped)
- {
+ if (client->swapped) {
swaps(&rep.sequenceNumber);
}
- WriteToClient(client, sizeof(xDbeGetVersionReply), (char *)&rep);
+ WriteToClient(client, sizeof(xDbeGetVersionReply), (char *) &rep);
return Success;
-} /* ProcDbeGetVersion() */
-
+} /* ProcDbeGetVersion() */
/******************************************************************************
*
@@ -170,38 +165,34 @@ static int
ProcDbeAllocateBackBufferName(ClientPtr client)
{
REQUEST(xDbeAllocateBackBufferNameReq);
- WindowPtr pWin;
- DbeScreenPrivPtr pDbeScreenPriv;
- DbeWindowPrivPtr pDbeWindowPriv;
- XdbeScreenVisualInfo scrVisInfo;
- register int i;
- Bool visualMatched = FALSE;
- xDbeSwapAction swapAction;
- VisualID visual;
- int status;
- int add_index;
-
+ WindowPtr pWin;
+ DbeScreenPrivPtr pDbeScreenPriv;
+ DbeWindowPrivPtr pDbeWindowPriv;
+ XdbeScreenVisualInfo scrVisInfo;
+ register int i;
+ Bool visualMatched = FALSE;
+ xDbeSwapAction swapAction;
+ VisualID visual;
+ int status;
+ int add_index;
REQUEST_SIZE_MATCH(xDbeAllocateBackBufferNameReq);
/* The window must be valid. */
status = dixLookupWindow(&pWin, stuff->window, client, DixManageAccess);
if (status != Success)
- return status;
+ return status;
/* The window must be InputOutput. */
- if (pWin->drawable.class != InputOutput)
- {
- return BadMatch;
+ if (pWin->drawable.class != InputOutput) {
+ return BadMatch;
}
/* The swap action must be valid. */
- swapAction = stuff->swapAction; /* use local var for performance. */
- if ((swapAction != XdbeUndefined ) &&
+ swapAction = stuff->swapAction; /* use local var for performance. */
+ if ((swapAction != XdbeUndefined) &&
(swapAction != XdbeBackground) &&
- (swapAction != XdbeUntouched ) &&
- (swapAction != XdbeCopied ))
- {
+ (swapAction != XdbeUntouched) && (swapAction != XdbeCopied)) {
return BadValue;
}
@@ -213,115 +204,105 @@ ProcDbeAllocateBackBufferName(ClientPtr client)
*/
pDbeScreenPriv = DBE_SCREEN_PRIV_FROM_WINDOW(pWin);
if (!pDbeScreenPriv->GetVisualInfo)
- return BadMatch; /* screen doesn't support double buffering */
+ return BadMatch; /* screen doesn't support double buffering */
- if (!(*pDbeScreenPriv->GetVisualInfo)(pWin->drawable.pScreen, &scrVisInfo))
- {
+ if (!(*pDbeScreenPriv->GetVisualInfo) (pWin->drawable.pScreen, &scrVisInfo)) {
/* GetVisualInfo() failed to allocate visual info data. */
return BadAlloc;
}
/* See if the window's visual is on the list. */
visual = wVisual(pWin);
- for (i = 0; (i < scrVisInfo.count) && !visualMatched; i++)
- {
- if (scrVisInfo.visinfo[i].visual == visual)
- {
- visualMatched = TRUE;
- }
+ for (i = 0; (i < scrVisInfo.count) && !visualMatched; i++) {
+ if (scrVisInfo.visinfo[i].visual == visual) {
+ visualMatched = TRUE;
+ }
}
/* Free what was allocated by the GetVisualInfo() call above. */
free(scrVisInfo.visinfo);
- if (!visualMatched)
- {
- return BadMatch;
+ if (!visualMatched) {
+ return BadMatch;
}
- if ((pDbeWindowPriv = DBE_WINDOW_PRIV(pWin)) == NULL)
- {
+ if ((pDbeWindowPriv = DBE_WINDOW_PRIV(pWin)) == NULL) {
/* There is no buffer associated with the window.
* Allocate a window priv.
*/
- pDbeWindowPriv = dixAllocateObjectWithPrivates(DbeWindowPrivRec, PRIVATE_DBE_WINDOW);
- if (!pDbeWindowPriv)
+ pDbeWindowPriv =
+ dixAllocateObjectWithPrivates(DbeWindowPrivRec, PRIVATE_DBE_WINDOW);
+ if (!pDbeWindowPriv)
return BadAlloc;
/* Fill out window priv information. */
- pDbeWindowPriv->pWindow = pWin;
- pDbeWindowPriv->width = pWin->drawable.width;
- pDbeWindowPriv->height = pWin->drawable.height;
- pDbeWindowPriv->x = pWin->drawable.x;
- pDbeWindowPriv->y = pWin->drawable.y;
- pDbeWindowPriv->nBufferIDs = 0;
+ pDbeWindowPriv->pWindow = pWin;
+ pDbeWindowPriv->width = pWin->drawable.width;
+ pDbeWindowPriv->height = pWin->drawable.height;
+ pDbeWindowPriv->x = pWin->drawable.x;
+ pDbeWindowPriv->y = pWin->drawable.y;
+ pDbeWindowPriv->nBufferIDs = 0;
/* Set the buffer ID array pointer to the initial (static) array). */
pDbeWindowPriv->IDs = pDbeWindowPriv->initIDs;
- /* Initialize the buffer ID list. */
+ /* Initialize the buffer ID list. */
pDbeWindowPriv->maxAvailableIDs = DBE_INIT_MAX_IDS;
pDbeWindowPriv->IDs[0] = stuff->buffer;
add_index = 0;
- for (i = 0; i < DBE_INIT_MAX_IDS; i++)
- {
+ for (i = 0; i < DBE_INIT_MAX_IDS; i++) {
pDbeWindowPriv->IDs[i] = DBE_FREE_ID_ELEMENT;
}
/* Actually connect the window priv to the window. */
dixSetPrivate(&pWin->devPrivates, dbeWindowPrivKey, pDbeWindowPriv);
- } /* if -- There is no buffer associated with the window. */
+ } /* if -- There is no buffer associated with the window. */
- else
- {
+ else {
/* A buffer is already associated with the window.
* Add the new buffer ID to the array, reallocating the array memory
* if necessary.
*/
/* Determine if there is a free element in the ID array. */
- for (i = 0; i < pDbeWindowPriv->maxAvailableIDs; i++)
- {
- if (pDbeWindowPriv->IDs[i] == DBE_FREE_ID_ELEMENT)
- {
+ for (i = 0; i < pDbeWindowPriv->maxAvailableIDs; i++) {
+ if (pDbeWindowPriv->IDs[i] == DBE_FREE_ID_ELEMENT) {
/* There is still room in the ID array. */
break;
}
}
-
- if (i == pDbeWindowPriv->maxAvailableIDs)
- {
+
+ if (i == pDbeWindowPriv->maxAvailableIDs) {
/* No more room in the ID array -- reallocate another array. */
- XID *pIDs;
+ XID *pIDs;
/* Setup an array pointer for the realloc operation below. */
- if (pDbeWindowPriv->maxAvailableIDs == DBE_INIT_MAX_IDS)
- {
+ if (pDbeWindowPriv->maxAvailableIDs == DBE_INIT_MAX_IDS) {
/* We will malloc a new array. */
pIDs = NULL;
}
- else
- {
+ else {
/* We will realloc a new array. */
pIDs = pDbeWindowPriv->IDs;
}
/* malloc/realloc a new array and initialize all elements to 0. */
- pDbeWindowPriv->IDs = (XID *)realloc(pIDs,
- (pDbeWindowPriv->maxAvailableIDs+DBE_INCR_MAX_IDS)*sizeof(XID));
- if (!pDbeWindowPriv->IDs)
- {
+ pDbeWindowPriv->IDs = (XID *) realloc(pIDs,
+ (pDbeWindowPriv->
+ maxAvailableIDs +
+ DBE_INCR_MAX_IDS) *
+ sizeof(XID));
+ if (!pDbeWindowPriv->IDs) {
return BadAlloc;
}
memset(&pDbeWindowPriv->IDs[pDbeWindowPriv->nBufferIDs], 0,
(pDbeWindowPriv->maxAvailableIDs + DBE_INCR_MAX_IDS -
pDbeWindowPriv->nBufferIDs) * sizeof(XID));
- if (pDbeWindowPriv->maxAvailableIDs == DBE_INIT_MAX_IDS)
- {
+ if (pDbeWindowPriv->maxAvailableIDs == DBE_INIT_MAX_IDS) {
/* We just went from using the initial (static) array to a
* newly allocated array. Copy the IDs from the initial array
* to the new array.
@@ -333,21 +314,18 @@ ProcDbeAllocateBackBufferName(ClientPtr client)
pDbeWindowPriv->maxAvailableIDs += DBE_INCR_MAX_IDS;
}
- add_index = i;
-
- } /* else -- A buffer is already associated with the window. */
+ add_index = i;
+ } /* else -- A buffer is already associated with the window. */
/* Call the DDX routine to allocate the back buffer. */
- status = (*pDbeScreenPriv->AllocBackBufferName)(pWin, stuff->buffer,
- stuff->swapAction);
+ status = (*pDbeScreenPriv->AllocBackBufferName) (pWin, stuff->buffer,
+ stuff->swapAction);
- if (status == Success)
- {
- pDbeWindowPriv->IDs[add_index] = stuff->buffer;
+ if (status == Success) {
+ pDbeWindowPriv->IDs[add_index] = stuff->buffer;
if (!AddResource(stuff->buffer, dbeWindowPrivResType,
- (pointer)pDbeWindowPriv))
- {
+ (pointer) pDbeWindowPriv)) {
pDbeWindowPriv->IDs[add_index] = DBE_FREE_ID_ELEMENT;
if (pDbeWindowPriv->nBufferIDs == 0) {
@@ -355,7 +333,8 @@ ProcDbeAllocateBackBufferName(ClientPtr client)
goto out_free;
}
}
- } else {
+ }
+ else {
/* The DDX buffer allocation routine failed for the first buffer of
* this window.
*/
@@ -372,13 +351,12 @@ ProcDbeAllocateBackBufferName(ClientPtr client)
return status;
-out_free:
+ out_free:
dixSetPrivate(&pWin->devPrivates, dbeWindowPrivKey, NULL);
free(pDbeWindowPriv);
return status;
-} /* ProcDbeAllocateBackBufferName() */
-
+} /* ProcDbeAllocateBackBufferName() */
/******************************************************************************
*
@@ -401,41 +379,37 @@ static int
ProcDbeDeallocateBackBufferName(ClientPtr client)
{
REQUEST(xDbeDeallocateBackBufferNameReq);
- DbeWindowPrivPtr pDbeWindowPriv;
- int rc, i;
+ DbeWindowPrivPtr pDbeWindowPriv;
+ int rc, i;
pointer val;
-
REQUEST_SIZE_MATCH(xDbeDeallocateBackBufferNameReq);
/* Buffer name must be valid */
- rc = dixLookupResourceByType((pointer *)&pDbeWindowPriv, stuff->buffer,
- dbeWindowPrivResType, client,
- DixDestroyAccess);
+ rc = dixLookupResourceByType((pointer *) &pDbeWindowPriv, stuff->buffer,
+ dbeWindowPrivResType, client,
+ DixDestroyAccess);
if (rc != Success)
- return rc;
+ return rc;
rc = dixLookupResourceByType(&val, stuff->buffer, dbeDrawableResType,
- client, DixDestroyAccess);
+ client, DixDestroyAccess);
if (rc != Success)
- return rc;
+ return rc;
/* Make sure that the id is valid for the window.
* This is paranoid code since we already looked up the ID by type
* above.
*/
- for (i = 0; i < pDbeWindowPriv->nBufferIDs; i++)
- {
+ for (i = 0; i < pDbeWindowPriv->nBufferIDs; i++) {
/* Loop through the ID list to find the ID. */
- if (pDbeWindowPriv->IDs[i] == stuff->buffer)
- {
+ if (pDbeWindowPriv->IDs[i] == stuff->buffer) {
break;
}
}
- if (i == pDbeWindowPriv->nBufferIDs)
- {
+ if (i == pDbeWindowPriv->nBufferIDs) {
/* We did not find the ID in the ID list. */
client->errorValue = stuff->buffer;
return dbeErrorBase + DbeBadBuffer;
@@ -445,8 +419,7 @@ ProcDbeDeallocateBackBufferName(ClientPtr client)
return Success;
-} /* ProcDbeDeallocateBackBufferName() */
-
+} /* ProcDbeDeallocateBackBufferName() */
/******************************************************************************
*
@@ -475,82 +448,72 @@ static int
ProcDbeSwapBuffers(ClientPtr client)
{
REQUEST(xDbeSwapBuffersReq);
- WindowPtr pWin;
- DbeScreenPrivPtr pDbeScreenPriv;
- DbeSwapInfoPtr swapInfo;
- xDbeSwapInfo *dbeSwapInfo;
- int error;
- register int i, j;
- int nStuff;
-
+ WindowPtr pWin;
+ DbeScreenPrivPtr pDbeScreenPriv;
+ DbeSwapInfoPtr swapInfo;
+ xDbeSwapInfo *dbeSwapInfo;
+ int error;
+ register int i, j;
+ int nStuff;
REQUEST_AT_LEAST_SIZE(xDbeSwapBuffersReq);
- nStuff = stuff->n; /* use local variable for performance. */
+ nStuff = stuff->n; /* use local variable for performance. */
- if (nStuff == 0)
- {
+ if (nStuff == 0) {
return Success;
}
if (nStuff > UINT32_MAX / sizeof(DbeSwapInfoRec))
- return BadAlloc;
+ return BadAlloc;
/* Get to the swap info appended to the end of the request. */
- dbeSwapInfo = (xDbeSwapInfo *)&stuff[1];
+ dbeSwapInfo = (xDbeSwapInfo *) & stuff[1];
- /* Allocate array to record swap information. */
- swapInfo = (DbeSwapInfoPtr)malloc(nStuff * sizeof(DbeSwapInfoRec));
- if (swapInfo == NULL)
- {
+ /* Allocate array to record swap information. */
+ swapInfo = (DbeSwapInfoPtr) malloc(nStuff * sizeof(DbeSwapInfoRec));
+ if (swapInfo == NULL) {
return BadAlloc;
}
-
- for (i = 0; i < nStuff; i++)
- {
+ for (i = 0; i < nStuff; i++) {
/* Check all windows to swap. */
/* Each window must be a valid window - BadWindow. */
- error = dixLookupWindow(&pWin, dbeSwapInfo[i].window, client,
- DixWriteAccess);
- if (error != Success) {
+ error = dixLookupWindow(&pWin, dbeSwapInfo[i].window, client,
+ DixWriteAccess);
+ if (error != Success) {
free(swapInfo);
- return error;
+ return error;
}
/* Each window must be double-buffered - BadMatch. */
- if (DBE_WINDOW_PRIV(pWin) == NULL)
- {
+ if (DBE_WINDOW_PRIV(pWin) == NULL) {
free(swapInfo);
return BadMatch;
}
/* Each window must only be specified once - BadMatch. */
- for (j = i + 1; j < nStuff; j++)
- {
- if (dbeSwapInfo[i].window == dbeSwapInfo[j].window)
- {
+ for (j = i + 1; j < nStuff; j++) {
+ if (dbeSwapInfo[i].window == dbeSwapInfo[j].window) {
free(swapInfo);
return BadMatch;
- }
+ }
}
/* Each swap action must be valid - BadValue. */
- if ((dbeSwapInfo[i].swapAction != XdbeUndefined ) &&
+ if ((dbeSwapInfo[i].swapAction != XdbeUndefined) &&
(dbeSwapInfo[i].swapAction != XdbeBackground) &&
- (dbeSwapInfo[i].swapAction != XdbeUntouched ) &&
- (dbeSwapInfo[i].swapAction != XdbeCopied ))
- {
+ (dbeSwapInfo[i].swapAction != XdbeUntouched) &&
+ (dbeSwapInfo[i].swapAction != XdbeCopied)) {
free(swapInfo);
return BadValue;
}
/* Everything checks out OK. Fill in the swap info array. */
- swapInfo[i].pWindow = pWin;
- swapInfo[i].swapAction = dbeSwapInfo[i].swapAction;
-
- } /* for (i = 0; i < nStuff; i++) */
+ swapInfo[i].pWindow = pWin;
+ swapInfo[i].swapAction = dbeSwapInfo[i].swapAction;
+ } /* for (i = 0; i < nStuff; i++) */
/* Call the DDX routine to perform the swap(s). The DDX routine should
* scan the swap list (swap info), swap any buffers that it knows how to
@@ -565,22 +528,19 @@ ProcDbeSwapBuffers(ClientPtr client)
* could deal with cross-screen synchronization.
*/
- while (nStuff > 0)
- {
+ while (nStuff > 0) {
pDbeScreenPriv = DBE_SCREEN_PRIV_FROM_WINDOW(swapInfo[0].pWindow);
- error = (*pDbeScreenPriv->SwapBuffers)(client, &nStuff, swapInfo);
- if (error != Success)
- {
+ error = (*pDbeScreenPriv->SwapBuffers) (client, &nStuff, swapInfo);
+ if (error != Success) {
free(swapInfo);
return error;
}
}
-
+
free(swapInfo);
return Success;
-} /* ProcDbeSwapBuffers() */
-
+} /* ProcDbeSwapBuffers() */
/******************************************************************************
*
@@ -602,27 +562,23 @@ static int
ProcDbeBeginIdiom(ClientPtr client)
{
/* REQUEST(xDbeBeginIdiomReq); */
- DbeScreenPrivPtr pDbeScreenPriv;
- register int i;
-
+ DbeScreenPrivPtr pDbeScreenPriv;
+ register int i;
REQUEST_SIZE_MATCH(xDbeBeginIdiomReq);
- for (i = 0; i < screenInfo.numScreens; i++)
- {
+ for (i = 0; i < screenInfo.numScreens; i++) {
pDbeScreenPriv = DBE_SCREEN_PRIV(screenInfo.screens[i]);
/* Call the DDX begin idiom procedure if there is one. */
- if (pDbeScreenPriv->BeginIdiom)
- {
- (*pDbeScreenPriv->BeginIdiom)(client);
+ if (pDbeScreenPriv->BeginIdiom) {
+ (*pDbeScreenPriv->BeginIdiom) (client);
}
}
return Success;
-} /* ProcDbeBeginIdiom() */
-
+} /* ProcDbeBeginIdiom() */
/******************************************************************************
*
@@ -645,37 +601,33 @@ static int
ProcDbeGetVisualInfo(ClientPtr client)
{
REQUEST(xDbeGetVisualInfoReq);
- DbeScreenPrivPtr pDbeScreenPriv;
- xDbeGetVisualInfoReply rep;
- Drawable *drawables;
- DrawablePtr *pDrawables = NULL;
- register int i, j, rc;
- register int count; /* number of visual infos in reply */
- register int length; /* length of reply */
- ScreenPtr pScreen;
- XdbeScreenVisualInfo *pScrVisInfo;
-
+ DbeScreenPrivPtr pDbeScreenPriv;
+ xDbeGetVisualInfoReply rep;
+ Drawable *drawables;
+ DrawablePtr *pDrawables = NULL;
+ register int i, j, rc;
+ register int count; /* number of visual infos in reply */
+ register int length; /* length of reply */
+ ScreenPtr pScreen;
+ XdbeScreenVisualInfo *pScrVisInfo;
REQUEST_AT_LEAST_SIZE(xDbeGetVisualInfoReq);
if (stuff->n > UINT32_MAX / sizeof(DrawablePtr))
- return BadAlloc;
+ return BadAlloc;
/* Make sure any specified drawables are valid. */
- if (stuff->n != 0)
- {
- if (!(pDrawables = (DrawablePtr *)malloc(stuff->n *
- sizeof(DrawablePtr))))
- {
+ if (stuff->n != 0) {
+ if (!(pDrawables = (DrawablePtr *) malloc(stuff->n *
+ sizeof(DrawablePtr)))) {
return BadAlloc;
}
- drawables = (Drawable *)&stuff[1];
+ drawables = (Drawable *) &stuff[1];
- for (i = 0; i < stuff->n; i++)
- {
- rc = dixLookupDrawable(pDrawables+i, drawables[i], client, 0,
- DixGetAttrAccess);
- if (rc != Success) {
+ for (i = 0; i < stuff->n; i++) {
+ rc = dixLookupDrawable(pDrawables + i, drawables[i], client, 0,
+ DixGetAttrAccess);
+ if (rc != Success) {
free(pDrawables);
return rc;
}
@@ -683,8 +635,7 @@ ProcDbeGetVisualInfo(ClientPtr client)
}
count = (stuff->n == 0) ? screenInfo.numScreens : stuff->n;
- if (!(pScrVisInfo = calloc(count, sizeof(XdbeScreenVisualInfo))))
- {
+ if (!(pScrVisInfo = calloc(count, sizeof(XdbeScreenVisualInfo)))) {
free(pDrawables);
return BadAlloc;
@@ -692,22 +643,20 @@ ProcDbeGetVisualInfo(ClientPtr client)
length = 0;
- for (i = 0; i < count; i++)
- {
+ for (i = 0; i < count; i++) {
pScreen = (stuff->n == 0) ? screenInfo.screens[i] :
- pDrawables[i]->pScreen;
+ pDrawables[i]->pScreen;
pDbeScreenPriv = DBE_SCREEN_PRIV(pScreen);
- rc = XaceHook(XACE_SCREEN_ACCESS, client, pScreen, DixGetAttrAccess);
+ rc = XaceHook(XACE_SCREEN_ACCESS, client, pScreen, DixGetAttrAccess);
if (rc != Success)
goto freeScrVisInfo;
- if (!(*pDbeScreenPriv->GetVisualInfo)(pScreen, &pScrVisInfo[i]))
- {
+ if (!(*pDbeScreenPriv->GetVisualInfo) (pScreen, &pScrVisInfo[i])) {
/* We failed to alloc pScrVisInfo[i].visinfo. */
rc = BadAlloc;
- /* Free visinfos that we allocated for previous screen infos.*/
+ /* Free visinfos that we allocated for previous screen infos. */
goto freeScrVisInfo;
}
@@ -718,53 +667,48 @@ ProcDbeGetVisualInfo(ClientPtr client)
length += pScrVisInfo[i].count * sizeof(xDbeVisInfo);
}
- rep.type = X_Reply;
+ rep.type = X_Reply;
rep.sequenceNumber = client->sequence;
- rep.length = bytes_to_int32(length);
- rep.m = count;
+ rep.length = bytes_to_int32(length);
+ rep.m = count;
- if (client->swapped)
- {
+ if (client->swapped) {
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swapl(&rep.m);
}
/* Send off reply. */
- WriteToClient(client, sizeof(xDbeGetVisualInfoReply), (char *)&rep);
+ WriteToClient(client, sizeof(xDbeGetVisualInfoReply), (char *) &rep);
- for (i = 0; i < count; i++)
- {
- CARD32 data32;
+ for (i = 0; i < count; i++) {
+ CARD32 data32;
/* For each screen in the reply, send off the visual info */
/* Send off number of visuals. */
- data32 = (CARD32)pScrVisInfo[i].count;
+ data32 = (CARD32) pScrVisInfo[i].count;
- if (client->swapped)
- {
+ if (client->swapped) {
swapl(&data32);
}
- WriteToClient(client, sizeof(CARD32), (char *)&data32);
+ WriteToClient(client, sizeof(CARD32), (char *) &data32);
/* Now send off visual info items. */
- for (j = 0; j < pScrVisInfo[i].count; j++)
- {
- xDbeVisInfo visInfo;
+ for (j = 0; j < pScrVisInfo[i].count; j++) {
+ xDbeVisInfo visInfo;
/* Copy the data in the client data structure to a protocol
* data structure. We will send data to the client from the
* protocol data structure.
*/
- visInfo.visualID = (CARD32)pScrVisInfo[i].visinfo[j].visual;
- visInfo.depth = (CARD8) pScrVisInfo[i].visinfo[j].depth;
+ visInfo.visualID = (CARD32) pScrVisInfo[i].visinfo[j].visual;
+ visInfo.depth = (CARD8) pScrVisInfo[i].visinfo[j].depth;
visInfo.perfLevel = (CARD8) pScrVisInfo[i].visinfo[j].perflevel;
- if (client->swapped)
- {
+ if (client->swapped) {
swapl(&visInfo.visualID);
/* We do not need to swap depth and perfLevel since they are
@@ -773,16 +717,16 @@ ProcDbeGetVisualInfo(ClientPtr client)
}
/* Write visualID(32), depth(8), perfLevel(8), and pad(16). */
- WriteToClient(client, 2*sizeof(CARD32), (char *)&visInfo.visualID);
+ WriteToClient(client, 2 * sizeof(CARD32),
+ (char *) &visInfo.visualID);
}
}
rc = Success;
- freeScrVisInfo:
+ freeScrVisInfo:
/* Clean up memory. */
- for (i = 0; i < count; i++)
- {
+ for (i = 0; i < count; i++) {
free(pScrVisInfo[i].visinfo);
}
free(pScrVisInfo);
@@ -791,8 +735,7 @@ ProcDbeGetVisualInfo(ClientPtr client)
return rc;
-} /* ProcDbeGetVisualInfo() */
-
+} /* ProcDbeGetVisualInfo() */
/******************************************************************************
*
@@ -813,42 +756,37 @@ static int
ProcDbeGetBackBufferAttributes(ClientPtr client)
{
REQUEST(xDbeGetBackBufferAttributesReq);
- xDbeGetBackBufferAttributesReply rep;
- DbeWindowPrivPtr pDbeWindowPriv;
- int rc;
-
+ xDbeGetBackBufferAttributesReply rep;
+ DbeWindowPrivPtr pDbeWindowPriv;
+ int rc;
REQUEST_SIZE_MATCH(xDbeGetBackBufferAttributesReq);
- rc = dixLookupResourceByType((pointer *)&pDbeWindowPriv, stuff->buffer,
- dbeWindowPrivResType, client,
- DixGetAttrAccess);
- if (rc == Success)
- {
+ rc = dixLookupResourceByType((pointer *) &pDbeWindowPriv, stuff->buffer,
+ dbeWindowPrivResType, client,
+ DixGetAttrAccess);
+ if (rc == Success) {
rep.attributes = pDbeWindowPriv->pWindow->drawable.id;
}
- else
- {
+ else {
rep.attributes = None;
}
-
- rep.type = X_Reply;
+
+ rep.type = X_Reply;
rep.sequenceNumber = client->sequence;
- rep.length = 0;
-
- if (client->swapped)
- {
+ rep.length = 0;
+
+ if (client->swapped) {
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swapl(&rep.attributes);
}
WriteToClient(client, sizeof(xDbeGetBackBufferAttributesReply),
- (char *)&rep);
+ (char *) &rep);
return Success;
-} /* ProcDbeGetbackBufferAttributes() */
-
+} /* ProcDbeGetbackBufferAttributes() */
/******************************************************************************
*
@@ -865,39 +803,36 @@ ProcDbeDispatch(ClientPtr client)
{
REQUEST(xReq);
+ switch (stuff->data) {
+ case X_DbeGetVersion:
+ return (ProcDbeGetVersion(client));
- switch (stuff->data)
- {
- case X_DbeGetVersion:
- return(ProcDbeGetVersion(client));
+ case X_DbeAllocateBackBufferName:
+ return (ProcDbeAllocateBackBufferName(client));
- case X_DbeAllocateBackBufferName:
- return(ProcDbeAllocateBackBufferName(client));
+ case X_DbeDeallocateBackBufferName:
+ return (ProcDbeDeallocateBackBufferName(client));
- case X_DbeDeallocateBackBufferName:
- return(ProcDbeDeallocateBackBufferName(client));
+ case X_DbeSwapBuffers:
+ return (ProcDbeSwapBuffers(client));
- case X_DbeSwapBuffers:
- return(ProcDbeSwapBuffers(client));
+ case X_DbeBeginIdiom:
+ return (ProcDbeBeginIdiom(client));
- case X_DbeBeginIdiom:
- return(ProcDbeBeginIdiom(client));
-
- case X_DbeEndIdiom:
- return Success;
+ case X_DbeEndIdiom:
+ return Success;
- case X_DbeGetVisualInfo:
- return(ProcDbeGetVisualInfo(client));
+ case X_DbeGetVisualInfo:
+ return (ProcDbeGetVisualInfo(client));
- case X_DbeGetBackBufferAttributes:
- return(ProcDbeGetBackBufferAttributes(client));
+ case X_DbeGetBackBufferAttributes:
+ return (ProcDbeGetBackBufferAttributes(client));
- default:
- return BadRequest;
+ default:
+ return BadRequest;
}
-} /* ProcDbeDispatch() */
-
+} /* ProcDbeDispatch() */
/******************************************************************************
*
@@ -921,10 +856,9 @@ SProcDbeGetVersion(ClientPtr client)
REQUEST(xDbeGetVersionReq);
swaps(&stuff->length);
- return(ProcDbeGetVersion(client));
-
-} /* SProcDbeGetVersion() */
+ return (ProcDbeGetVersion(client));
+} /* SProcDbeGetVersion() */
/******************************************************************************
*
@@ -961,10 +895,9 @@ SProcDbeAllocateBackBufferName(ClientPtr client)
swapl(&stuff->buffer);
/* stuff->swapAction is a byte. We do not need to swap this field. */
- return(ProcDbeAllocateBackBufferName(client));
-
-} /* SProcDbeAllocateBackBufferName() */
+ return (ProcDbeAllocateBackBufferName(client));
+} /* SProcDbeAllocateBackBufferName() */
/******************************************************************************
*
@@ -986,17 +919,16 @@ SProcDbeAllocateBackBufferName(ClientPtr client)
static int
SProcDbeDeallocateBackBufferName(ClientPtr client)
{
- REQUEST (xDbeDeallocateBackBufferNameReq);
+ REQUEST(xDbeDeallocateBackBufferNameReq);
swaps(&stuff->length);
REQUEST_SIZE_MATCH(xDbeDeallocateBackBufferNameReq);
swapl(&stuff->buffer);
- return(ProcDbeDeallocateBackBufferName(client));
-
-} /* SProcDbeDeallocateBackBufferName() */
+ return (ProcDbeDeallocateBackBufferName(client));
+} /* SProcDbeDeallocateBackBufferName() */
/******************************************************************************
*
@@ -1023,33 +955,29 @@ static int
SProcDbeSwapBuffers(ClientPtr client)
{
REQUEST(xDbeSwapBuffersReq);
- register int i;
- xDbeSwapInfo *pSwapInfo;
-
+ register int i;
+ xDbeSwapInfo *pSwapInfo;
swaps(&stuff->length);
REQUEST_AT_LEAST_SIZE(xDbeSwapBuffersReq);
swapl(&stuff->n);
- if (stuff->n != 0)
- {
- pSwapInfo = (xDbeSwapInfo *)stuff+1;
+ if (stuff->n != 0) {
+ pSwapInfo = (xDbeSwapInfo *) stuff + 1;
/* The swap info following the fix part of this request is a window(32)
* followed by a 1 byte swap action and then 3 pad bytes. We only need
* to swap the window information.
*/
- for (i = 0; i < stuff->n; i++)
- {
+ for (i = 0; i < stuff->n; i++) {
swapl(&pSwapInfo->window);
}
}
- return(ProcDbeSwapBuffers(client));
-
-} /* SProcDbeSwapBuffers() */
+ return (ProcDbeSwapBuffers(client));
+} /* SProcDbeSwapBuffers() */
/******************************************************************************
*
@@ -1073,10 +1001,9 @@ SProcDbeBeginIdiom(ClientPtr client)
REQUEST(xDbeBeginIdiomReq);
swaps(&stuff->length);
- return(ProcDbeBeginIdiom(client));
-
-} /* SProcDbeBeginIdiom() */
+ return (ProcDbeBeginIdiom(client));
+} /* SProcDbeBeginIdiom() */
/******************************************************************************
*
@@ -1106,10 +1033,9 @@ SProcDbeGetVisualInfo(ClientPtr client)
swapl(&stuff->n);
SwapRestL(stuff);
- return(ProcDbeGetVisualInfo(client));
-
-} /* SProcDbeGetVisualInfo() */
+ return (ProcDbeGetVisualInfo(client));
+} /* SProcDbeGetVisualInfo() */
/******************************************************************************
*
@@ -1130,17 +1056,16 @@ SProcDbeGetVisualInfo(ClientPtr client)
static int
SProcDbeGetBackBufferAttributes(ClientPtr client)
{
- REQUEST (xDbeGetBackBufferAttributesReq);
+ REQUEST(xDbeGetBackBufferAttributesReq);
swaps(&stuff->length);
REQUEST_SIZE_MATCH(xDbeGetBackBufferAttributesReq);
swapl(&stuff->buffer);
- return(ProcDbeGetBackBufferAttributes(client));
-
-} /* SProcDbeGetBackBufferAttributes() */
+ return (ProcDbeGetBackBufferAttributes(client));
+} /* SProcDbeGetBackBufferAttributes() */
/******************************************************************************
*
@@ -1157,39 +1082,36 @@ SProcDbeDispatch(ClientPtr client)
{
REQUEST(xReq);
+ switch (stuff->data) {
+ case X_DbeGetVersion:
+ return (SProcDbeGetVersion(client));
- switch (stuff->data)
- {
- case X_DbeGetVersion:
- return(SProcDbeGetVersion(client));
+ case X_DbeAllocateBackBufferName:
+ return (SProcDbeAllocateBackBufferName(client));
- case X_DbeAllocateBackBufferName:
- return(SProcDbeAllocateBackBufferName(client));
+ case X_DbeDeallocateBackBufferName:
+ return (SProcDbeDeallocateBackBufferName(client));
- case X_DbeDeallocateBackBufferName:
- return(SProcDbeDeallocateBackBufferName(client));
+ case X_DbeSwapBuffers:
+ return (SProcDbeSwapBuffers(client));
- case X_DbeSwapBuffers:
- return(SProcDbeSwapBuffers(client));
+ case X_DbeBeginIdiom:
+ return (SProcDbeBeginIdiom(client));
- case X_DbeBeginIdiom:
- return(SProcDbeBeginIdiom(client));
-
- case X_DbeEndIdiom:
- return Success;
+ case X_DbeEndIdiom:
+ return Success;
- case X_DbeGetVisualInfo:
- return(SProcDbeGetVisualInfo(client));
+ case X_DbeGetVisualInfo:
+ return (SProcDbeGetVisualInfo(client));
- case X_DbeGetBackBufferAttributes:
- return(SProcDbeGetBackBufferAttributes(client));
+ case X_DbeGetBackBufferAttributes:
+ return (SProcDbeGetBackBufferAttributes(client));
- default:
- return BadRequest;
+ default:
+ return BadRequest;
}
-} /* SProcDbeDispatch() */
-
+} /* SProcDbeDispatch() */
/******************************************************************************
*
@@ -1209,12 +1131,11 @@ SProcDbeDispatch(ClientPtr client)
static Bool
DbeSetupBackgroundPainter(WindowPtr pWin, GCPtr pGC)
{
- ChangeGCVal gcvalues[4];
- int ts_x_origin, ts_y_origin;
- PixUnion background;
- int backgroundState;
- Mask gcmask;
-
+ ChangeGCVal gcvalues[4];
+ int ts_x_origin, ts_y_origin;
+ PixUnion background;
+ int backgroundState;
+ Mask gcmask;
/* First take care of any ParentRelative stuff by altering the
* tile/stipple origin to match the coordinates of the upper-left
@@ -1222,40 +1143,37 @@ DbeSetupBackgroundPainter(WindowPtr pWin, GCPtr pGC)
* This coordinate is, of course, negative.
*/
ts_x_origin = ts_y_origin = 0;
- while (pWin->backgroundState == ParentRelative)
- {
+ while (pWin->backgroundState == ParentRelative) {
ts_x_origin -= pWin->origin.x;
ts_y_origin -= pWin->origin.y;
pWin = pWin->parent;
}
backgroundState = pWin->backgroundState;
- background = pWin->background;
-
- switch (backgroundState)
- {
- case BackgroundPixel:
- gcvalues[0].val = background.pixel;
- gcvalues[1].val = FillSolid;
- gcmask = GCForeground|GCFillStyle;
- break;
-
- case BackgroundPixmap:
- gcvalues[0].val = FillTiled;
- gcvalues[1].ptr = background.pixmap;
- gcvalues[2].val = ts_x_origin;
- gcvalues[3].val = ts_y_origin;
- gcmask = GCFillStyle|GCTile|GCTileStipXOrigin|GCTileStipYOrigin;
- break;
-
- default:
- /* pWin->backgroundState == None */
- return FALSE;
+ background = pWin->background;
+
+ switch (backgroundState) {
+ case BackgroundPixel:
+ gcvalues[0].val = background.pixel;
+ gcvalues[1].val = FillSolid;
+ gcmask = GCForeground | GCFillStyle;
+ break;
+
+ case BackgroundPixmap:
+ gcvalues[0].val = FillTiled;
+ gcvalues[1].ptr = background.pixmap;
+ gcvalues[2].val = ts_x_origin;
+ gcvalues[3].val = ts_y_origin;
+ gcmask = GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin;
+ break;
+
+ default:
+ /* pWin->backgroundState == None */
+ return FALSE;
}
return ChangeGC(NullClient, pGC, gcmask, gcvalues) == 0;
-} /* DbeSetupBackgroundPainter() */
-
+} /* DbeSetupBackgroundPainter() */
/******************************************************************************
*
@@ -1278,8 +1196,7 @@ DbeDrawableDelete(pointer pDrawable, XID id)
{
return Success;
-} /* DbeDrawableDelete() */
-
+} /* DbeDrawableDelete() */
/******************************************************************************
*
@@ -1295,10 +1212,9 @@ DbeDrawableDelete(pointer pDrawable, XID id)
static int
DbeWindowPrivDelete(pointer pDbeWinPriv, XID id)
{
- DbeScreenPrivPtr pDbeScreenPriv;
- DbeWindowPrivPtr pDbeWindowPriv = (DbeWindowPrivPtr)pDbeWinPriv;
- int i;
-
+ DbeScreenPrivPtr pDbeScreenPriv;
+ DbeWindowPrivPtr pDbeWindowPriv = (DbeWindowPrivPtr) pDbeWinPriv;
+ int i;
/*
**************************************************************************
@@ -1308,27 +1224,23 @@ DbeWindowPrivDelete(pointer pDbeWinPriv, XID id)
/* Find the ID in the ID array. */
i = 0;
- while ((i < pDbeWindowPriv->nBufferIDs) && (pDbeWindowPriv->IDs[i] != id))
- {
+ while ((i < pDbeWindowPriv->nBufferIDs) && (pDbeWindowPriv->IDs[i] != id)) {
i++;
}
- if (i == pDbeWindowPriv->nBufferIDs)
- {
+ if (i == pDbeWindowPriv->nBufferIDs) {
/* We did not find the ID in the array. We should never get here. */
return BadValue;
}
/* Remove the ID from the array. */
- if (i < (pDbeWindowPriv->nBufferIDs - 1))
- {
+ if (i < (pDbeWindowPriv->nBufferIDs - 1)) {
/* Compress the buffer ID array, overwriting the ID in the process. */
- memmove(&pDbeWindowPriv->IDs[i], &pDbeWindowPriv->IDs[i+1],
- (pDbeWindowPriv->nBufferIDs - i - 1) * sizeof(XID));
+ memmove(&pDbeWindowPriv->IDs[i], &pDbeWindowPriv->IDs[i + 1],
+ (pDbeWindowPriv->nBufferIDs - i - 1) * sizeof(XID));
}
- else
- {
+ else {
/* We are removing the last ID in the array, in which case, the
* assignement below is all that we need to do.
*/
@@ -1341,9 +1253,8 @@ DbeWindowPrivDelete(pointer pDbeWinPriv, XID id)
* buffer IDs will fit in the static array.
*/
- if ((pDbeWindowPriv->maxAvailableIDs > DBE_INIT_MAX_IDS) &&
- (pDbeWindowPriv->nBufferIDs == DBE_INIT_MAX_IDS))
- {
+ if ((pDbeWindowPriv->maxAvailableIDs > DBE_INIT_MAX_IDS) &&
+ (pDbeWindowPriv->nBufferIDs == DBE_INIT_MAX_IDS)) {
/* Copy the IDs back into the static array. */
memcpy(pDbeWindowPriv->initIDs, pDbeWindowPriv->IDs,
DBE_INIT_MAX_IDS * sizeof(XID));
@@ -1354,17 +1265,15 @@ DbeWindowPrivDelete(pointer pDbeWinPriv, XID id)
pDbeWindowPriv->maxAvailableIDs = DBE_INIT_MAX_IDS;
}
-
/*
**************************************************************************
** Perform DDX level tasks.
**************************************************************************
*/
- pDbeScreenPriv = DBE_SCREEN_PRIV_FROM_WINDOW_PRIV(
- (DbeWindowPrivPtr)pDbeWindowPriv);
- (*pDbeScreenPriv->WinPrivDelete)((DbeWindowPrivPtr)pDbeWindowPriv, id);
-
+ pDbeScreenPriv = DBE_SCREEN_PRIV_FROM_WINDOW_PRIV((DbeWindowPrivPtr)
+ pDbeWindowPriv);
+ (*pDbeScreenPriv->WinPrivDelete) ((DbeWindowPrivPtr) pDbeWindowPriv, id);
/*
**************************************************************************
@@ -1373,20 +1282,18 @@ DbeWindowPrivDelete(pointer pDbeWinPriv, XID id)
**************************************************************************
*/
- if (pDbeWindowPriv->nBufferIDs == 0)
- {
+ if (pDbeWindowPriv->nBufferIDs == 0) {
/* Reset the DBE window priv pointer. */
- dixSetPrivate(&pDbeWindowPriv->pWindow->devPrivates, dbeWindowPrivKey,
- NULL);
+ dixSetPrivate(&pDbeWindowPriv->pWindow->devPrivates, dbeWindowPrivKey,
+ NULL);
/* We are done with the window priv. */
- dixFreeObjectWithPrivates(pDbeWindowPriv, PRIVATE_DBE_WINDOW);
+ dixFreeObjectWithPrivates(pDbeWindowPriv, PRIVATE_DBE_WINDOW);
}
return Success;
-} /* DbeWindowPrivDelete() */
-
+} /* DbeWindowPrivDelete() */
/******************************************************************************
*
@@ -1400,30 +1307,27 @@ DbeWindowPrivDelete(pointer pDbeWinPriv, XID id)
*
*****************************************************************************/
static void
-DbeResetProc(ExtensionEntry *extEntry)
+DbeResetProc(ExtensionEntry * extEntry)
{
- int i;
- ScreenPtr pScreen;
- DbeScreenPrivPtr pDbeScreenPriv;
-
- for (i = 0; i < screenInfo.numScreens; i++)
- {
- pScreen = screenInfo.screens[i];
- pDbeScreenPriv = DBE_SCREEN_PRIV(pScreen);
-
- if (pDbeScreenPriv)
- {
- /* Unwrap DestroyWindow, which was wrapped in DbeExtensionInit().*/
+ int i;
+ ScreenPtr pScreen;
+ DbeScreenPrivPtr pDbeScreenPriv;
+
+ for (i = 0; i < screenInfo.numScreens; i++) {
+ pScreen = screenInfo.screens[i];
+ pDbeScreenPriv = DBE_SCREEN_PRIV(pScreen);
+
+ if (pDbeScreenPriv) {
+ /* Unwrap DestroyWindow, which was wrapped in DbeExtensionInit(). */
pScreen->DestroyWindow = pDbeScreenPriv->DestroyWindow;
- if (pDbeScreenPriv->ResetProc)
- (*pDbeScreenPriv->ResetProc)(pScreen);
+ if (pDbeScreenPriv->ResetProc)
+ (*pDbeScreenPriv->ResetProc) (pScreen);
- free(pDbeScreenPriv);
- }
+ free(pDbeScreenPriv);
+ }
}
-} /* DbeResetProc() */
-
+} /* DbeResetProc() */
/******************************************************************************
*
@@ -1440,11 +1344,10 @@ DbeResetProc(ExtensionEntry *extEntry)
static Bool
DbeDestroyWindow(WindowPtr pWin)
{
- DbeScreenPrivPtr pDbeScreenPriv;
- DbeWindowPrivPtr pDbeWindowPriv;
- ScreenPtr pScreen;
- Bool ret;
-
+ DbeScreenPrivPtr pDbeScreenPriv;
+ DbeWindowPrivPtr pDbeWindowPriv;
+ ScreenPtr pScreen;
+ Bool ret;
/*
**************************************************************************
@@ -1452,8 +1355,8 @@ DbeDestroyWindow(WindowPtr pWin)
**************************************************************************
*/
- pScreen = pWin->drawable.pScreen;
- pDbeScreenPriv = DBE_SCREEN_PRIV(pScreen);
+ pScreen = pWin->drawable.pScreen;
+ pDbeScreenPriv = DBE_SCREEN_PRIV(pScreen);
pScreen->DestroyWindow = pDbeScreenPriv->DestroyWindow;
/*
@@ -1465,10 +1368,8 @@ DbeDestroyWindow(WindowPtr pWin)
**************************************************************************
*/
- if ((pDbeWindowPriv = DBE_WINDOW_PRIV(pWin)))
- {
- while (pDbeWindowPriv)
- {
+ if ((pDbeWindowPriv = DBE_WINDOW_PRIV(pWin))) {
+ while (pDbeWindowPriv) {
/* *DbeWinPrivDelete() will free the window private and set it to
* NULL if there are no more buffer IDs associated with this
* window.
@@ -1484,7 +1385,7 @@ DbeDestroyWindow(WindowPtr pWin)
**************************************************************************
*/
- ret = (*pScreen->DestroyWindow)(pWin);
+ ret = (*pScreen->DestroyWindow) (pWin);
/*
**************************************************************************
@@ -1506,8 +1407,7 @@ DbeDestroyWindow(WindowPtr pWin)
return ret;
-} /* DbeDestroyWindow() */
-
+} /* DbeDestroyWindow() */
/******************************************************************************
*
@@ -1522,67 +1422,65 @@ DbeDestroyWindow(WindowPtr pWin)
void
DbeExtensionInit(void)
{
- ExtensionEntry *extEntry;
- register int i, j;
- ScreenPtr pScreen = NULL;
- DbeScreenPrivPtr pDbeScreenPriv;
- int nStubbedScreens = 0;
- Bool ddxInitSuccess;
+ ExtensionEntry *extEntry;
+ register int i, j;
+ ScreenPtr pScreen = NULL;
+ DbeScreenPrivPtr pDbeScreenPriv;
+ int nStubbedScreens = 0;
+ Bool ddxInitSuccess;
#ifdef PANORAMIX
- if(!noPanoramiXExtension) return;
+ if (!noPanoramiXExtension)
+ return;
#endif
/* Create the resource types. */
dbeDrawableResType =
CreateNewResourceType(DbeDrawableDelete, "dbeDrawable");
if (!dbeDrawableResType)
- return;
+ return;
dbeDrawableResType |= RC_DRAWABLE;
dbeWindowPrivResType =
CreateNewResourceType(DbeWindowPrivDelete, "dbeWindow");
if (!dbeWindowPrivResType)
- return;
+ return;
if (!dixRegisterPrivateKey(&dbeScreenPrivKeyRec, PRIVATE_SCREEN, 0))
- return;
+ return;
if (!dixRegisterPrivateKey(&dbeWindowPrivKeyRec, PRIVATE_WINDOW, 0))
- return;
+ return;
- for (i = 0; i < screenInfo.numScreens; i++)
- {
+ for (i = 0; i < screenInfo.numScreens; i++) {
/* For each screen, set up DBE screen privates and init DIX and DDX
* interface.
*/
- pScreen = screenInfo.screens[i];
+ pScreen = screenInfo.screens[i];
- if (!(pDbeScreenPriv = malloc (sizeof (DbeScreenPrivRec))))
- {
+ if (!(pDbeScreenPriv = malloc(sizeof(DbeScreenPrivRec)))) {
/* If we can not alloc a window or screen private,
* then free any privates that we already alloc'ed and return
*/
- for (j = 0; j < i; j++)
- {
- free(dixLookupPrivate(&screenInfo.screens[j]->devPrivates,
- dbeScreenPrivKey));
- dixSetPrivate(&screenInfo.screens[j]->devPrivates,
- dbeScreenPrivKey, NULL);
- }
- return;
- }
+ for (j = 0; j < i; j++) {
+ free(dixLookupPrivate(&screenInfo.screens[j]->devPrivates,
+ dbeScreenPrivKey));
+ dixSetPrivate(&screenInfo.screens[j]->devPrivates,
+ dbeScreenPrivKey, NULL);
+ }
+ return;
+ }
- dixSetPrivate(&pScreen->devPrivates, dbeScreenPrivKey, pDbeScreenPriv);
+ dixSetPrivate(&pScreen->devPrivates, dbeScreenPrivKey, pDbeScreenPriv);
{
/* We don't have DDX support for DBE anymore */
#ifndef DISABLE_MI_DBE_BY_DEFAULT
/* Setup DIX. */
- pDbeScreenPriv->SetupBackgroundPainter = DbeSetupBackgroundPainter;
+ pDbeScreenPriv->SetupBackgroundPainter = DbeSetupBackgroundPainter;
/* Setup DDX. */
ddxInitSuccess = miDbeInit(pScreen, pDbeScreenPriv);
@@ -1592,17 +1490,15 @@ DbeExtensionInit(void)
*/
pDbeScreenPriv = DBE_SCREEN_PRIV(pScreen);
- if (ddxInitSuccess)
- {
+ if (ddxInitSuccess) {
/* Wrap DestroyWindow. The DDX initialization function
* already wrapped PositionWindow for us.
*/
pDbeScreenPriv->DestroyWindow = pScreen->DestroyWindow;
- pScreen->DestroyWindow = DbeDestroyWindow;
+ pScreen->DestroyWindow = DbeDestroyWindow;
}
- else
- {
+ else {
/* DDX initialization failed. Stub the screen. */
DbeStubScreen(pDbeScreenPriv, &nStubbedScreens);
}
@@ -1612,31 +1508,27 @@ DbeExtensionInit(void)
}
- } /* for (i = 0; i < screenInfo.numScreens; i++) */
-
+ } /* for (i = 0; i < screenInfo.numScreens; i++) */
- if (nStubbedScreens == screenInfo.numScreens)
- {
- /* All screens stubbed. Clean up and return. */
+ if (nStubbedScreens == screenInfo.numScreens) {
+ /* All screens stubbed. Clean up and return. */
- for (i = 0; i < screenInfo.numScreens; i++)
- {
- free(dixLookupPrivate(&screenInfo.screens[i]->devPrivates,
- dbeScreenPrivKey));
- dixSetPrivate(&pScreen->devPrivates, dbeScreenPrivKey, NULL);
+ for (i = 0; i < screenInfo.numScreens; i++) {
+ free(dixLookupPrivate(&screenInfo.screens[i]->devPrivates,
+ dbeScreenPrivKey));
+ dixSetPrivate(&pScreen->devPrivates, dbeScreenPrivKey, NULL);
}
return;
}
-
/* Now add the extension. */
- extEntry = AddExtension(DBE_PROTOCOL_NAME, DbeNumberEvents,
+ extEntry = AddExtension(DBE_PROTOCOL_NAME, DbeNumberEvents,
DbeNumberErrors, ProcDbeDispatch, SProcDbeDispatch,
DbeResetProc, StandardMinorOpcode);
dbeErrorBase = extEntry->errorBase;
- SetResourceTypeErrorValue(dbeWindowPrivResType, dbeErrorBase + DbeBadBuffer);
+ SetResourceTypeErrorValue(dbeWindowPrivResType,
+ dbeErrorBase + DbeBadBuffer);
SetResourceTypeErrorValue(dbeDrawableResType, dbeErrorBase + DbeBadBuffer);
-} /* DbeExtensionInit() */
-
+} /* DbeExtensionInit() */
diff --git a/dbe/dbestruct.h b/dbe/dbestruct.h
index 9c383cef8..9ea9eb695 100644
--- a/dbe/dbestruct.h
+++ b/dbe/dbestruct.h
@@ -33,7 +33,6 @@
#ifndef DBE_STRUCT_H
#define DBE_STRUCT_H
-
/* INCLUDES */
#define NEED_DBE_PROTOCOL
@@ -41,20 +40,16 @@
#include "windowstr.h"
#include "privates.h"
-typedef struct
-{
- VisualID visual; /* one visual ID that supports double-buffering */
- int depth; /* depth of visual in bits */
- int perflevel; /* performance level of visual */
-}
-XdbeVisualInfo;
-
-typedef struct
-{
- int count; /* number of items in visual_depth */
- XdbeVisualInfo *visinfo; /* list of visuals & depths for scrn */
-}
-XdbeScreenVisualInfo;
+typedef struct {
+ VisualID visual; /* one visual ID that supports double-buffering */
+ int depth; /* depth of visual in bits */
+ int perflevel; /* performance level of visual */
+} XdbeVisualInfo;
+
+typedef struct {
+ int count; /* number of items in visual_depth */
+ XdbeVisualInfo *visinfo; /* list of visuals & depths for scrn */
+} XdbeScreenVisualInfo;
/* DEFINES */
@@ -88,17 +83,16 @@ XdbeScreenVisualInfo;
/* Marker for free elements in the buffer ID array. */
#define DBE_FREE_ID_ELEMENT 0
-extern _X_EXPORT void DbeExtensionInit (void);
+extern _X_EXPORT void DbeExtensionInit(void);
/* TYPEDEFS */
/* Record used to pass swap information between DIX and DDX swapping
* procedures.
*/
-typedef struct _DbeSwapInfoRec
-{
- WindowPtr pWindow;
- unsigned char swapAction;
+typedef struct _DbeSwapInfoRec {
+ WindowPtr pWindow;
+ unsigned char swapAction;
} DbeSwapInfoRec, *DbeSwapInfoPtr;
@@ -108,38 +102,37 @@ typedef struct _DbeSwapInfoRec
******************************************************************************
*/
-typedef struct _DbeWindowPrivRec
-{
+typedef struct _DbeWindowPrivRec {
/* A pointer to the window with which the DBE window private (buffer) is
* associated.
*/
- WindowPtr pWindow;
+ WindowPtr pWindow;
/* Last known swap action for this buffer. Legal values for this field
* are XdbeUndefined, XdbeBackground, XdbeUntouched, and XdbeCopied.
*/
- unsigned char swapAction;
+ unsigned char swapAction;
/* Last known buffer size.
*/
- unsigned short width, height;
+ unsigned short width, height;
/* Coordinates used for static gravity when the window is positioned.
*/
- short x, y;
+ short x, y;
/* Number of XIDs associated with this buffer.
*/
- int nBufferIDs;
+ int nBufferIDs;
/* Capacity of the current buffer ID array, IDs. */
- int maxAvailableIDs;
+ int maxAvailableIDs;
/* Pointer to the array of buffer IDs. This initially points to initIDs.
* When the static limit of the initIDs array is reached, the array is
* reallocated and this pointer is set to the new array instead of initIDs.
*/
- XID *IDs;
+ XID *IDs;
/* Initial array of buffer IDs. We are defining the XID array within the
* window priv to optimize for data locality. In most cases, only one
@@ -150,65 +143,55 @@ typedef struct _DbeWindowPrivRec
* more IDs than can fit in this static array, we will allocate a larger
* array to use, possibly suffering a performance loss.
*/
- XID initIDs[DBE_INIT_MAX_IDS];
+ XID initIDs[DBE_INIT_MAX_IDS];
/* Device-specific private information.
*/
- PrivateRec *devPrivates;
+ PrivateRec *devPrivates;
} DbeWindowPrivRec, *DbeWindowPrivPtr;
-
/*
******************************************************************************
** Per-screen data
******************************************************************************
*/
-typedef struct _DbeScreenPrivRec
-{
+typedef struct _DbeScreenPrivRec {
/* Wrapped functions
* It is the responsibilty of the DDX layer to wrap PositionWindow().
* DbeExtensionInit wraps DestroyWindow().
*/
PositionWindowProcPtr PositionWindow;
- DestroyWindowProcPtr DestroyWindow;
+ DestroyWindowProcPtr DestroyWindow;
/* Per-screen DIX routines */
- Bool (*SetupBackgroundPainter)(
- WindowPtr /*pWin*/,
- GCPtr /*pGC*/
-);
+ Bool (*SetupBackgroundPainter) (WindowPtr /*pWin */ ,
+ GCPtr /*pGC */
+ );
/* Per-screen DDX routines */
- Bool (*GetVisualInfo)(
- ScreenPtr /*pScreen*/,
- XdbeScreenVisualInfo * /*pVisInfo*/
-);
- int (*AllocBackBufferName)(
- WindowPtr /*pWin*/,
- XID /*bufId*/,
- int /*swapAction*/
-);
- int (*SwapBuffers)(
- ClientPtr /*client*/,
- int * /*pNumWindows*/,
- DbeSwapInfoPtr /*swapInfo*/
-);
- void (*BeginIdiom)(
- ClientPtr /*client*/
-);
- void (*EndIdiom)(
- ClientPtr /*client*/
-);
- void (*WinPrivDelete)(
- DbeWindowPrivPtr /*pDbeWindowPriv*/,
- XID /*bufId*/
-);
- void (*ResetProc)(
- ScreenPtr /*pScreen*/
-);
+ Bool (*GetVisualInfo) (ScreenPtr /*pScreen */ ,
+ XdbeScreenVisualInfo * /*pVisInfo */
+ );
+ int (*AllocBackBufferName) (WindowPtr /*pWin */ ,
+ XID /*bufId */ ,
+ int /*swapAction */
+ );
+ int (*SwapBuffers) (ClientPtr /*client */ ,
+ int * /*pNumWindows */ ,
+ DbeSwapInfoPtr /*swapInfo */
+ );
+ void (*BeginIdiom) (ClientPtr /*client */
+ );
+ void (*EndIdiom) (ClientPtr /*client */
+ );
+ void (*WinPrivDelete) (DbeWindowPrivPtr /*pDbeWindowPriv */ ,
+ XID /*bufId */
+ );
+ void (*ResetProc) (ScreenPtr /*pScreen */
+ );
} DbeScreenPrivRec, *DbeScreenPrivPtr;
-#endif /* DBE_STRUCT_H */
+#endif /* DBE_STRUCT_H */
diff --git a/dbe/midbe.c b/dbe/midbe.c
index b43ac1b3d..d810d992e 100644
--- a/dbe/midbe.c
+++ b/dbe/midbe.c
@@ -30,7 +30,6 @@
*
*****************************************************************************/
-
/* INCLUDES */
#ifdef HAVE_DIX_CONFIG_H
@@ -59,8 +58,8 @@
#include <stdio.h>
static DevPrivateKeyRec miDbeWindowPrivPrivKeyRec;
-#define miDbeWindowPrivPrivKey (&miDbeWindowPrivPrivKeyRec)
+#define miDbeWindowPrivPrivKey (&miDbeWindowPrivPrivKeyRec)
/******************************************************************************
*
@@ -79,41 +78,36 @@ static DevPrivateKeyRec miDbeWindowPrivPrivKeyRec;
*****************************************************************************/
static Bool
-miDbeGetVisualInfo(ScreenPtr pScreen, XdbeScreenVisualInfo *pScrVisInfo)
+miDbeGetVisualInfo(ScreenPtr pScreen, XdbeScreenVisualInfo * pScrVisInfo)
{
- register int i, j, k;
- register int count;
- DepthPtr pDepth;
- XdbeVisualInfo *visInfo;
-
+ register int i, j, k;
+ register int count;
+ DepthPtr pDepth;
+ XdbeVisualInfo *visInfo;
/* Determine number of visuals for this screen. */
- for (i = 0, count = 0; i < pScreen->numDepths; i++)
- {
+ for (i = 0, count = 0; i < pScreen->numDepths; i++) {
count += pScreen->allowedDepths[i].numVids;
}
/* Allocate an array of XdbeVisualInfo items. */
- if (!(visInfo = (XdbeVisualInfo *)malloc(count * sizeof(XdbeVisualInfo))))
- {
- return FALSE; /* memory alloc failure */
+ if (!(visInfo = (XdbeVisualInfo *) malloc(count * sizeof(XdbeVisualInfo)))) {
+ return FALSE; /* memory alloc failure */
}
- for (i = 0, k = 0; i < pScreen->numDepths; i++)
- {
+ for (i = 0, k = 0; i < pScreen->numDepths; i++) {
/* For each depth of this screen, get visual information. */
pDepth = &pScreen->allowedDepths[i];
- for (j = 0; j < pDepth->numVids; j++)
- {
+ for (j = 0; j < pDepth->numVids; j++) {
/* For each visual for this depth of this screen, get visual ID
* and visual depth. Since this is MI code, we will always return
* the same performance level for all visuals (0). A higher
* performance level value indicates higher performance.
*/
- visInfo[k].visual = pDepth->vids[j];
- visInfo[k].depth = pDepth->depth;
+ visInfo[k].visual = pDepth->vids[j];
+ visInfo[k].depth = pDepth->depth;
visInfo[k].perflevel = 0;
k++;
}
@@ -122,13 +116,12 @@ miDbeGetVisualInfo(ScreenPtr pScreen, XdbeScreenVisualInfo *pScrVisInfo)
/* Record the number of visuals and point visual_depth to
* the array of visual info.
*/
- pScrVisInfo->count = count;
+ pScrVisInfo->count = count;
pScrVisInfo->visinfo = visInfo;
- return TRUE; /* success */
-
-} /* miDbeGetVisualInfo() */
+ return TRUE; /* success */
+} /* miDbeGetVisualInfo() */
/******************************************************************************
*
@@ -143,20 +136,18 @@ miDbeGetVisualInfo(ScreenPtr pScreen, XdbeScreenVisualInfo *pScrVisInfo)
static int
miDbeAllocBackBufferName(WindowPtr pWin, XID bufId, int swapAction)
{
- ScreenPtr pScreen;
- DbeWindowPrivPtr pDbeWindowPriv;
- MiDbeWindowPrivPrivPtr pDbeWindowPrivPriv;
- DbeScreenPrivPtr pDbeScreenPriv;
- GCPtr pGC;
- xRectangle clearRect;
- int rc;
-
+ ScreenPtr pScreen;
+ DbeWindowPrivPtr pDbeWindowPriv;
+ MiDbeWindowPrivPrivPtr pDbeWindowPrivPriv;
+ DbeScreenPrivPtr pDbeScreenPriv;
+ GCPtr pGC;
+ xRectangle clearRect;
+ int rc;
pScreen = pWin->drawable.pScreen;
pDbeWindowPriv = DBE_WINDOW_PRIV(pWin);
- if (pDbeWindowPriv->nBufferIDs == 0)
- {
+ if (pDbeWindowPriv->nBufferIDs == 0) {
/* There is no buffer associated with the window.
* We have to create the window priv priv. Remember, the window
* priv was created at the DIX level, so all we need to do is
@@ -171,32 +162,29 @@ miDbeAllocBackBufferName(WindowPtr pWin, XID bufId, int swapAction)
/* Get a front pixmap. */
if (!(pDbeWindowPrivPriv->pFrontBuffer =
- (*pScreen->CreatePixmap)(pScreen, pDbeWindowPriv->width,
- pDbeWindowPriv->height,
- pWin->drawable.depth, 0)))
- {
+ (*pScreen->CreatePixmap) (pScreen, pDbeWindowPriv->width,
+ pDbeWindowPriv->height,
+ pWin->drawable.depth, 0))) {
return BadAlloc;
}
/* Get a back pixmap. */
if (!(pDbeWindowPrivPriv->pBackBuffer =
- (*pScreen->CreatePixmap)(pScreen, pDbeWindowPriv->width,
- pDbeWindowPriv->height,
- pWin->drawable.depth, 0)))
- {
- (*pScreen->DestroyPixmap)(pDbeWindowPrivPriv->pFrontBuffer);
+ (*pScreen->CreatePixmap) (pScreen, pDbeWindowPriv->width,
+ pDbeWindowPriv->height,
+ pWin->drawable.depth, 0))) {
+ (*pScreen->DestroyPixmap) (pDbeWindowPrivPriv->pFrontBuffer);
return BadAlloc;
}
- /* Security creation/labeling check. */
- rc = XaceHook(XACE_RESOURCE_ACCESS, serverClient, bufId,
- dbeDrawableResType, pDbeWindowPrivPriv->pBackBuffer,
- RT_WINDOW, pWin, DixCreateAccess);
+ /* Security creation/labeling check. */
+ rc = XaceHook(XACE_RESOURCE_ACCESS, serverClient, bufId,
+ dbeDrawableResType, pDbeWindowPrivPriv->pBackBuffer,
+ RT_WINDOW, pWin, DixCreateAccess);
/* Make the back pixmap a DBE drawable resource. */
if (rc != Success || !AddResource(bufId, dbeDrawableResType,
- pDbeWindowPrivPriv->pBackBuffer))
- {
+ pDbeWindowPrivPriv->pBackBuffer)) {
/* free the buffer and the drawable resource */
FreeResource(bufId, RT_NONE);
return (rc == Success) ? BadAlloc : rc;
@@ -204,22 +192,19 @@ miDbeAllocBackBufferName(WindowPtr pWin, XID bufId, int swapAction)
/* Clear the back buffer. */
pGC = GetScratchGC(pWin->drawable.depth, pWin->drawable.pScreen);
- if ((*pDbeScreenPriv->SetupBackgroundPainter)(pWin, pGC))
- {
- ValidateGC((DrawablePtr)pDbeWindowPrivPriv->pBackBuffer, pGC);
+ if ((*pDbeScreenPriv->SetupBackgroundPainter) (pWin, pGC)) {
+ ValidateGC((DrawablePtr) pDbeWindowPrivPriv->pBackBuffer, pGC);
clearRect.x = clearRect.y = 0;
- clearRect.width = pDbeWindowPrivPriv->pBackBuffer->drawable.width;
+ clearRect.width = pDbeWindowPrivPriv->pBackBuffer->drawable.width;
clearRect.height = pDbeWindowPrivPriv->pBackBuffer->drawable.height;
- (*pGC->ops->PolyFillRect)(
- (DrawablePtr)pDbeWindowPrivPriv->pBackBuffer, pGC, 1,
- &clearRect);
+ (*pGC->ops->PolyFillRect) ((DrawablePtr) pDbeWindowPrivPriv->
+ pBackBuffer, pGC, 1, &clearRect);
}
FreeScratchGC(pGC);
- } /* if no buffer associated with the window */
+ } /* if no buffer associated with the window */
- else
- {
+ else {
/* A buffer is already associated with the window.
* Place the new buffer ID information at the head of the ID list.
*/
@@ -227,8 +212,7 @@ miDbeAllocBackBufferName(WindowPtr pWin, XID bufId, int swapAction)
/* Associate the new ID with an existing pixmap. */
pDbeWindowPrivPriv = MI_DBE_WINDOW_PRIV_PRIV(pDbeWindowPriv);
if (!AddResource(bufId, dbeDrawableResType,
- (pointer)pDbeWindowPrivPriv->pBackBuffer))
- {
+ (pointer) pDbeWindowPrivPriv->pBackBuffer)) {
return BadAlloc;
}
@@ -236,8 +220,7 @@ miDbeAllocBackBufferName(WindowPtr pWin, XID bufId, int swapAction)
return Success;
-} /* miDbeAllocBackBufferName() */
-
+} /* miDbeAllocBackBufferName() */
/******************************************************************************
*
@@ -253,18 +236,16 @@ miDbeAllocBackBufferName(WindowPtr pWin, XID bufId, int swapAction)
static void
miDbeAliasBuffers(DbeWindowPrivPtr pDbeWindowPriv)
{
- int i;
- MiDbeWindowPrivPrivPtr pDbeWindowPrivPriv =
- MI_DBE_WINDOW_PRIV_PRIV(pDbeWindowPriv);
+ int i;
+ MiDbeWindowPrivPrivPtr pDbeWindowPrivPriv =
+ MI_DBE_WINDOW_PRIV_PRIV(pDbeWindowPriv);
- for (i = 0; i < pDbeWindowPriv->nBufferIDs; i++)
- {
+ for (i = 0; i < pDbeWindowPriv->nBufferIDs; i++) {
ChangeResourceValue(pDbeWindowPriv->IDs[i], dbeDrawableResType,
- (pointer)pDbeWindowPrivPriv->pBackBuffer);
+ (pointer) pDbeWindowPrivPriv->pBackBuffer);
}
-} /* miDbeAliasBuffers() */
-
+} /* miDbeAliasBuffers() */
/******************************************************************************
*
@@ -279,16 +260,15 @@ miDbeAliasBuffers(DbeWindowPrivPtr pDbeWindowPriv)
static int
miDbeSwapBuffers(ClientPtr client, int *pNumWindows, DbeSwapInfoPtr swapInfo)
{
- DbeScreenPrivPtr pDbeScreenPriv;
- GCPtr pGC;
- WindowPtr pWin;
- MiDbeWindowPrivPrivPtr pDbeWindowPrivPriv;
- PixmapPtr pTmpBuffer;
- xRectangle clearRect;
-
-
- pWin = swapInfo[0].pWindow;
- pDbeScreenPriv = DBE_SCREEN_PRIV_FROM_WINDOW(pWin);
+ DbeScreenPrivPtr pDbeScreenPriv;
+ GCPtr pGC;
+ WindowPtr pWin;
+ MiDbeWindowPrivPrivPtr pDbeWindowPrivPriv;
+ PixmapPtr pTmpBuffer;
+ xRectangle clearRect;
+
+ pWin = swapInfo[0].pWindow;
+ pDbeScreenPriv = DBE_SCREEN_PRIV_FROM_WINDOW(pWin);
pDbeWindowPrivPriv = MI_DBE_WINDOW_PRIV_PRIV_FROM_WINDOW(pWin);
pGC = GetScratchGC(pWin->drawable.depth, pWin->drawable.pScreen);
@@ -298,24 +278,23 @@ miDbeSwapBuffers(ClientPtr client, int *pNumWindows, DbeSwapInfoPtr swapInfo)
**********************************************************************
*/
- switch(swapInfo[0].swapAction)
- {
- case XdbeUndefined:
- break;
+ switch (swapInfo[0].swapAction) {
+ case XdbeUndefined:
+ break;
- case XdbeBackground:
- break;
+ case XdbeBackground:
+ break;
- case XdbeUntouched:
- ValidateGC((DrawablePtr)pDbeWindowPrivPriv->pFrontBuffer, pGC);
- (*pGC->ops->CopyArea)((DrawablePtr)pWin,
- (DrawablePtr)pDbeWindowPrivPriv->pFrontBuffer,
- pGC, 0, 0, pWin->drawable.width,
- pWin->drawable.height, 0, 0);
- break;
+ case XdbeUntouched:
+ ValidateGC((DrawablePtr) pDbeWindowPrivPriv->pFrontBuffer, pGC);
+ (*pGC->ops->CopyArea) ((DrawablePtr) pWin,
+ (DrawablePtr) pDbeWindowPrivPriv->pFrontBuffer,
+ pGC, 0, 0, pWin->drawable.width,
+ pWin->drawable.height, 0, 0);
+ break;
- case XdbeCopied:
- break;
+ case XdbeCopied:
+ break;
}
@@ -325,11 +304,10 @@ miDbeSwapBuffers(ClientPtr client, int *pNumWindows, DbeSwapInfoPtr swapInfo)
**********************************************************************
*/
- ValidateGC((DrawablePtr)pWin, pGC);
- (*pGC->ops->CopyArea)((DrawablePtr)pDbeWindowPrivPriv->pBackBuffer,
- (DrawablePtr)pWin, pGC, 0, 0,
- pWin->drawable.width, pWin->drawable.height,
- 0, 0);
+ ValidateGC((DrawablePtr) pWin, pGC);
+ (*pGC->ops->CopyArea) ((DrawablePtr) pDbeWindowPrivPriv->pBackBuffer,
+ (DrawablePtr) pWin, pGC, 0, 0,
+ pWin->drawable.width, pWin->drawable.height, 0, 0);
/*
**********************************************************************
@@ -337,40 +315,34 @@ miDbeSwapBuffers(ClientPtr client, int *pNumWindows, DbeSwapInfoPtr swapInfo)
**********************************************************************
*/
- switch(swapInfo[0].swapAction)
- {
- case XdbeUndefined:
- break;
-
- case XdbeBackground:
- if ((*pDbeScreenPriv->SetupBackgroundPainter)(pWin, pGC))
- {
- ValidateGC((DrawablePtr)pDbeWindowPrivPriv->pBackBuffer, pGC);
- clearRect.x = 0;
- clearRect.y = 0;
- clearRect.width =
- pDbeWindowPrivPriv->pBackBuffer->drawable.width;
- clearRect.height =
- pDbeWindowPrivPriv->pBackBuffer->drawable.height;
- (*pGC->ops->PolyFillRect)(
- (DrawablePtr)pDbeWindowPrivPriv->pBackBuffer,
- pGC, 1, &clearRect);
- }
- break;
-
- case XdbeUntouched:
- /* Swap pixmap pointers. */
- pTmpBuffer = pDbeWindowPrivPriv->pBackBuffer;
- pDbeWindowPrivPriv->pBackBuffer =
- pDbeWindowPrivPriv->pFrontBuffer;
- pDbeWindowPrivPriv->pFrontBuffer = pTmpBuffer;
-
- miDbeAliasBuffers(pDbeWindowPrivPriv->pDbeWindowPriv);
-
- break;
-
- case XdbeCopied:
- break;
+ switch (swapInfo[0].swapAction) {
+ case XdbeUndefined:
+ break;
+
+ case XdbeBackground:
+ if ((*pDbeScreenPriv->SetupBackgroundPainter) (pWin, pGC)) {
+ ValidateGC((DrawablePtr) pDbeWindowPrivPriv->pBackBuffer, pGC);
+ clearRect.x = 0;
+ clearRect.y = 0;
+ clearRect.width = pDbeWindowPrivPriv->pBackBuffer->drawable.width;
+ clearRect.height = pDbeWindowPrivPriv->pBackBuffer->drawable.height;
+ (*pGC->ops->PolyFillRect) ((DrawablePtr) pDbeWindowPrivPriv->
+ pBackBuffer, pGC, 1, &clearRect);
+ }
+ break;
+
+ case XdbeUntouched:
+ /* Swap pixmap pointers. */
+ pTmpBuffer = pDbeWindowPrivPriv->pBackBuffer;
+ pDbeWindowPrivPriv->pBackBuffer = pDbeWindowPrivPriv->pFrontBuffer;
+ pDbeWindowPrivPriv->pFrontBuffer = pTmpBuffer;
+
+ miDbeAliasBuffers(pDbeWindowPrivPriv->pDbeWindowPriv);
+
+ break;
+
+ case XdbeCopied:
+ break;
}
@@ -379,23 +351,21 @@ miDbeSwapBuffers(ClientPtr client, int *pNumWindows, DbeSwapInfoPtr swapInfo)
* swapped.
*/
- if (*pNumWindows > 1)
- {
+ if (*pNumWindows > 1) {
/* We were told to swap more than one window, but we only swapped the
* first one. Remove the first window in the list by moving the last
* window to the beginning.
*/
- swapInfo[0].pWindow = swapInfo[*pNumWindows - 1].pWindow;
+ swapInfo[0].pWindow = swapInfo[*pNumWindows - 1].pWindow;
swapInfo[0].swapAction = swapInfo[*pNumWindows - 1].swapAction;
/* Clear the last window information just to be safe. */
- swapInfo[*pNumWindows - 1].pWindow = (WindowPtr)NULL;
+ swapInfo[*pNumWindows - 1].pWindow = (WindowPtr) NULL;
swapInfo[*pNumWindows - 1].swapAction = 0;
}
- else
- {
+ else {
/* Clear the window information just to be safe. */
- swapInfo[0].pWindow = (WindowPtr)NULL;
+ swapInfo[0].pWindow = (WindowPtr) NULL;
swapInfo[0].swapAction = 0;
}
@@ -405,8 +375,7 @@ miDbeSwapBuffers(ClientPtr client, int *pNumWindows, DbeSwapInfoPtr swapInfo)
return Success;
-} /* miSwapBuffers() */
-
+} /* miSwapBuffers() */
/******************************************************************************
*
@@ -458,18 +427,15 @@ miDbeSwapBuffers(ClientPtr client, int *pNumWindows, DbeSwapInfoPtr swapInfo)
static void
miDbeWinPrivDelete(DbeWindowPrivPtr pDbeWindowPriv, XID bufId)
{
- MiDbeWindowPrivPrivPtr pDbeWindowPrivPriv;
+ MiDbeWindowPrivPrivPtr pDbeWindowPrivPriv;
-
- if (pDbeWindowPriv->nBufferIDs != 0)
- {
+ if (pDbeWindowPriv->nBufferIDs != 0) {
/* We still have at least one more buffer ID associated with this
* window.
*/
return;
}
-
/* We have no more buffer IDs associated with this window. We need to
* free some stuff.
*/
@@ -477,19 +443,16 @@ miDbeWinPrivDelete(DbeWindowPrivPtr pDbeWindowPriv, XID bufId)
pDbeWindowPrivPriv = MI_DBE_WINDOW_PRIV_PRIV(pDbeWindowPriv);
/* Destroy the front and back pixmaps. */
- if (pDbeWindowPrivPriv->pFrontBuffer)
- {
- (*pDbeWindowPriv->pWindow->drawable.pScreen->DestroyPixmap)(
- pDbeWindowPrivPriv->pFrontBuffer);
+ if (pDbeWindowPrivPriv->pFrontBuffer) {
+ (*pDbeWindowPriv->pWindow->drawable.pScreen->
+ DestroyPixmap) (pDbeWindowPrivPriv->pFrontBuffer);
}
- if (pDbeWindowPrivPriv->pBackBuffer)
- {
- (*pDbeWindowPriv->pWindow->drawable.pScreen->DestroyPixmap)(
- pDbeWindowPrivPriv->pBackBuffer);
+ if (pDbeWindowPrivPriv->pBackBuffer) {
+ (*pDbeWindowPriv->pWindow->drawable.pScreen->
+ DestroyPixmap) (pDbeWindowPrivPriv->pBackBuffer);
}
-} /* miDbeWinPrivDelete() */
-
+} /* miDbeWinPrivDelete() */
/******************************************************************************
*
@@ -505,30 +468,29 @@ miDbeWinPrivDelete(DbeWindowPrivPtr pDbeWindowPriv, XID bufId)
static Bool
miDbePositionWindow(WindowPtr pWin, int x, int y)
{
- ScreenPtr pScreen;
- DbeScreenPrivPtr pDbeScreenPriv;
- DbeWindowPrivPtr pDbeWindowPriv;
- int width, height;
- int dx, dy, dw, dh;
- int sourcex, sourcey;
- int destx, desty;
- int savewidth, saveheight;
- PixmapPtr pFrontBuffer;
- PixmapPtr pBackBuffer;
- Bool clear;
- GCPtr pGC;
- xRectangle clearRect;
- Bool ret;
-
+ ScreenPtr pScreen;
+ DbeScreenPrivPtr pDbeScreenPriv;
+ DbeWindowPrivPtr pDbeWindowPriv;
+ int width, height;
+ int dx, dy, dw, dh;
+ int sourcex, sourcey;
+ int destx, desty;
+ int savewidth, saveheight;
+ PixmapPtr pFrontBuffer;
+ PixmapPtr pBackBuffer;
+ Bool clear;
+ GCPtr pGC;
+ xRectangle clearRect;
+ Bool ret;
/*
**************************************************************************
** 1. Unwrap the member routine.
**************************************************************************
*/
-
- pScreen = pWin->drawable.pScreen;
- pDbeScreenPriv = DBE_SCREEN_PRIV(pScreen);
+
+ pScreen = pWin->drawable.pScreen;
+ pDbeScreenPriv = DBE_SCREEN_PRIV(pScreen);
pScreen->PositionWindow = pDbeScreenPriv->PositionWindow;
/*
@@ -538,14 +500,14 @@ miDbePositionWindow(WindowPtr pWin, int x, int y)
** In this case we do not need to do anything.
**************************************************************************
*/
-
+
/*
**************************************************************************
** 3. Call the member routine, saving its result if necessary.
**************************************************************************
*/
-
- ret = (*pScreen->PositionWindow)(pWin, x, y);
+
+ ret = (*pScreen->PositionWindow) (pWin, x, y);
/*
**************************************************************************
@@ -562,108 +524,95 @@ miDbePositionWindow(WindowPtr pWin, int x, int y)
** 5. Do any work necessary after the member routine has been called.
**************************************************************************
*/
-
- if (!(pDbeWindowPriv = DBE_WINDOW_PRIV(pWin)))
- {
- return ret;
+
+ if (!(pDbeWindowPriv = DBE_WINDOW_PRIV(pWin))) {
+ return ret;
}
- if (pDbeWindowPriv->width == pWin->drawable.width &&
- pDbeWindowPriv->height == pWin->drawable.height)
- {
- return ret;
+ if (pDbeWindowPriv->width == pWin->drawable.width &&
+ pDbeWindowPriv->height == pWin->drawable.height) {
+ return ret;
}
- width = pWin->drawable.width;
+ width = pWin->drawable.width;
height = pWin->drawable.height;
dx = pWin->drawable.x - pDbeWindowPriv->x;
dy = pWin->drawable.y - pDbeWindowPriv->y;
- dw = width - pDbeWindowPriv->width;
+ dw = width - pDbeWindowPriv->width;
dh = height - pDbeWindowPriv->height;
- GravityTranslate (0, 0, -dx, -dy, dw, dh, pWin->bitGravity, &destx, &desty);
+ GravityTranslate(0, 0, -dx, -dy, dw, dh, pWin->bitGravity, &destx, &desty);
- clear = ((pDbeWindowPriv->width < (unsigned short)width ) ||
- (pDbeWindowPriv->height < (unsigned short)height) ||
+ clear = ((pDbeWindowPriv->width < (unsigned short) width) ||
+ (pDbeWindowPriv->height < (unsigned short) height) ||
(pWin->bitGravity == ForgetGravity));
sourcex = 0;
sourcey = 0;
- savewidth = pDbeWindowPriv->width;
+ savewidth = pDbeWindowPriv->width;
saveheight = pDbeWindowPriv->height;
/* Clip rectangle to source and destination. */
- if (destx < 0)
- {
- savewidth += destx;
- sourcex -= destx;
- destx = 0;
+ if (destx < 0) {
+ savewidth += destx;
+ sourcex -= destx;
+ destx = 0;
}
- if (destx + savewidth > width)
- {
- savewidth = width - destx;
+ if (destx + savewidth > width) {
+ savewidth = width - destx;
}
- if (desty < 0)
- {
- saveheight += desty;
- sourcey -= desty;
- desty = 0;
+ if (desty < 0) {
+ saveheight += desty;
+ sourcey -= desty;
+ desty = 0;
}
- if (desty + saveheight > height)
- {
- saveheight = height - desty;
+ if (desty + saveheight > height) {
+ saveheight = height - desty;
}
- pDbeWindowPriv->width = width;
+ pDbeWindowPriv->width = width;
pDbeWindowPriv->height = height;
pDbeWindowPriv->x = pWin->drawable.x;
pDbeWindowPriv->y = pWin->drawable.y;
- pGC = GetScratchGC (pWin->drawable.depth, pScreen);
-
- if (clear)
- {
- if ((*pDbeScreenPriv->SetupBackgroundPainter)(pWin, pGC))
- {
- clearRect.x = 0;
- clearRect.y = 0;
- clearRect.width = width;
- clearRect.height = height;
- }
- else
- {
- clear = FALSE;
- }
+ pGC = GetScratchGC(pWin->drawable.depth, pScreen);
+
+ if (clear) {
+ if ((*pDbeScreenPriv->SetupBackgroundPainter) (pWin, pGC)) {
+ clearRect.x = 0;
+ clearRect.y = 0;
+ clearRect.width = width;
+ clearRect.height = height;
+ }
+ else {
+ clear = FALSE;
+ }
}
/* Create DBE buffer pixmaps equal to size of resized window. */
- pFrontBuffer = (*pScreen->CreatePixmap)(pScreen, width, height,
- pWin->drawable.depth, 0);
+ pFrontBuffer = (*pScreen->CreatePixmap) (pScreen, width, height,
+ pWin->drawable.depth, 0);
- pBackBuffer = (*pScreen->CreatePixmap)(pScreen, width, height,
- pWin->drawable.depth, 0);
+ pBackBuffer = (*pScreen->CreatePixmap) (pScreen, width, height,
+ pWin->drawable.depth, 0);
- if (!pFrontBuffer || !pBackBuffer)
- {
+ if (!pFrontBuffer || !pBackBuffer) {
/* We failed at creating 1 or 2 of the pixmaps. */
- if (pFrontBuffer)
- {
- (*pScreen->DestroyPixmap)(pFrontBuffer);
+ if (pFrontBuffer) {
+ (*pScreen->DestroyPixmap) (pFrontBuffer);
}
- if (pBackBuffer)
- {
- (*pScreen->DestroyPixmap)(pBackBuffer);
+ if (pBackBuffer) {
+ (*pScreen->DestroyPixmap) (pBackBuffer);
}
/* Destroy all buffers for this window. */
- while (pDbeWindowPriv)
- {
+ while (pDbeWindowPriv) {
/* DbeWindowPrivDelete() will free the window private if there no
* more buffer IDs associated with this window.
*/
@@ -675,57 +624,53 @@ miDbePositionWindow(WindowPtr pWin, int x, int y)
return FALSE;
}
- else
- {
+ else {
/* Clear out the new DBE buffer pixmaps. */
- MiDbeWindowPrivPrivPtr pDbeWindowPrivPriv;
-
+ MiDbeWindowPrivPrivPtr pDbeWindowPrivPriv;
pDbeWindowPrivPriv = MI_DBE_WINDOW_PRIV_PRIV(pDbeWindowPriv);
- /* I suppose this could avoid quite a bit of work if
- * it computed the minimal area required.
- */
- ValidateGC(&pFrontBuffer->drawable, pGC);
- if (clear)
- {
- (*pGC->ops->PolyFillRect)((DrawablePtr)pFrontBuffer, pGC, 1,
- &clearRect);
- }
- /* Copy the contents of the old front pixmap to the new one. */
- if (pWin->bitGravity != ForgetGravity)
- {
- (*pGC->ops->CopyArea)((DrawablePtr)pDbeWindowPrivPriv->pFrontBuffer,
- (DrawablePtr)pFrontBuffer, pGC, sourcex,
- sourcey, savewidth, saveheight, destx, desty);
+ /* I suppose this could avoid quite a bit of work if
+ * it computed the minimal area required.
+ */
+ ValidateGC(&pFrontBuffer->drawable, pGC);
+ if (clear) {
+ (*pGC->ops->PolyFillRect) ((DrawablePtr) pFrontBuffer, pGC, 1,
+ &clearRect);
+ }
+ /* Copy the contents of the old front pixmap to the new one. */
+ if (pWin->bitGravity != ForgetGravity) {
+ (*pGC->ops->CopyArea) ((DrawablePtr) pDbeWindowPrivPriv->
+ pFrontBuffer, (DrawablePtr) pFrontBuffer,
+ pGC, sourcex, sourcey, savewidth, saveheight,
+ destx, desty);
}
- ValidateGC(&pBackBuffer->drawable, pGC);
- if (clear)
- {
- (*pGC->ops->PolyFillRect)((DrawablePtr)pBackBuffer , pGC, 1,
- &clearRect);
- }
- /* Copy the contents of the old back pixmap to the new one. */
- if (pWin->bitGravity != ForgetGravity)
- {
- (*pGC->ops->CopyArea)((DrawablePtr)pDbeWindowPrivPriv->pBackBuffer,
- (DrawablePtr)pBackBuffer, pGC, sourcex,
- sourcey, savewidth, saveheight, destx, desty);
- }
+ ValidateGC(&pBackBuffer->drawable, pGC);
+ if (clear) {
+ (*pGC->ops->PolyFillRect) ((DrawablePtr) pBackBuffer, pGC, 1,
+ &clearRect);
+ }
+ /* Copy the contents of the old back pixmap to the new one. */
+ if (pWin->bitGravity != ForgetGravity) {
+ (*pGC->ops->CopyArea) ((DrawablePtr) pDbeWindowPrivPriv->
+ pBackBuffer, (DrawablePtr) pBackBuffer, pGC,
+ sourcex, sourcey, savewidth, saveheight,
+ destx, desty);
+ }
/* Destroy the old pixmaps, and point the DBE window priv to the new
* pixmaps.
*/
- (*pScreen->DestroyPixmap)(pDbeWindowPrivPriv->pFrontBuffer);
- (*pScreen->DestroyPixmap)(pDbeWindowPrivPriv->pBackBuffer);
+ (*pScreen->DestroyPixmap) (pDbeWindowPrivPriv->pFrontBuffer);
+ (*pScreen->DestroyPixmap) (pDbeWindowPrivPriv->pBackBuffer);
pDbeWindowPrivPriv->pFrontBuffer = pFrontBuffer;
- pDbeWindowPrivPriv->pBackBuffer = pBackBuffer;
+ pDbeWindowPrivPriv->pBackBuffer = pBackBuffer;
- /* Make sure all XID are associated with the new back pixmap. */
+ /* Make sure all XID are associated with the new back pixmap. */
miDbeAliasBuffers(pDbeWindowPriv);
FreeScratchGC(pGC);
@@ -733,8 +678,7 @@ miDbePositionWindow(WindowPtr pWin, int x, int y)
return ret;
-} /* miDbePositionWindow() */
-
+} /* miDbePositionWindow() */
/******************************************************************************
*
@@ -751,16 +695,14 @@ miDbePositionWindow(WindowPtr pWin, int x, int y)
static void
miDbeResetProc(ScreenPtr pScreen)
{
- DbeScreenPrivPtr pDbeScreenPriv;
-
+ DbeScreenPrivPtr pDbeScreenPriv;
pDbeScreenPriv = DBE_SCREEN_PRIV(pScreen);
/* Unwrap wrappers */
pScreen->PositionWindow = pDbeScreenPriv->PositionWindow;
-} /* miDbeResetProc() */
-
+} /* miDbeResetProc() */
/******************************************************************************
*
@@ -776,22 +718,22 @@ Bool
miDbeInit(ScreenPtr pScreen, DbeScreenPrivPtr pDbeScreenPriv)
{
if (!dixRegisterPrivateKey(&miDbeWindowPrivPrivKeyRec, PRIVATE_DBE_WINDOW,
- sizeof(MiDbeWindowPrivPrivRec)))
+ sizeof(MiDbeWindowPrivPrivRec)))
return FALSE;
/* Wrap functions. */
pDbeScreenPriv->PositionWindow = pScreen->PositionWindow;
- pScreen->PositionWindow = miDbePositionWindow;
+ pScreen->PositionWindow = miDbePositionWindow;
/* Initialize the per-screen DBE function pointers. */
- pDbeScreenPriv->GetVisualInfo = miDbeGetVisualInfo;
- pDbeScreenPriv->AllocBackBufferName = miDbeAllocBackBufferName;
- pDbeScreenPriv->SwapBuffers = miDbeSwapBuffers;
- pDbeScreenPriv->BeginIdiom = 0;
- pDbeScreenPriv->EndIdiom = 0;
- pDbeScreenPriv->ResetProc = miDbeResetProc;
- pDbeScreenPriv->WinPrivDelete = miDbeWinPrivDelete;
+ pDbeScreenPriv->GetVisualInfo = miDbeGetVisualInfo;
+ pDbeScreenPriv->AllocBackBufferName = miDbeAllocBackBufferName;
+ pDbeScreenPriv->SwapBuffers = miDbeSwapBuffers;
+ pDbeScreenPriv->BeginIdiom = 0;
+ pDbeScreenPriv->EndIdiom = 0;
+ pDbeScreenPriv->ResetProc = miDbeResetProc;
+ pDbeScreenPriv->WinPrivDelete = miDbeWinPrivDelete;
return TRUE;
-} /* miDbeInit() */
+} /* miDbeInit() */
diff --git a/dbe/midbe.h b/dbe/midbe.h
index cff36d038..4eed538d0 100644
--- a/dbe/midbe.h
+++ b/dbe/midbe.h
@@ -40,19 +40,17 @@
/* EXTERNS */
-extern Bool miDbeInit(
- ScreenPtr pScreen,
- DbeScreenPrivPtr pDbeScreenPriv
-);
+extern Bool miDbeInit(ScreenPtr pScreen, DbeScreenPrivPtr pDbeScreenPriv);
extern DevPrivateKeyRec dbeScreenPrivKeyRec;
+
#define dbeScreenPrivKey (&dbeScreenPrivKeyRec)
extern DevPrivateKeyRec dbeWindowPrivKeyRec;
-#define dbeWindowPrivKey (&dbeWindowPrivKeyRec)
-extern RESTYPE dbeDrawableResType;
-extern RESTYPE dbeWindowPrivResType;
+#define dbeWindowPrivKey (&dbeWindowPrivKeyRec)
-#endif /* MIDBE_H */
+extern RESTYPE dbeDrawableResType;
+extern RESTYPE dbeWindowPrivResType;
+#endif /* MIDBE_H */
diff --git a/dbe/midbestr.h b/dbe/midbestr.h
index a47d8d9f1..70017b045 100644
--- a/dbe/midbestr.h
+++ b/dbe/midbestr.h
@@ -30,7 +30,6 @@
*
*****************************************************************************/
-
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
@@ -38,7 +37,6 @@
#ifndef MIDBE_STRUCT_H
#define MIDBE_STRUCT_H
-
/* DEFINES */
#define MI_DBE_WINDOW_PRIV_PRIV(pDbeWindowPriv) \
@@ -50,15 +48,14 @@
/* TYPEDEFS */
-typedef struct _MiDbeWindowPrivPrivRec
-{
+typedef struct _MiDbeWindowPrivPrivRec {
/* Place machine-specific fields in here.
* Since this is mi code, we do not really have machine-specific fields.
*/
/* Pointer to a drawable that contains the contents of the back buffer.
*/
- PixmapPtr pBackBuffer;
+ PixmapPtr pBackBuffer;
/* Pointer to a drawable that contains the contents of the front buffer.
* This pointer is only used for the XdbeUntouched swap action. For that
@@ -68,12 +65,11 @@ typedef struct _MiDbeWindowPrivPrivRec
* and then swap the drawable/resource associations in the resource
* database.
*/
- PixmapPtr pFrontBuffer;
+ PixmapPtr pFrontBuffer;
/* Pointer back to our window private with which we are associated. */
- DbeWindowPrivPtr pDbeWindowPriv;
+ DbeWindowPrivPtr pDbeWindowPriv;
} MiDbeWindowPrivPrivRec, *MiDbeWindowPrivPrivPtr;
-#endif /* MIDBE_STRUCT_H */
-
+#endif /* MIDBE_STRUCT_H */
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-01 02:05:59 +0000