int
ProcXFixesCombineRegion (ClientPtr client)
{
RegionPtr pSource1, pSource2, pDestination;
int ret = Success;
REQUEST (xXFixesCombineRegionReq);
REQUEST_SIZE_MATCH (xXFixesCombineRegionReq);
VERIFY_REGION(pSource1, stuff->source1, client, DixReadAccess);
VERIFY_REGION(pSource2, stuff->source2, client, DixReadAccess);
VERIFY_REGION(pDestination, stuff->destination, client, DixWriteAccess);
switch (stuff->xfixesReqType) {
case X_XFixesUnionRegion:
if (!REGION_UNION (0, pDestination, pSource1, pSource2))
ret = BadAlloc;
break;
case X_XFixesIntersectRegion:
if (!REGION_INTERSECT (0, pDestination, pSource1, pSource2))
ret = BadAlloc;
break;
case X_XFixesSubtractRegion:
if (!REGION_SUBTRACT (0, pDestination, pSource1, pSource2))
ret = BadAlloc;
break;
}
if (ret == Success)
ret = client->noClientException;
return ret;
}
int
ProcXFixesCombineRegion(ClientPtr client)
{
RegionPtr pSource1, pSource2, pDestination;
REQUEST(xXFixesCombineRegionReq);
REQUEST_SIZE_MATCH(xXFixesCombineRegionReq);
VERIFY_REGION(pSource1, stuff->source1, client, DixReadAccess);
VERIFY_REGION(pSource2, stuff->source2, client, DixReadAccess);
VERIFY_REGION(pDestination, stuff->destination, client, DixWriteAccess);
switch (stuff->xfixesReqType) {
case X_XFixesUnionRegion:
if (!RegionUnion(pDestination, pSource1, pSource2))
return BadAlloc;
break;
case X_XFixesIntersectRegion:
if (!RegionIntersect(pDestination, pSource1, pSource2))
return BadAlloc;
break;
case X_XFixesSubtractRegion:
if (!RegionSubtract(pDestination, pSource1, pSource2))
return BadAlloc;
break;
}
return Success;
}
int
ProcXFixesInvertRegion (ClientPtr client)
{
RegionPtr pSource, pDestination;
BoxRec bounds;
int ret = Success;
REQUEST(xXFixesInvertRegionReq);
REQUEST_SIZE_MATCH(xXFixesInvertRegionReq);
VERIFY_REGION(pSource, stuff->source, client, DixReadAccess);
VERIFY_REGION(pDestination, stuff->destination, client, DixWriteAccess);
/* Compute bounds, limit to 16 bits */
bounds.x1 = stuff->x;
bounds.y1 = stuff->y;
if ((int) stuff->x + (int) stuff->width > MAXSHORT)
bounds.x2 = MAXSHORT;
else
bounds.x2 = stuff->x + stuff->width;
if ((int) stuff->y + (int) stuff->height > MAXSHORT)
bounds.y2 = MAXSHORT;
else
bounds.y2 = stuff->y + stuff->height;
if (!REGION_INVERSE(0, pDestination, pSource, &bounds))
ret = BadAlloc;
if (ret == Success)
ret = client->noClientException;
return ret;
}
int
ProcXFixesCopyRegion (ClientPtr client)
{
RegionPtr pSource, pDestination;
REQUEST (xXFixesCopyRegionReq);
VERIFY_REGION(pSource, stuff->source, client, DixReadAccess);
VERIFY_REGION(pDestination, stuff->destination, client, DixWriteAccess);
if (!RegionCopy(pDestination, pSource))
return BadAlloc;
return Success;
}
int
ProcXFixesCopyRegion (ClientPtr client)
{
RegionPtr pSource, pDestination;
REQUEST (xXFixesCopyRegionReq);
VERIFY_REGION(pSource, stuff->source, client, DixReadAccess);
VERIFY_REGION(pDestination, stuff->destination, client, DixWriteAccess);
if (!REGION_COPY(pScreen, pDestination, pSource))
return BadAlloc;
return(client->noClientException);
}
int
ProcXFixesRegionExtents (ClientPtr client)
{
RegionPtr pSource, pDestination;
REQUEST(xXFixesRegionExtentsReq);
REQUEST_SIZE_MATCH(xXFixesRegionExtentsReq);
VERIFY_REGION(pSource, stuff->source, client, DixReadAccess);
VERIFY_REGION(pDestination, stuff->destination, client, DixWriteAccess);
RegionReset(pDestination, RegionExtents(pSource));
return Success;
}
int
ProcXFixesRegionExtents (ClientPtr client)
{
RegionPtr pSource, pDestination;
REQUEST(xXFixesRegionExtentsReq);
REQUEST_SIZE_MATCH(xXFixesRegionExtentsReq);
VERIFY_REGION(pSource, stuff->source, client, DixReadAccess);
VERIFY_REGION(pDestination, stuff->destination, client, DixWriteAccess);
REGION_RESET (0, pDestination, REGION_EXTENTS (0, pSource));
return (client->noClientException);
}
int
ProcXFixesSetRegion(ClientPtr client)
{
int things;
RegionPtr pRegion, pNew;
REQUEST(xXFixesSetRegionReq);
REQUEST_AT_LEAST_SIZE(xXFixesSetRegionReq);
VERIFY_REGION(pRegion, stuff->region, client, DixWriteAccess);
things = (client->req_len << 2) - sizeof(xXFixesCreateRegionReq);
if (things & 4)
return BadLength;
things >>= 3;
pNew = RegionFromRects(things, (xRectangle *) (stuff + 1), CT_UNSORTED);
if (!pNew)
return BadAlloc;
if (!RegionCopy(pRegion, pNew)) {
RegionDestroy(pNew);
return BadAlloc;
}
RegionDestroy(pNew);
return Success;
}
int
ProcXFixesSetRegion (ClientPtr client)
{
int things;
RegionPtr pRegion, pNew;
REQUEST (xXFixesSetRegionReq);
REQUEST_AT_LEAST_SIZE(xXFixesSetRegionReq);
VERIFY_REGION(pRegion, stuff->region, client, DixWriteAccess);
things = (client->req_len << 2) - sizeof (xXFixesCreateRegionReq);
if (things & 4)
return BadLength;
things >>= 3;
pNew = RECTS_TO_REGION(0, things, (xRectangle *) (stuff + 1), CT_UNSORTED);
if (!pNew)
return BadAlloc;
if (!REGION_COPY (0, pRegion, pNew))
{
REGION_DESTROY (0, pNew);
return BadAlloc;
}
REGION_DESTROY (0, pNew);
return(client->noClientException);
}
int
ProcXFixesExpandRegion (ClientPtr client)
{
RegionPtr pSource, pDestination;
int ret = Success;
REQUEST (xXFixesExpandRegionReq);
BoxPtr pTmp;
BoxPtr pSrc;
int nBoxes;
int i;
REQUEST_SIZE_MATCH (xXFixesExpandRegionReq);
VERIFY_REGION(pSource, stuff->source, client, DixReadAccess);
VERIFY_REGION(pDestination, stuff->destination, client, DixWriteAccess);
nBoxes = REGION_NUM_RECTS(pSource);
pSrc = REGION_RECTS(pSource);
if (nBoxes)
{
pTmp = xalloc (nBoxes * sizeof (BoxRec));
if (!pTmp)
return BadAlloc;
for (i = 0; i < nBoxes; i++)
{
pTmp[i].x1 = pSrc[i].x1 - stuff->left;
pTmp[i].x2 = pSrc[i].x2 + stuff->right;
pTmp[i].y1 = pSrc[i].y1 - stuff->top;
pTmp[i].y2 = pSrc[i].y2 + stuff->bottom;
}
REGION_EMPTY (pScreen, pDestination);
for (i = 0; i < nBoxes; i++)
{
RegionRec r;
REGION_INIT (pScreen, &r, &pTmp[i], 0);
REGION_UNION (pScreen, pDestination, pDestination, &r);
}
xfree(pTmp);
}
if (ret == Success)
ret = client->noClientException;
return ret;
}
int
ProcXFixesDestroyRegion (ClientPtr client)
{
REQUEST (xXFixesDestroyRegionReq);
RegionPtr pRegion;
REQUEST_SIZE_MATCH(xXFixesDestroyRegionReq);
VERIFY_REGION(pRegion, stuff->region, client, DixWriteAccess);
FreeResource (stuff->region, RT_NONE);
return(client->noClientException);
}
int
ProcXFixesFetchRegion (ClientPtr client)
{
RegionPtr pRegion;
xXFixesFetchRegionReply *reply;
xRectangle *pRect;
BoxPtr pExtent;
BoxPtr pBox;
int i, nBox;
REQUEST(xXFixesFetchRegionReq);
REQUEST_SIZE_MATCH(xXFixesFetchRegionReq);
VERIFY_REGION(pRegion, stuff->region, client, DixReadAccess);
pExtent = REGION_EXTENTS (0, pRegion);
pBox = REGION_RECTS (pRegion);
nBox = REGION_NUM_RECTS (pRegion);
reply = xalloc (sizeof (xXFixesFetchRegionReply) +
nBox * sizeof (xRectangle));
if (!reply)
return BadAlloc;
reply->type = X_Reply;
reply->sequenceNumber = client->sequence;
reply->length = nBox << 1;
reply->x = pExtent->x1;
reply->y = pExtent->y1;
reply->width = pExtent->x2 - pExtent->x1;
reply->height = pExtent->y2 - pExtent->y1;
pRect = (xRectangle *) (reply + 1);
for (i = 0; i < nBox; i++)
{
pRect[i].x = pBox[i].x1;
pRect[i].y = pBox[i].y1;
pRect[i].width = pBox[i].x2 - pBox[i].x1;
pRect[i].height = pBox[i].y2 - pBox[i].y1;
}
if (client->swapped)
{
int n;
swaps (&reply->sequenceNumber, n);
swapl (&reply->length, n);
swaps (&reply->x, n);
swaps (&reply->y, n);
swaps (&reply->width, n);
swaps (&reply->height, n);
SwapShorts ((INT16 *) pRect, nBox * 4);
}
(void) WriteToClient(client, sizeof (xXFixesFetchRegionReply) +
nBox * sizeof (xRectangle), (char *) reply);
xfree (reply);
return (client->noClientException);
}
int
ProcXFixesTranslateRegion (ClientPtr client)
{
RegionPtr pRegion;
REQUEST(xXFixesTranslateRegionReq);
REQUEST_SIZE_MATCH(xXFixesTranslateRegionReq);
VERIFY_REGION(pRegion, stuff->region, client, DixWriteAccess);
RegionTranslate(pRegion, stuff->dx, stuff->dy);
return Success;
}
int
ProcXFixesTranslateRegion (ClientPtr client)
{
RegionPtr pRegion;
REQUEST(xXFixesTranslateRegionReq);
REQUEST_SIZE_MATCH(xXFixesTranslateRegionReq);
VERIFY_REGION(pRegion, stuff->region, client, DixWriteAccess);
REGION_TRANSLATE(pScreen, pRegion, stuff->dx, stuff->dy);
return (client->noClientException);
}
int
ProcXFixesExpandRegion (ClientPtr client)
{
RegionPtr pSource, pDestination;
REQUEST (xXFixesExpandRegionReq);
BoxPtr pTmp;
BoxPtr pSrc;
int nBoxes;
int i;
REQUEST_SIZE_MATCH (xXFixesExpandRegionReq);
VERIFY_REGION(pSource, stuff->source, client, DixReadAccess);
VERIFY_REGION(pDestination, stuff->destination, client, DixWriteAccess);
nBoxes = RegionNumRects(pSource);
pSrc = RegionRects(pSource);
if (nBoxes)
{
pTmp = malloc(nBoxes * sizeof (BoxRec));
if (!pTmp)
return BadAlloc;
for (i = 0; i < nBoxes; i++)
{
pTmp[i].x1 = pSrc[i].x1 - stuff->left;
pTmp[i].x2 = pSrc[i].x2 + stuff->right;
pTmp[i].y1 = pSrc[i].y1 - stuff->top;
pTmp[i].y2 = pSrc[i].y2 + stuff->bottom;
}
RegionEmpty(pDestination);
for (i = 0; i < nBoxes; i++)
{
RegionRec r;
RegionInit(&r, &pTmp[i], 0);
RegionUnion(pDestination, pDestination, &r);
}
free(pTmp);
}
return Success;
}
static int
ProcDRI2CopyRegion(ClientPtr client)
{
REQUEST(xDRI2CopyRegionReq);
xDRI2CopyRegionReply rep;
DrawablePtr pDrawable;
int status;
RegionPtr pRegion;
REQUEST_SIZE_MATCH(xDRI2CopyRegionReq);
if (!validDrawable(client, stuff->drawable, DixWriteAccess,
&pDrawable, &status))
return status;
VERIFY_REGION(pRegion, stuff->region, client, DixReadAccess);
status = DRI2CopyRegion(pDrawable, pRegion, stuff->dest, stuff->src);
if (status != Success)
return status;
/* CopyRegion needs to be a round trip to make sure the X server
* queues the swap buffer rendering commands before the DRI client
* continues rendering. The reply has a bitmask to signal the
* presense of optional return values as well, but we're not using
* that yet.
*/
rep = (xDRI2CopyRegionReply) {
.type = X_Reply,
.sequenceNumber = client->sequence,
.length = 0
};
WriteToClient(client, sizeof(xDRI2CopyRegionReply), &rep);
return Success;
}
static void
load_swap_reply(xDRI2SwapBuffersReply * rep, CARD64 sbc)
{
rep->swap_hi = sbc >> 32;
rep->swap_lo = sbc & 0xffffffff;
}
static int
ProcDamageAdd(ClientPtr client)
{
REQUEST(xDamageAddReq);
DrawablePtr pDrawable;
RegionPtr pRegion;
REQUEST_SIZE_MATCH(xDamageAddReq);
VERIFY_REGION(pRegion, stuff->region, client, SecurityWriteAccess);
SECURITY_VERIFY_DRAWABLE(pDrawable, stuff->drawable, client,
SecurityReadAccess);
/* The region is relative to the drawable origin, so translate it out to
* screen coordinates like damage expects.
*/
REGION_TRANSLATE(pRegion, pDrawable->x, pDrawable->y);
DamageDamageRegion(pDrawable, pRegion);
REGION_TRANSLATE(pRegion, -pDrawable->x, -pDrawable->y);
return (client->noClientException);
}
static int
ProcDamageAdd (ClientPtr client)
{
REQUEST(xDamageAddReq);
DrawablePtr pDrawable;
RegionPtr pRegion;
int rc;
REQUEST_SIZE_MATCH(xDamageAddReq);
VERIFY_REGION(pRegion, stuff->region, client, DixWriteAccess);
rc = dixLookupDrawable(&pDrawable, stuff->drawable, client, 0,
DixWriteAccess);
if (rc != Success)
return rc;
/* The region is relative to the drawable origin, so translate it out to
* screen coordinates like damage expects.
*/
RegionTranslate(pRegion, pDrawable->x, pDrawable->y);
DamageDamageRegion(pDrawable, pRegion);
RegionTranslate(pRegion, -pDrawable->x, -pDrawable->y);
return Success;
}