static int
ProcDamageSubtract (ClientPtr client)
{
REQUEST(xDamageSubtractReq);
DamageExtPtr pDamageExt;
RegionPtr pRepair;
RegionPtr pParts;
REQUEST_SIZE_MATCH(xDamageSubtractReq);
VERIFY_DAMAGEEXT(pDamageExt, stuff->damage, client, SecurityWriteAccess);
VERIFY_REGION_OR_NONE(pRepair, stuff->repair, client, SecurityWriteAccess);
VERIFY_REGION_OR_NONE(pParts, stuff->parts, client, SecurityWriteAccess);
if (pDamageExt->level != DamageReportRawRegion)
{
DamagePtr pDamage = pDamageExt->pDamage;
if (pRepair)
{
if (pParts)
REGION_INTERSECT (prScreen, pParts, DamageRegion (pDamage), pRepair);
if (DamageSubtract (pDamage, pRepair))
DamageExtReport (pDamage, DamageRegion (pDamage), (void *) pDamageExt);
}
else
{
if (pParts)
REGION_COPY (prScreen, pParts, DamageRegion (pDamage));
DamageEmpty (pDamage);
}
}
return (client->noClientException);
}
static int
ProcDamageSubtract (ClientPtr client)
{
REQUEST(xDamageSubtractReq);
DamageExtPtr pDamageExt;
RegionPtr pRepair;
RegionPtr pParts;
REQUEST_SIZE_MATCH(xDamageSubtractReq);
VERIFY_DAMAGEEXT(pDamageExt, stuff->damage, client, DixWriteAccess);
VERIFY_REGION_OR_NONE(pRepair, stuff->repair, client, DixWriteAccess);
VERIFY_REGION_OR_NONE(pParts, stuff->parts, client, DixWriteAccess);
if (pDamageExt->level != DamageReportRawRegion)
{
DamagePtr pDamage = pDamageExt->pDamage;
if (pRepair)
{
if (pParts)
RegionIntersect(pParts, DamageRegion (pDamage), pRepair);
if (DamageSubtract (pDamage, pRepair))
DamageExtReport (pDamage, DamageRegion (pDamage), (void *) pDamageExt);
}
else
{
if (pParts)
RegionCopy(pParts, DamageRegion (pDamage));
DamageEmpty (pDamage);
}
}
return Success;
}
int
ProcXFixesSetGCClipRegion (ClientPtr client)
{
GCPtr pGC;
RegionPtr pRegion;
XID vals[2];
int rc;
REQUEST(xXFixesSetGCClipRegionReq);
REQUEST_SIZE_MATCH(xXFixesSetGCClipRegionReq);
rc = dixLookupGC(&pGC, stuff->gc, client, DixWriteAccess);
if (rc != Success)
return rc;
VERIFY_REGION_OR_NONE (pRegion, stuff->region, client, DixReadAccess);
if (pRegion)
{
pRegion = XFixesRegionCopy (pRegion);
if (!pRegion)
return BadAlloc;
}
vals[0] = stuff->xOrigin;
vals[1] = stuff->yOrigin;
DoChangeGC (pGC, GCClipXOrigin|GCClipYOrigin, vals, 0);
(*pGC->funcs->ChangeClip)(pGC, pRegion ? CT_REGION : CT_NONE, (pointer)pRegion, 0);
return (client->noClientException);
}
int
ProcXFixesSetGCClipRegion(ClientPtr client)
{
GCPtr pGC;
RegionPtr pRegion;
ChangeGCVal vals[2];
int rc;
REQUEST(xXFixesSetGCClipRegionReq);
REQUEST_SIZE_MATCH(xXFixesSetGCClipRegionReq);
rc = dixLookupGC(&pGC, stuff->gc, client, DixSetAttrAccess);
if (rc != Success)
return rc;
VERIFY_REGION_OR_NONE(pRegion, stuff->region, client, DixReadAccess);
if (pRegion) {
pRegion = XFixesRegionCopy(pRegion);
if (!pRegion)
return BadAlloc;
}
vals[0].val = stuff->xOrigin;
vals[1].val = stuff->yOrigin;
ChangeGC(NullClient, pGC, GCClipXOrigin | GCClipYOrigin, vals);
(*pGC->funcs->ChangeClip) (pGC, pRegion ? CT_REGION : CT_NONE,
(void *) pRegion, 0);
return Success;
}
int
ProcXFixesSetPictureClipRegion (ClientPtr client)
{
PicturePtr pPicture;
RegionPtr pRegion;
REQUEST(xXFixesSetPictureClipRegionReq);
REQUEST_SIZE_MATCH (xXFixesSetPictureClipRegionReq);
VERIFY_PICTURE(pPicture, stuff->picture, client, DixSetAttrAccess);
VERIFY_REGION_OR_NONE(pRegion, stuff->region, client, DixReadAccess);
return SetPictureClipRegion (pPicture, stuff->xOrigin, stuff->yOrigin,
pRegion);
}
int
PanoramiXFixesSetWindowShapeRegion(ClientPtr client)
{
int result = Success, j;
PanoramiXRes *win;
RegionPtr reg = NULL;
REQUEST(xXFixesSetWindowShapeRegionReq);
REQUEST_SIZE_MATCH(xXFixesSetWindowShapeRegionReq);
if ((result = dixLookupResourceByType((void **) &win, stuff->dest,
XRT_WINDOW, client,
DixWriteAccess))) {
client->errorValue = stuff->dest;
return result;
}
if (win->u.win.root)
VERIFY_REGION_OR_NONE(reg, stuff->region, client, DixReadAccess);
FOR_NSCREENS_FORWARD(j) {
ScreenPtr screen = screenInfo.screens[j];
stuff->dest = win->info[j].id;
if (reg)
RegionTranslate(reg, -screen->x, -screen->y);
result =
(*PanoramiXSaveXFixesVector[X_XFixesSetWindowShapeRegion]) (client);
if (reg)
RegionTranslate(reg, screen->x, screen->y);
if (result != Success)
break;
}
return result;
}
int
PanoramiXFixesSetPictureClipRegion(ClientPtr client)
{
REQUEST(xXFixesSetPictureClipRegionReq);
int result = Success, j;
PanoramiXRes *pict;
RegionPtr reg = NULL;
REQUEST_SIZE_MATCH(xXFixesSetPictureClipRegionReq);
if ((result = dixLookupResourceByType((void **) &pict, stuff->picture,
XRT_PICTURE, client,
DixWriteAccess))) {
client->errorValue = stuff->picture;
return result;
}
if (pict->u.pict.root)
VERIFY_REGION_OR_NONE(reg, stuff->region, client, DixReadAccess);
FOR_NSCREENS_BACKWARD(j) {
ScreenPtr screen = screenInfo.screens[j];
stuff->picture = pict->info[j].id;
if (reg)
RegionTranslate(reg, -screen->x, -screen->y);
result =
(*PanoramiXSaveXFixesVector[X_XFixesSetPictureClipRegion]) (client);
if (reg)
RegionTranslate(reg, screen->x, screen->y);
if (result != Success)
break;
}
return result;
}
int
ProcXFixesSetPictureClipRegion (ClientPtr client)
{
#ifdef RENDER
PicturePtr pPicture;
RegionPtr pRegion;
ScreenPtr pScreen;
PictureScreenPtr ps;
REQUEST(xXFixesSetPictureClipRegionReq);
REQUEST_SIZE_MATCH (xXFixesSetPictureClipRegionReq);
VERIFY_PICTURE(pPicture, stuff->picture, client, DixWriteAccess,
RenderErrBase + BadPicture);
pScreen = pPicture->pDrawable->pScreen;
ps = GetPictureScreen (pScreen);
VERIFY_REGION_OR_NONE(pRegion, stuff->region, client, DixReadAccess);
return SetPictureClipRegion (pPicture, stuff->xOrigin, stuff->yOrigin,
pRegion);
#else
return BadRequest;
#endif
}
int
ProcXFixesSetWindowShapeRegion (ClientPtr client)
{
#ifdef SHAPE
WindowPtr pWin;
ScreenPtr pScreen;
RegionPtr pRegion;
RegionPtr *pDestRegion;
REQUEST(xXFixesSetWindowShapeRegionReq);
REQUEST_SIZE_MATCH(xXFixesSetWindowShapeRegionReq);
pWin = (WindowPtr) LookupIDByType (stuff->dest, RT_WINDOW);
if (!pWin)
{
client->errorValue = stuff->dest;
return BadWindow;
}
VERIFY_REGION_OR_NONE(pRegion, stuff->region, client, DixWriteAccess);
pScreen = pWin->drawable.pScreen;
switch (stuff->destKind) {
case ShapeBounding:
case ShapeClip:
case ShapeInput:
break;
default:
client->errorValue = stuff->destKind;
return BadValue;
}
if (pRegion)
{
pRegion = XFixesRegionCopy (pRegion);
if (!pRegion)
return BadAlloc;
if (!pWin->optional)
MakeWindowOptional (pWin);
switch (stuff->destKind) {
default:
case ShapeBounding:
pDestRegion = &pWin->optional->boundingShape;
break;
case ShapeClip:
pDestRegion = &pWin->optional->clipShape;
break;
case ShapeInput:
pDestRegion = &pWin->optional->inputShape;
break;
}
if (stuff->xOff || stuff->yOff)
REGION_TRANSLATE (0, pRegion, stuff->xOff, stuff->yOff);
}
else
{
if (pWin->optional)
{
switch (stuff->destKind) {
default:
case ShapeBounding:
pDestRegion = &pWin->optional->boundingShape;
break;
case ShapeClip:
pDestRegion = &pWin->optional->clipShape;
break;
case ShapeInput:
pDestRegion = &pWin->optional->inputShape;
break;
}
}
else
pDestRegion = &pRegion; /* a NULL region pointer */
}
if (*pDestRegion)
REGION_DESTROY(pScreen, *pDestRegion);
*pDestRegion = pRegion;
(*pScreen->SetShape) (pWin);
SendShapeNotify (pWin, stuff->destKind);
return (client->noClientException);
#else
return BadRequest;
#endif
}
int
ProcXFixesSetWindowShapeRegion(ClientPtr client)
{
WindowPtr pWin;
RegionPtr pRegion;
RegionPtr *pDestRegion;
int rc;
REQUEST(xXFixesSetWindowShapeRegionReq);
REQUEST_SIZE_MATCH(xXFixesSetWindowShapeRegionReq);
rc = dixLookupResourceByType((void **) &pWin, stuff->dest, RT_WINDOW,
client, DixSetAttrAccess);
if (rc != Success) {
client->errorValue = stuff->dest;
return rc;
}
VERIFY_REGION_OR_NONE(pRegion, stuff->region, client, DixWriteAccess);
switch (stuff->destKind) {
case ShapeBounding:
case ShapeClip:
case ShapeInput:
break;
default:
client->errorValue = stuff->destKind;
return BadValue;
}
if (pRegion) {
pRegion = XFixesRegionCopy(pRegion);
if (!pRegion)
return BadAlloc;
if (!pWin->optional)
MakeWindowOptional(pWin);
switch (stuff->destKind) {
default:
case ShapeBounding:
pDestRegion = &pWin->optional->boundingShape;
break;
case ShapeClip:
pDestRegion = &pWin->optional->clipShape;
break;
case ShapeInput:
pDestRegion = &pWin->optional->inputShape;
break;
}
if (stuff->xOff || stuff->yOff)
RegionTranslate(pRegion, stuff->xOff, stuff->yOff);
}
else {
if (pWin->optional) {
switch (stuff->destKind) {
default:
case ShapeBounding:
pDestRegion = &pWin->optional->boundingShape;
break;
case ShapeClip:
pDestRegion = &pWin->optional->clipShape;
break;
case ShapeInput:
pDestRegion = &pWin->optional->inputShape;
break;
}
}
else
pDestRegion = &pRegion; /* a NULL region pointer */
}
if (*pDestRegion)
RegionDestroy(*pDestRegion);
*pDestRegion = pRegion;
(*pWin->drawable.pScreen->SetShape) (pWin, stuff->destKind);
SendShapeNotify(pWin, stuff->destKind);
return Success;
}
static int
proc_present_query_version(ClientPtr client)
{
REQUEST(xPresentQueryVersionReq);
xPresentQueryVersionReply rep = {
.type = X_Reply,
.sequenceNumber = client->sequence,
.length = 0,
.majorVersion = PRESENT_MAJOR,
.minorVersion = PRESENT_MINOR
};
REQUEST_SIZE_MATCH(xPresentQueryVersionReq);
(void) stuff;
if (client->swapped) {
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swapl(&rep.majorVersion);
swapl(&rep.minorVersion);
}
WriteToClient(client, sizeof(rep), &rep);
return Success;
}
#define VERIFY_FENCE_OR_NONE(fence_ptr, fence_id, client, access) do { \
if ((fence_id) == None) \
(fence_ptr) = NULL; \
else { \
int __rc__ = SyncVerifyFence(&fence_ptr, fence_id, client, access); \
if (__rc__ != Success) \
return __rc__; \
} \
} while (0)
#define VERIFY_CRTC_OR_NONE(crtc_ptr, crtc_id, client, access) do { \
if ((crtc_id) == None) \
(crtc_ptr) = NULL; \
else { \
VERIFY_RR_CRTC(crtc_id, crtc_ptr, access); \
} \
} while (0)
static int
proc_present_pixmap(ClientPtr client)
{
REQUEST(xPresentPixmapReq);
WindowPtr window;
PixmapPtr pixmap;
RegionPtr valid = NULL;
RegionPtr update = NULL;
SyncFence *wait_fence;
SyncFence *idle_fence;
RRCrtcPtr target_crtc;
int ret;
int nnotifies;
present_notify_ptr notifies = NULL;
REQUEST_AT_LEAST_SIZE(xPresentPixmapReq);
ret = dixLookupWindow(&window, stuff->window, client, DixWriteAccess);
if (ret != Success)
return ret;
ret = dixLookupResourceByType((pointer *) &pixmap, stuff->pixmap, RT_PIXMAP, client, DixReadAccess);
if (ret != Success)
return ret;
if (window->drawable.depth != pixmap->drawable.depth)
return BadMatch;
VERIFY_REGION_OR_NONE(valid, stuff->valid, client, DixReadAccess);
VERIFY_REGION_OR_NONE(update, stuff->update, client, DixReadAccess);
VERIFY_CRTC_OR_NONE(target_crtc, stuff->target_crtc, client, DixReadAccess);
VERIFY_FENCE_OR_NONE(wait_fence, stuff->wait_fence, client, DixReadAccess);
VERIFY_FENCE_OR_NONE(idle_fence, stuff->idle_fence, client, DixWriteAccess);
if (stuff->options & ~(PresentAllOptions)) {
client->errorValue = stuff->options;
return BadValue;
}
/*
* Check to see if remainder is sane
*/
if (stuff->divisor == 0) {
if (stuff->remainder != 0) {
client->errorValue = (CARD32) stuff->remainder;
return BadValue;
}
} else {
if (stuff->remainder >= stuff->divisor) {
client->errorValue = (CARD32) stuff->remainder;
return BadValue;
}
}
nnotifies = (client->req_len << 2) - sizeof (xPresentPixmapReq);
if (nnotifies % sizeof (xPresentNotify))
return BadLength;
nnotifies /= sizeof (xPresentNotify);
if (nnotifies) {
ret = present_create_notifies(client, nnotifies, (xPresentNotify *) (stuff + 1), ¬ifies);
if (ret != Success)
return ret;
}
ret = present_pixmap(window, pixmap, stuff->serial, valid, update,
stuff->x_off, stuff->y_off, target_crtc,
wait_fence, idle_fence, stuff->options,
stuff->target_msc, stuff->divisor, stuff->remainder, notifies, nnotifies);
if (ret != Success)
present_destroy_notifies(notifies, nnotifies);
return ret;
}
