631 lines
19 KiB
Diff
631 lines
19 KiB
Diff
From 728866dbc1246a04dc614fac94b81f6baed19959 Mon Sep 17 00:00:00 2001
|
|
From: Adam Jackson <ajax@redhat.com>
|
|
Date: Mon, 16 Sep 2013 15:17:26 -0400
|
|
Subject: [PATCH 3/6] damageext: Xineramify (v6)
|
|
|
|
v6:
|
|
- Clip window damages even more excruciatingly correctly
|
|
|
|
Screen 0 holds the "real" damage for all drawable types; the window
|
|
report hooks for other screens look up screen 0 and pile on. Therefore
|
|
we don't need to wrap Subtract, though we do have to be careful how we
|
|
subtract since we need to clip to the (apparent) root window geometry.
|
|
The real compexity is the cleverness required for deferring writing the
|
|
events, but there's no getting around that.
|
|
|
|
Add is probably (still) somewhat broken since it will only hit screen 0,
|
|
but Add really only exists for DRI1's sake, and DRI1 disables itself
|
|
with Xinerama enabled anyway. In the absence of a use case, I'm leaving
|
|
it unwrapped under Xinerama; if someone wants to define how it ought to
|
|
work, be my guest.
|
|
|
|
Signed-off-by: Adam Jackson <ajax@redhat.com>
|
|
|
|
stuff
|
|
---
|
|
Xext/panoramiX.c | 3 +
|
|
Xext/panoramiX.h | 3 +
|
|
damageext/damageext.c | 425 ++++++++++++++++++++++++++++++++++++++++++-----
|
|
damageext/damageextint.h | 4 +
|
|
4 files changed, 390 insertions(+), 45 deletions(-)
|
|
|
|
diff --git a/Xext/panoramiX.c b/Xext/panoramiX.c
|
|
index 15c38a9..ce0d072 100644
|
|
--- a/Xext/panoramiX.c
|
|
+++ b/Xext/panoramiX.c
|
|
@@ -54,6 +54,7 @@ Equipment Corporation.
|
|
#include "resource.h"
|
|
#include "picturestr.h"
|
|
#include "xfixesint.h"
|
|
+#include "damageextint.h"
|
|
#ifdef COMPOSITE
|
|
#include "compint.h"
|
|
#endif
|
|
@@ -582,6 +583,7 @@ PanoramiXExtensionInit(void)
|
|
|
|
PanoramiXRenderInit();
|
|
PanoramiXFixesInit();
|
|
+ PanoramiXDamageInit();
|
|
#ifdef COMPOSITE
|
|
PanoramiXCompositeInit();
|
|
#endif
|
|
@@ -887,6 +889,7 @@ PanoramiXResetProc(ExtensionEntry * extEntry)
|
|
|
|
PanoramiXRenderReset();
|
|
PanoramiXFixesReset();
|
|
+ PanoramiXDamageReset();
|
|
#ifdef COMPOSITE
|
|
PanoramiXCompositeReset ();
|
|
#endif
|
|
diff --git a/Xext/panoramiX.h b/Xext/panoramiX.h
|
|
index 6578dfa..b06fce4 100644
|
|
--- a/Xext/panoramiX.h
|
|
+++ b/Xext/panoramiX.h
|
|
@@ -64,6 +64,9 @@ typedef struct {
|
|
struct {
|
|
Bool root;
|
|
} pict;
|
|
+ struct {
|
|
+ Bool queued;
|
|
+ } damage;
|
|
char raw_data[4];
|
|
} u;
|
|
} PanoramiXRes;
|
|
diff --git a/damageext/damageext.c b/damageext/damageext.c
|
|
index 9521c26..7c86491 100644
|
|
--- a/damageext/damageext.c
|
|
+++ b/damageext/damageext.c
|
|
@@ -1,5 +1,6 @@
|
|
/*
|
|
* Copyright © 2002 Keith Packard
|
|
+ * Copyright 2013 Red Hat, Inc.
|
|
*
|
|
* Permission to use, copy, modify, distribute, and sell this software and its
|
|
* documentation for any purpose is hereby granted without fee, provided that
|
|
@@ -28,6 +29,15 @@
|
|
#include "protocol-versions.h"
|
|
#include "extinit.h"
|
|
|
|
+#ifdef PANORAMIX
|
|
+#include "panoramiX.h"
|
|
+#include "panoramiXsrv.h"
|
|
+
|
|
+static RESTYPE XRT_DAMAGE;
|
|
+static int (*PanoramiXSaveDamageVector[XDamageNumberRequests]) (ClientPtr);
|
|
+
|
|
+#endif
|
|
+
|
|
static unsigned char DamageReqCode;
|
|
static int DamageEventBase;
|
|
static RESTYPE DamageExtType;
|
|
@@ -37,25 +47,61 @@ static DevPrivateKeyRec DamageClientPrivateKeyRec;
|
|
#define DamageClientPrivateKey (&DamageClientPrivateKeyRec)
|
|
|
|
static void
|
|
+DamageNoteCritical(ClientPtr pClient)
|
|
+{
|
|
+ DamageClientPtr pDamageClient = GetDamageClient(pClient);
|
|
+
|
|
+ /* Composite extension marks clients with manual Subwindows as critical */
|
|
+ if (pDamageClient->critical > 0) {
|
|
+ SetCriticalOutputPending();
|
|
+ pClient->smart_priority = SMART_MAX_PRIORITY;
|
|
+ }
|
|
+}
|
|
+
|
|
+static void
|
|
+damageGetGeometry(DrawablePtr draw, int *x, int *y, int *w, int *h)
|
|
+{
|
|
+#ifdef PANORAMIX
|
|
+ if (!noPanoramiXExtension && draw->type == DRAWABLE_WINDOW) {
|
|
+ WindowPtr win = (WindowPtr)draw;
|
|
+
|
|
+ if (!win->parent) {
|
|
+ *x = screenInfo.x;
|
|
+ *y = screenInfo.y;
|
|
+ *w = screenInfo.width;
|
|
+ *h = screenInfo.height;
|
|
+ return;
|
|
+ }
|
|
+ }
|
|
+#endif
|
|
+
|
|
+ *x = draw->x;
|
|
+ *y = draw->y;
|
|
+ *w = draw->width;
|
|
+ *h = draw->height;
|
|
+}
|
|
+
|
|
+static void
|
|
DamageExtNotify(DamageExtPtr pDamageExt, BoxPtr pBoxes, int nBoxes)
|
|
{
|
|
ClientPtr pClient = pDamageExt->pClient;
|
|
- DamageClientPtr pDamageClient = GetDamageClient(pClient);
|
|
DrawablePtr pDrawable = pDamageExt->pDrawable;
|
|
xDamageNotifyEvent ev;
|
|
- int i;
|
|
+ int i, x, y, w, h;
|
|
+
|
|
+ damageGetGeometry(pDrawable, &x, &y, &w, &h);
|
|
|
|
UpdateCurrentTimeIf();
|
|
ev = (xDamageNotifyEvent) {
|
|
.type = DamageEventBase + XDamageNotify,
|
|
.level = pDamageExt->level,
|
|
.drawable = pDamageExt->drawable,
|
|
- .damage = pDamageExt->id,
|
|
+ .damage = pDamageExt->report_id,
|
|
.timestamp = currentTime.milliseconds,
|
|
- .geometry.x = pDrawable->x,
|
|
- .geometry.y = pDrawable->y,
|
|
- .geometry.width = pDrawable->width,
|
|
- .geometry.height = pDrawable->height
|
|
+ .geometry.x = x,
|
|
+ .geometry.y = y,
|
|
+ .geometry.width = w,
|
|
+ .geometry.height = h
|
|
};
|
|
if (pBoxes) {
|
|
for (i = 0; i < nBoxes; i++) {
|
|
@@ -72,15 +118,12 @@ DamageExtNotify(DamageExtPtr pDamageExt, BoxPtr pBoxes, int nBoxes)
|
|
else {
|
|
ev.area.x = 0;
|
|
ev.area.y = 0;
|
|
- ev.area.width = pDrawable->width;
|
|
- ev.area.height = pDrawable->height;
|
|
+ ev.area.width = w;
|
|
+ ev.area.height = h;
|
|
WriteEventsToClient(pClient, 1, (xEvent *) &ev);
|
|
}
|
|
- /* Composite extension marks clients with manual Subwindows as critical */
|
|
- if (pDamageClient->critical > 0) {
|
|
- SetCriticalOutputPending();
|
|
- pClient->smart_priority = SMART_MAX_PRIORITY;
|
|
- }
|
|
+
|
|
+ DamageNoteCritical(pClient);
|
|
}
|
|
|
|
static void
|
|
@@ -162,19 +205,55 @@ ProcDamageQueryVersion(ClientPtr client)
|
|
return Success;
|
|
}
|
|
|
|
+static DamageExtPtr
|
|
+DamageExtCreate(DrawablePtr pDrawable, DamageReportLevel level,
|
|
+ ClientPtr client, XID id, XID drawable, XID report_id,
|
|
+ DamageReportFunc reportFunc)
|
|
+{
|
|
+ DamageExtPtr pDamageExt = malloc(sizeof(DamageExtRec));
|
|
+ if (!pDamageExt)
|
|
+ return NULL;
|
|
+
|
|
+ pDamageExt->id = id;
|
|
+ pDamageExt->report_id = report_id;
|
|
+ pDamageExt->drawable = drawable;
|
|
+ pDamageExt->pDrawable = pDrawable;
|
|
+ pDamageExt->level = level;
|
|
+ pDamageExt->pClient = client;
|
|
+ pDamageExt->pDamage = DamageCreate(reportFunc, DamageExtDestroy, level,
|
|
+ FALSE, pDrawable->pScreen, pDamageExt);
|
|
+ if (!pDamageExt->pDamage) {
|
|
+ free(pDamageExt);
|
|
+ return NULL;
|
|
+ }
|
|
+
|
|
+ if (!AddResource(id, DamageExtType, (pointer) pDamageExt))
|
|
+ return NULL;
|
|
+
|
|
+ DamageSetReportAfterOp(pDamageExt->pDamage, TRUE);
|
|
+ DamageRegister(pDrawable, pDamageExt->pDamage);
|
|
+
|
|
+ if (pDrawable->type == DRAWABLE_WINDOW) {
|
|
+ RegionPtr pRegion = &((WindowPtr) pDrawable)->borderClip;
|
|
+ RegionTranslate(pRegion, -pDrawable->x, -pDrawable->y);
|
|
+ DamageReportDamage(pDamageExt->pDamage, pRegion);
|
|
+ RegionTranslate(pRegion, pDrawable->x, pDrawable->y);
|
|
+ }
|
|
+
|
|
+ return pDamageExt;
|
|
+}
|
|
+
|
|
static int
|
|
-ProcDamageCreate(ClientPtr client)
|
|
+doDamageCreate(ClientPtr client, XID reportDrawable, XID reportDamage,
|
|
+ DamageReportFunc reportFunc)
|
|
{
|
|
DrawablePtr pDrawable;
|
|
DamageExtPtr pDamageExt;
|
|
DamageReportLevel level;
|
|
- RegionPtr pRegion;
|
|
int rc;
|
|
|
|
REQUEST(xDamageCreateReq);
|
|
|
|
- REQUEST_SIZE_MATCH(xDamageCreateReq);
|
|
- LEGAL_NEW_RESOURCE(stuff->damage, client);
|
|
rc = dixLookupDrawable(&pDrawable, stuff->drawable, client, 0,
|
|
DixGetAttrAccess | DixReadAccess);
|
|
if (rc != Success)
|
|
@@ -198,39 +277,25 @@ ProcDamageCreate(ClientPtr client)
|
|
return BadValue;
|
|
}
|
|
|
|
- pDamageExt = malloc(sizeof(DamageExtRec));
|
|
+ pDamageExt = DamageExtCreate(pDrawable, level, client, stuff->damage,
|
|
+ reportDrawable, reportDamage, reportFunc);
|
|
if (!pDamageExt)
|
|
return BadAlloc;
|
|
- pDamageExt->id = stuff->damage;
|
|
- pDamageExt->drawable = stuff->drawable;
|
|
- pDamageExt->pDrawable = pDrawable;
|
|
- pDamageExt->level = level;
|
|
- pDamageExt->pClient = client;
|
|
- pDamageExt->pDamage = DamageCreate(DamageExtReport,
|
|
- DamageExtDestroy,
|
|
- level,
|
|
- FALSE, pDrawable->pScreen, pDamageExt);
|
|
- if (!pDamageExt->pDamage) {
|
|
- free(pDamageExt);
|
|
- return BadAlloc;
|
|
- }
|
|
- if (!AddResource(stuff->damage, DamageExtType, (pointer) pDamageExt))
|
|
- return BadAlloc;
|
|
-
|
|
- DamageSetReportAfterOp(pDamageExt->pDamage, TRUE);
|
|
- DamageRegister(pDamageExt->pDrawable, pDamageExt->pDamage);
|
|
-
|
|
- if (pDrawable->type == DRAWABLE_WINDOW) {
|
|
- pRegion = &((WindowPtr) pDrawable)->borderClip;
|
|
- RegionTranslate(pRegion, -pDrawable->x, -pDrawable->y);
|
|
- DamageReportDamage(pDamageExt->pDamage, pRegion);
|
|
- RegionTranslate(pRegion, pDrawable->x, pDrawable->y);
|
|
- }
|
|
|
|
return Success;
|
|
}
|
|
|
|
static int
|
|
+ProcDamageCreate(ClientPtr client)
|
|
+{
|
|
+ REQUEST(xDamageCreateReq);
|
|
+ REQUEST_SIZE_MATCH(xDamageCreateReq);
|
|
+ LEGAL_NEW_RESOURCE(stuff->damage, client);
|
|
+ return doDamageCreate(client, stuff->drawable, stuff->damage,
|
|
+ DamageExtReport);
|
|
+}
|
|
+
|
|
+static int
|
|
ProcDamageDestroy(ClientPtr client)
|
|
{
|
|
REQUEST(xDamageDestroyReq);
|
|
@@ -242,6 +307,88 @@ ProcDamageDestroy(ClientPtr client)
|
|
return Success;
|
|
}
|
|
|
|
+#ifdef PANORAMIX
|
|
+static RegionPtr
|
|
+DamageExtSubtractWindowClip(DamageExtPtr pDamageExt)
|
|
+{
|
|
+ WindowPtr win = (WindowPtr)pDamageExt->pDrawable;
|
|
+ PanoramiXRes *res = NULL;
|
|
+ RegionPtr ret;
|
|
+ int i;
|
|
+
|
|
+ if (!win->parent)
|
|
+ return &PanoramiXScreenRegion;
|
|
+
|
|
+ dixLookupResourceByType((void **)&res, win->drawable.id, XRT_WINDOW,
|
|
+ serverClient, DixReadAccess);
|
|
+ if (!res)
|
|
+ return NULL;
|
|
+
|
|
+ ret = RegionCreate(NULL, 0);
|
|
+ if (!ret)
|
|
+ return NULL;
|
|
+
|
|
+ FOR_NSCREENS_FORWARD(i) {
|
|
+ ScreenPtr screen;
|
|
+ if (Success != dixLookupWindow(&win, res->info[i].id, serverClient,
|
|
+ DixReadAccess))
|
|
+ goto out;
|
|
+
|
|
+ screen = win->drawable.pScreen;
|
|
+
|
|
+ RegionTranslate(ret, -screen->x, -screen->y);
|
|
+ if (!RegionUnion(ret, ret, &win->borderClip))
|
|
+ goto out;
|
|
+ RegionTranslate(ret, screen->x, screen->y);
|
|
+ }
|
|
+
|
|
+ return ret;
|
|
+
|
|
+out:
|
|
+ RegionDestroy(ret);
|
|
+ return NULL;
|
|
+}
|
|
+
|
|
+static void
|
|
+DamageExtFreeWindowClip(RegionPtr reg)
|
|
+{
|
|
+ if (reg != &PanoramiXScreenRegion)
|
|
+ RegionDestroy(reg);
|
|
+}
|
|
+#endif
|
|
+
|
|
+/*
|
|
+ * DamageSubtract intersects with borderClip, so we must reconstruct the
|
|
+ * protocol's perspective of same...
|
|
+ */
|
|
+static Bool
|
|
+DamageExtSubtract(DamageExtPtr pDamageExt, const RegionPtr pRegion)
|
|
+{
|
|
+ DamagePtr pDamage = pDamageExt->pDamage;
|
|
+
|
|
+#ifdef PANORAMIX
|
|
+ if (!noPanoramiXExtension) {
|
|
+ RegionPtr damage = DamageRegion(pDamage);
|
|
+ RegionSubtract(damage, damage, pRegion);
|
|
+
|
|
+ if (pDamageExt->pDrawable->type == DRAWABLE_WINDOW) {
|
|
+ DrawablePtr pDraw = pDamageExt->pDrawable;
|
|
+ RegionPtr clip = DamageExtSubtractWindowClip(pDamageExt);
|
|
+ if (clip) {
|
|
+ RegionTranslate(clip, -pDraw->x, -pDraw->y);
|
|
+ RegionIntersect(damage, damage, clip);
|
|
+ RegionTranslate(clip, pDraw->x, pDraw->y);
|
|
+ DamageExtFreeWindowClip(clip);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ return RegionNotEmpty(damage);
|
|
+ }
|
|
+#endif
|
|
+
|
|
+ return DamageSubtract(pDamage, pRegion);
|
|
+}
|
|
+
|
|
static int
|
|
ProcDamageSubtract(ClientPtr client)
|
|
{
|
|
@@ -261,7 +408,7 @@ ProcDamageSubtract(ClientPtr client)
|
|
if (pRepair) {
|
|
if (pParts)
|
|
RegionIntersect(pParts, DamageRegion(pDamage), pRepair);
|
|
- if (DamageSubtract(pDamage, pRepair))
|
|
+ if (DamageExtSubtract(pDamageExt, pRepair))
|
|
DamageExtReport(pDamage, DamageRegion(pDamage),
|
|
(void *) pDamageExt);
|
|
}
|
|
@@ -271,6 +418,7 @@ ProcDamageSubtract(ClientPtr client)
|
|
DamageEmpty(pDamage);
|
|
}
|
|
}
|
|
+
|
|
return Success;
|
|
}
|
|
|
|
@@ -460,6 +608,188 @@ SDamageNotifyEvent(xDamageNotifyEvent * from, xDamageNotifyEvent * to)
|
|
cpswaps(from->geometry.height, to->geometry.height);
|
|
}
|
|
|
|
+#ifdef PANORAMIX
|
|
+
|
|
+static void
|
|
+damageDispatchCallback(CallbackListPtr *cbl, void *closure, void *unused)
|
|
+{
|
|
+ DamageExtPtr pDamageExt = closure;
|
|
+ RegionPtr pRegion = DamageRegion(pDamageExt->pDamage);
|
|
+ PanoramiXRes *damage = NULL;
|
|
+
|
|
+ DamageExtReport(pDamageExt->pDamage, pRegion, pDamageExt);
|
|
+ DeleteCallback(&PostDispatchCallback, damageDispatchCallback, pDamageExt);
|
|
+
|
|
+ dixLookupResourceByType((void **)&damage, pDamageExt->id, XRT_DAMAGE,
|
|
+ serverClient, DixWriteAccess);
|
|
+
|
|
+ if (damage)
|
|
+ damage->u.damage.queued = FALSE;
|
|
+}
|
|
+
|
|
+/* for screen 0 */
|
|
+static void
|
|
+PanoramiXDamageQueue(DamagePtr pDamage, RegionPtr pRegion, void *closure)
|
|
+{
|
|
+ DamageExtPtr pDamageExt = closure;
|
|
+ PanoramiXRes *damage = NULL;
|
|
+
|
|
+ /* happens on unmap? sigh xinerama */
|
|
+ if (RegionNil(pRegion))
|
|
+ return;
|
|
+
|
|
+ dixLookupResourceByType((void **)&damage, pDamageExt->report_id, XRT_DAMAGE,
|
|
+ serverClient, DixWriteAccess);
|
|
+
|
|
+ if (damage) {
|
|
+ if (!damage->u.damage.queued) {
|
|
+ AddCallback(&PostDispatchCallback, damageDispatchCallback,
|
|
+ pDamageExt);
|
|
+ damage->u.damage.queued = TRUE;
|
|
+ }
|
|
+ }
|
|
+
|
|
+ DamageNoteCritical(pDamageExt->pClient);
|
|
+}
|
|
+
|
|
+/* for screens 1 to n */
|
|
+static void
|
|
+PanoramiXDamageAccumulate(DamagePtr pDamage, RegionPtr pRegion, void *closure)
|
|
+{
|
|
+ DamageExtPtr pDamageExt = closure, pDamageExt0 = NULL;
|
|
+ PanoramiXRes *damage = NULL;
|
|
+
|
|
+ /* happens on unmap? sigh xinerama */
|
|
+ if (RegionNil(pRegion))
|
|
+ return;
|
|
+
|
|
+ dixLookupResourceByType((void **)&damage, pDamageExt->report_id, XRT_DAMAGE,
|
|
+ serverClient, DixWriteAccess);
|
|
+
|
|
+ if (damage) {
|
|
+ dixLookupResourceByType((void **)&pDamageExt0, damage->info[0].id,
|
|
+ DamageExtType, serverClient, DixWriteAccess);
|
|
+
|
|
+ if (pDamageExt0) {
|
|
+ DrawablePtr pDrawable = pDamageExt->pDrawable;
|
|
+ ScreenPtr pScreen = pDrawable->pScreen;
|
|
+
|
|
+ if (pDrawable->type == DRAWABLE_WINDOW) {
|
|
+ WindowPtr pWin = (WindowPtr)pDrawable;
|
|
+
|
|
+ if (!pWin->parent)
|
|
+ if (RegionNotEmpty(pRegion))
|
|
+ RegionTranslate(pRegion, pScreen->x, pScreen->y);
|
|
+ }
|
|
+
|
|
+ DamageReportDamage(pDamageExt0->pDamage, pRegion);
|
|
+ DamageEmpty(pDamageExt->pDamage);
|
|
+ }
|
|
+ }
|
|
+}
|
|
+
|
|
+static int
|
|
+PanoramiXDamageCreate(ClientPtr client)
|
|
+{
|
|
+ PanoramiXRes *draw, *damage;
|
|
+ int i, rc;
|
|
+
|
|
+ REQUEST(xDamageCreateReq);
|
|
+
|
|
+ REQUEST_SIZE_MATCH(xDamageCreateReq);
|
|
+ LEGAL_NEW_RESOURCE(stuff->damage, client);
|
|
+ rc = dixLookupResourceByClass((void **)&draw, stuff->drawable, XRC_DRAWABLE,
|
|
+ client, DixGetAttrAccess | DixReadAccess);
|
|
+ if (rc != Success)
|
|
+ return rc;
|
|
+
|
|
+ if (!(damage = calloc(1, sizeof(PanoramiXRes))))
|
|
+ return BadAlloc;
|
|
+
|
|
+ damage->type = XRT_DAMAGE;
|
|
+ if (!AddResource(stuff->damage, XRT_DAMAGE, damage))
|
|
+ return BadAlloc;
|
|
+
|
|
+ /* pixmaps exist on all screens, so just watching screen 0 works */
|
|
+ if (draw->type == XRT_PIXMAP) {
|
|
+ damage->info[0].id = stuff->damage;
|
|
+
|
|
+ rc = PanoramiXSaveDamageVector[X_DamageCreate](client);
|
|
+ if (rc != Success) {
|
|
+ FreeResource(damage->info[0].id, None);
|
|
+ return rc;
|
|
+ }
|
|
+ } else {
|
|
+ rc = doDamageCreate(client, stuff->drawable, stuff->damage,
|
|
+ PanoramiXDamageQueue);
|
|
+ if (rc == Success) {
|
|
+ panoramix_setup_ids(damage, client, stuff->damage);
|
|
+
|
|
+ FOR_NSCREENS_FORWARD_SKIP(i) {
|
|
+ stuff->damage = damage->info[i].id;
|
|
+ stuff->drawable = draw->info[i].id;
|
|
+ rc = doDamageCreate(client, draw->info[0].id,
|
|
+ damage->info[0].id,
|
|
+ PanoramiXDamageAccumulate);
|
|
+ if (rc != Success)
|
|
+ FreeResource(damage->info[0].id, None);
|
|
+ }
|
|
+ } else {
|
|
+ FreeResource(damage->info[0].id, None);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ return rc;
|
|
+}
|
|
+
|
|
+static int
|
|
+PanoramiXDamageDestroy(ClientPtr client)
|
|
+{
|
|
+ REQUEST(xDamageDestroyReq);
|
|
+ PanoramiXRes *damage;
|
|
+ int i, rc = Success;
|
|
+
|
|
+ REQUEST_SIZE_MATCH(xDamageDestroyReq);
|
|
+
|
|
+ rc = dixLookupResourceByType((void **)&damage, stuff->damage, XRT_DAMAGE,
|
|
+ client, DixDestroyAccess);
|
|
+ if (rc != Success)
|
|
+ return rc;
|
|
+
|
|
+ FOR_NSCREENS_BACKWARD(i) {
|
|
+ stuff->damage = damage->info[i].id;
|
|
+ if (stuff->damage) {
|
|
+ rc = PanoramiXSaveDamageVector[X_DamageDestroy](client);
|
|
+ if (rc != Success)
|
|
+ break;
|
|
+ }
|
|
+ }
|
|
+
|
|
+ return rc;
|
|
+}
|
|
+
|
|
+void
|
|
+PanoramiXDamageInit(void)
|
|
+{
|
|
+ XRT_DAMAGE = CreateNewResourceType(XineramaDeleteResource,
|
|
+ "XineramaDamage");
|
|
+
|
|
+ memcpy(PanoramiXSaveDamageVector, ProcDamageVector,
|
|
+ sizeof(ProcDamageVector));
|
|
+
|
|
+ ProcDamageVector[X_DamageCreate] = PanoramiXDamageCreate;
|
|
+ ProcDamageVector[X_DamageDestroy] = PanoramiXDamageDestroy;
|
|
+}
|
|
+
|
|
+void
|
|
+PanoramiXDamageReset(void)
|
|
+{
|
|
+ memcpy(ProcDamageVector, PanoramiXSaveDamageVector,
|
|
+ sizeof(ProcDamageVector));
|
|
+}
|
|
+
|
|
+#endif /* PANORAMIX */
|
|
+
|
|
void
|
|
DamageExtensionInit(void)
|
|
{
|
|
@@ -490,5 +820,10 @@ DamageExtensionInit(void)
|
|
(EventSwapPtr) SDamageNotifyEvent;
|
|
SetResourceTypeErrorValue(DamageExtType,
|
|
extEntry->errorBase + BadDamage);
|
|
+#ifdef PANORAMIX
|
|
+ if (XRT_DAMAGE)
|
|
+ SetResourceTypeErrorValue(XRT_DAMAGE,
|
|
+ extEntry->errorBase + BadDamage);
|
|
+#endif
|
|
}
|
|
}
|
|
diff --git a/damageext/damageextint.h b/damageext/damageextint.h
|
|
index 2723379..7319a1d 100644
|
|
--- a/damageext/damageextint.h
|
|
+++ b/damageext/damageextint.h
|
|
@@ -54,6 +54,7 @@ typedef struct _DamageExt {
|
|
DamageReportLevel level;
|
|
ClientPtr pClient;
|
|
XID id;
|
|
+ XID report_id;
|
|
XID drawable;
|
|
} DamageExtRec, *DamageExtPtr;
|
|
|
|
@@ -67,4 +68,7 @@ typedef struct _DamageExt {
|
|
void
|
|
DamageExtSetCritical(ClientPtr pClient, Bool critical);
|
|
|
|
+void PanoramiXDamageInit(void);
|
|
+void PanoramiXDamageReset(void);
|
|
+
|
|
#endif /* _DAMAGEEXTINT_H_ */
|
|
--
|
|
1.8.3.1
|
|
|