frederik
/
xserver
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge remote branch 'jamey/for-keith'

This commit is contained in:
Keith Packard 2010-06-03 15:09:32 -07:00
parent aa7c09f7d0 f114f54986
commit 0f12e86e60
73 changed files with 599 additions and 959 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

103
Xext/panoramiX.c
View File

@ -70,7 +70,6 @@ int PanoramiXPixWidth = 0;
int PanoramiXPixHeight = 0;
int PanoramiXNumScreens = 0;
PanoramiXData *panoramiXdataPtr = NULL;
static RegionRec PanoramiXScreenRegion = {{0, 0, 0, 0}, NULL};
static int PanoramiXNumDepths;
@ -120,8 +119,6 @@ typedef struct {
CloseScreenProcPtr CloseScreen;
} PanoramiXScreenRec, *PanoramiXScreenPtr;
RegionRec XineramaScreenRegions[MAXSCREENS];
static void XineramaValidateGC(GCPtr, unsigned long, DrawablePtr);
static void XineramaChangeGC(GCPtr, unsigned long);
static void XineramaCopyGC(GCPtr, unsigned long, GCPtr);
@ -154,7 +151,6 @@ XineramaCloseScreen (int i, ScreenPtr pScreen)
pScreen->CloseScreen = pScreenPriv->CloseScreen;
pScreen->CreateGC = pScreenPriv->CreateGC;
REGION_UNINIT(pScreen, &XineramaScreenRegions[pScreen->myNum]);
if (pScreen->myNum == 0)
REGION_UNINIT(pScreen, &PanoramiXScreenRegion);
@ -199,8 +195,8 @@ XineramaValidateGC(
if((pDraw->type == DRAWABLE_WINDOW) && !(((WindowPtr)pDraw)->parent)) {
/* the root window */
int x_off = panoramiXdataPtr[pGC->pScreen->myNum].x;
int y_off = panoramiXdataPtr[pGC->pScreen->myNum].y;
int x_off = pGC->pScreen->x;
int y_off = pGC->pScreen->y;
int new_val;
new_val = pGCPriv->clipOrg.x - x_off;
@ -393,30 +389,28 @@ static void XineramaInitData(ScreenPtr pScreen)
REGION_NULL(pScreen, &PanoramiXScreenRegion)
for (i = 0; i < PanoramiXNumScreens; i++) {
BoxRec TheBox;
RegionRec ScreenRegion;
pScreen = screenInfo.screens[i];
panoramiXdataPtr[i].x = dixScreenOrigins[i].x;
panoramiXdataPtr[i].y = dixScreenOrigins[i].y;
panoramiXdataPtr[i].width = pScreen->width;
panoramiXdataPtr[i].height = pScreen->height;
TheBox.x1 = pScreen->x;
TheBox.x2 = TheBox.x1 + pScreen->width;
TheBox.y1 = pScreen->y;
TheBox.y2 = TheBox.y1 + pScreen->height;
TheBox.x1 = panoramiXdataPtr[i].x;
TheBox.x2 = TheBox.x1 + panoramiXdataPtr[i].width;
TheBox.y1 = panoramiXdataPtr[i].y;
TheBox.y2 = TheBox.y1 + panoramiXdataPtr[i].height;
REGION_INIT(pScreen, &XineramaScreenRegions[i], &TheBox, 1);
REGION_INIT(pScreen, &ScreenRegion, &TheBox, 1);
REGION_UNION(pScreen, &PanoramiXScreenRegion, &PanoramiXScreenRegion,
&XineramaScreenRegions[i]);
&ScreenRegion);
REGION_UNINIT(pScreen, &ScreenRegion);
}
PanoramiXPixWidth = panoramiXdataPtr[0].x + panoramiXdataPtr[0].width;
PanoramiXPixHeight = panoramiXdataPtr[0].y + panoramiXdataPtr[0].height;
PanoramiXPixWidth = screenInfo.screens[0]->x + screenInfo.screens[0]->width;
PanoramiXPixHeight = screenInfo.screens[0]->y + screenInfo.screens[0]->height;
for (i = 1; i < PanoramiXNumScreens; i++) {
w = panoramiXdataPtr[i].x + panoramiXdataPtr[i].width;
h = panoramiXdataPtr[i].y + panoramiXdataPtr[i].height;
pScreen = screenInfo.screens[i];
w = pScreen->x + pScreen->width;
h = pScreen->y + pScreen->height;
if (PanoramiXPixWidth < w)
PanoramiXPixWidth = w;
@ -427,12 +421,7 @@ static void XineramaInitData(ScreenPtr pScreen)
void XineramaReinitData(ScreenPtr pScreen)
{
int i;
REGION_UNINIT(pScreen, &PanoramiXScreenRegion);
for (i = 0; i < PanoramiXNumScreens; i++)
REGION_UNINIT(pScreen, &XineramaScreenRegions[i]);
XineramaInitData(pScreen);
}
@ -473,12 +462,6 @@ void PanoramiXExtensionInit(int argc, char *argv[])
* run in non-PanoramiXeen mode.
*/
panoramiXdataPtr = (PanoramiXData *)
calloc(PanoramiXNumScreens, sizeof(PanoramiXData));
if (!panoramiXdataPtr)
break;
if (!dixRequestPrivate(PanoramiXGCKey, sizeof(PanoramiXGCRec))) {
noPanoramiXExtension = TRUE;
return;
@ -836,13 +819,14 @@ PanoramiXConsolidate(void)
saver->type = XRT_WINDOW;
for (i = 0; i < PanoramiXNumScreens; i++) {
root->info[i].id = WindowTable[i]->drawable.id;
ScreenPtr pScreen = screenInfo.screens[i];
root->info[i].id = pScreen->root->drawable.id;
root->u.win.class = InputOutput;
root->u.win.root = TRUE;
saver->info[i].id = savedScreenInfo[i].wid;
saver->info[i].id = pScreen->screensaver.wid;
saver->u.win.class = InputOutput;
saver->u.win.root = TRUE;
defmap->info[i].id = (screenInfo.screens[i])->defColormap;
defmap->info[i].id = pScreen->defColormap;
}
AddResource(root->info[0].id, XRT_WINDOW, root);
@ -896,8 +880,6 @@ static void PanoramiXResetProc(ExtensionEntry* extEntry)
screenInfo.numScreens = PanoramiXNumScreens;
for (i = 256; i--; )
ProcVector[i] = SavedProcVector[i];
free(panoramiXdataPtr);
}
@ -999,8 +981,8 @@ ProcPanoramiXGetScreenSize(ClientPtr client)
rep.length = 0;
rep.sequenceNumber = client->sequence;
/* screen dimensions */
rep.width = panoramiXdataPtr[stuff->screen].width;
rep.height = panoramiXdataPtr[stuff->screen].height;
rep.width = screenInfo.screens[stuff->screen]->width;
rep.height = screenInfo.screens[stuff->screen]->height;
rep.window = stuff->window;
rep.screen = stuff->screen;
if (client->swapped) {
@ -1072,10 +1054,10 @@ ProcXineramaQueryScreens(ClientPtr client)
int i;
for(i = 0; i < PanoramiXNumScreens; i++) {
scratch.x_org = panoramiXdataPtr[i].x;
scratch.y_org = panoramiXdataPtr[i].y;
scratch.width = panoramiXdataPtr[i].width;
scratch.height = panoramiXdataPtr[i].height;
scratch.x_org = screenInfo.screens[i]->x;
scratch.y_org = screenInfo.screens[i]->y;
scratch.width = screenInfo.screens[i]->width;
scratch.height = screenInfo.screens[i]->height;
if(client->swapped) {
int n;
@ -1153,7 +1135,7 @@ XineramaGetImageData(
int pitch,
Bool isRoot
){
RegionRec SrcRegion, GrabRegion;
RegionRec SrcRegion, ScreenRegion, GrabRegion;
BoxRec SrcBox, *pbox;
int x, y, w, h, i, j, nbox, size, sizeNeeded, ScratchPitch, inOut, depth;
DrawablePtr pDraw = pDrawables[0];
@ -1165,8 +1147,8 @@ XineramaGetImageData(
SrcBox.x1 = left;
SrcBox.y1 = top;
if(!isRoot) {
SrcBox.x1 += pDraw->x + panoramiXdataPtr[0].x;
SrcBox.y1 += pDraw->y + panoramiXdataPtr[0].y;
SrcBox.x1 += pDraw->x + screenInfo.screens[0]->x;
SrcBox.y1 += pDraw->y + screenInfo.screens[0]->y;
}
SrcBox.x2 = SrcBox.x1 + width;
SrcBox.y2 = SrcBox.y1 + height;
@ -1177,22 +1159,31 @@ XineramaGetImageData(
depth = (format == XYPixmap) ? 1 : pDraw->depth;
for(i = 0; i < PanoramiXNumScreens; i++) {
BoxRec TheBox;
ScreenPtr pScreen;
pDraw = pDrawables[i];
pScreen = pDraw->pScreen;
inOut = RECT_IN_REGION(pScreen,&XineramaScreenRegions[i],&SrcBox);
TheBox.x1 = pScreen->x;
TheBox.x2 = TheBox.x1 + pScreen->width;
TheBox.y1 = pScreen->y;
TheBox.y2 = TheBox.y1 + pScreen->height;
REGION_INIT(pScreen, &ScreenRegion, &TheBox, 1);
inOut = RECT_IN_REGION(pScreen, &ScreenRegion, &SrcBox);
if(inOut == rgnPART)
REGION_INTERSECT(pScreen, &GrabRegion, &SrcRegion, &ScreenRegion);
REGION_UNINIT(pScreen, &ScreenRegion);
if(inOut == rgnIN) {
(*pDraw->pScreen->GetImage)(pDraw,
SrcBox.x1 - pDraw->x - panoramiXdataPtr[i].x,
SrcBox.y1 - pDraw->y - panoramiXdataPtr[i].y,
(*pScreen->GetImage)(pDraw,
SrcBox.x1 - pDraw->x - screenInfo.screens[i]->x,
SrcBox.y1 - pDraw->y - screenInfo.screens[i]->y,
width, height, format, planemask, data);
break;
} else if (inOut == rgnOUT)
continue;
REGION_INTERSECT(pScreen, &GrabRegion, &SrcRegion,
&XineramaScreenRegions[i]);
nbox = REGION_NUM_RECTS(&GrabRegion);
if(nbox) {
@ -1215,10 +1206,10 @@ XineramaGetImageData(
}
}
x = pbox->x1 - pDraw->x - panoramiXdataPtr[i].x;
y = pbox->y1 - pDraw->y - panoramiXdataPtr[i].y;
x = pbox->x1 - pDraw->x - screenInfo.screens[i]->x;
y = pbox->y1 - pDraw->y - screenInfo.screens[i]->y;
(*pDraw->pScreen->GetImage)(pDraw, x, y, w, h,
(*pScreen->GetImage)(pDraw, x, y, w, h,
format, planemask, ScratchMem);
/* copy the memory over */

7
Xext/panoramiX.h
View File

@ -46,13 +46,6 @@ Equipment Corporation.
#include "gcstruct.h"
typedef struct _PanoramiXData {
int x;
int y;
int width;
int height;
} PanoramiXData;
typedef struct _PanoramiXInfo {
XID id ;
} PanoramiXInfo;

196
Xext/panoramiXprocs.c
View File

@ -129,14 +129,14 @@ int PanoramiXCreateWindow(ClientPtr client)
orig_visual = stuff->visual;
orig_x = stuff->x;
orig_y = stuff->y;
parentIsRoot = (stuff->parent == WindowTable[0]->drawable.id) ||
(stuff->parent == savedScreenInfo[0].wid);
parentIsRoot = (stuff->parent == screenInfo.screens[0]->root->drawable.id) ||
(stuff->parent == screenInfo.screens[0]->screensaver.wid);
FOR_NSCREENS_BACKWARD(j) {
stuff->wid = newWin->info[j].id;
stuff->parent = parent->info[j].id;
if (parentIsRoot) {
stuff->x = orig_x - panoramiXdataPtr[j].x;
stuff->y = orig_y - panoramiXdataPtr[j].y;
stuff->x = orig_x - screenInfo.screens[j]->x;
stuff->y = orig_y - screenInfo.screens[j]->y;
}
if (backPix)
*((CARD32 *) &stuff[1] + pback_offset) = backPix->info[j].id;
@ -328,14 +328,14 @@ int PanoramiXReparentWindow(ClientPtr client)
x = stuff->x;
y = stuff->y;
parentIsRoot = (stuff->parent == WindowTable[0]->drawable.id) ||
(stuff->parent == savedScreenInfo[0].wid);
parentIsRoot = (stuff->parent == screenInfo.screens[0]->root->drawable.id) ||
(stuff->parent == screenInfo.screens[0]->screensaver.wid);
FOR_NSCREENS_BACKWARD(j) {
stuff->window = win->info[j].id;
stuff->parent = parent->info[j].id;
if(parentIsRoot) {
stuff->x = x - panoramiXdataPtr[j].x;
stuff->y = y - panoramiXdataPtr[j].y;
stuff->x = x - screenInfo.screens[j]->x;
stuff->y = y - screenInfo.screens[j]->y;
}
result = (*SavedProcVector[X_ReparentWindow])(client);
if(result != Success) break;
@ -475,8 +475,8 @@ int PanoramiXConfigureWindow(ClientPtr client)
}
}
if(pWin->parent && ((pWin->parent == WindowTable[0]) ||
(pWin->parent->drawable.id == savedScreenInfo[0].wid)))
if(pWin->parent && ((pWin->parent == screenInfo.screens[0]->root) ||
(pWin->parent->drawable.id == screenInfo.screens[0]->screensaver.wid)))
{
if ((Mask)stuff->mask & CWX) {
x_offset = 0;
@ -495,9 +495,9 @@ int PanoramiXConfigureWindow(ClientPtr client)
if(sib)
*((CARD32 *) &stuff[1] + sib_offset) = sib->info[j].id;
if(x_offset >= 0)
*((CARD32 *) &stuff[1] + x_offset) = x - panoramiXdataPtr[j].x;
*((CARD32 *) &stuff[1] + x_offset) = x - screenInfo.screens[j]->x;
if(y_offset >= 0)
*((CARD32 *) &stuff[1] + y_offset) = y - panoramiXdataPtr[j].y;
*((CARD32 *) &stuff[1] + y_offset) = y - screenInfo.screens[j]->y;
result = (*SavedProcVector[X_ConfigureWindow])(client);
if(result != Success) break;
}
@ -544,7 +544,7 @@ int PanoramiXGetGeometry(ClientPtr client)
rep.type = X_Reply;
rep.length = 0;
rep.sequenceNumber = client->sequence;
rep.root = WindowTable[0]->drawable.id;
rep.root = screenInfo.screens[0]->root->drawable.id;
rep.depth = pDraw->depth;
rep.width = pDraw->width;
rep.height = pDraw->height;
@ -562,11 +562,11 @@ int PanoramiXGetGeometry(ClientPtr client)
WindowPtr pWin = (WindowPtr)pDraw;
rep.x = pWin->origin.x - wBorderWidth (pWin);
rep.y = pWin->origin.y - wBorderWidth (pWin);
if((pWin->parent == WindowTable[0]) ||
(pWin->parent->drawable.id == savedScreenInfo[0].wid))
if((pWin->parent == screenInfo.screens[0]->root) ||
(pWin->parent->drawable.id == screenInfo.screens[0]->screensaver.wid))
{
rep.x += panoramiXdataPtr[0].x;
rep.y += panoramiXdataPtr[0].y;
rep.x += screenInfo.screens[0]->x;
rep.y += screenInfo.screens[0]->y;
}
rep.borderWidth = pWin->borderWidth;
}
@ -596,11 +596,11 @@ int PanoramiXTranslateCoords(ClientPtr client)
rep.sameScreen = xTrue;
rep.child = None;
if((pWin == WindowTable[0]) ||
(pWin->drawable.id == savedScreenInfo[0].wid))
if((pWin == screenInfo.screens[0]->root) ||
(pWin->drawable.id == screenInfo.screens[0]->screensaver.wid))
{
x = stuff->srcX - panoramiXdataPtr[0].x;
y = stuff->srcY - panoramiXdataPtr[0].y;
x = stuff->srcX - screenInfo.screens[0]->x;
y = stuff->srcY - screenInfo.screens[0]->y;
} else {
x = pWin->drawable.x + stuff->srcX;
y = pWin->drawable.y + stuff->srcY;
@ -634,11 +634,11 @@ int PanoramiXTranslateCoords(ClientPtr client)
}
rep.dstX = x - pDst->drawable.x;
rep.dstY = y - pDst->drawable.y;
if((pDst == WindowTable[0]) ||
(pDst->drawable.id == savedScreenInfo[0].wid))
if((pDst == screenInfo.screens[0]->root) ||
(pWin->drawable.id == screenInfo.screens[0]->screensaver.wid))
{
rep.dstX += panoramiXdataPtr[0].x;
rep.dstY += panoramiXdataPtr[0].y;
rep.dstX += screenInfo.screens[0]->x;
rep.dstY += screenInfo.screens[0]->y;
}
WriteReplyToClient(client, sizeof(xTranslateCoordsReply), &rep);
@ -981,8 +981,8 @@ int PanoramiXClearToBackground(ClientPtr client)
FOR_NSCREENS_BACKWARD(j) {
stuff->window = win->info[j].id;
if(isRoot) {
stuff->x = x - panoramiXdataPtr[j].x;
stuff->y = y - panoramiXdataPtr[j].y;
stuff->x = x - screenInfo.screens[j]->x;
stuff->y = y - screenInfo.screens[j]->y;
}
result = (*SavedProcVector[X_ClearArea])(client);
if(result != Success) break;
@ -1084,20 +1084,22 @@ int PanoramiXCopyArea(ClientPtr client)
} else {
DrawablePtr pDst = NULL, pSrc = NULL;
GCPtr pGC = NULL;
RegionPtr pRgn[MAXSCREENS];
RegionRec totalReg;
int rc;
REGION_NULL(unusedScreen, &totalReg);
FOR_NSCREENS_BACKWARD(j) {
RegionPtr pRgn;
stuff->dstDrawable = dst->info[j].id;
stuff->srcDrawable = src->info[j].id;
stuff->gc = gc->info[j].id;
if (srcIsRoot) {
stuff->srcX = srcx - panoramiXdataPtr[j].x;
stuff->srcY = srcy - panoramiXdataPtr[j].y;
stuff->srcX = srcx - screenInfo.screens[j]->x;
stuff->srcY = srcy - screenInfo.screens[j]->y;
}
if (dstIsRoot) {
stuff->dstX = dstx - panoramiXdataPtr[j].x;
stuff->dstY = dsty - panoramiXdataPtr[j].y;
stuff->dstX = dstx - screenInfo.screens[j]->x;
stuff->dstY = dsty - screenInfo.screens[j]->y;
}
VALIDATE_DRAWABLE_AND_GC(stuff->dstDrawable, pDst, DixWriteAccess);
@ -1116,37 +1118,30 @@ int PanoramiXCopyArea(ClientPtr client)
} else
pSrc = pDst;
pRgn[j] = (*pGC->ops->CopyArea)(pSrc, pDst, pGC,
pRgn = (*pGC->ops->CopyArea)(pSrc, pDst, pGC,
stuff->srcX, stuff->srcY,
stuff->width, stuff->height,
stuff->dstX, stuff->dstY);
if(dstShared) {
while(j--) pRgn[j] = NULL;
break;
if(pGC->graphicsExposures && pRgn) {
if(srcIsRoot) {
REGION_TRANSLATE(unusedScreen, pRgn,
screenInfo.screens[j]->x, screenInfo.screens[j]->y);
}
REGION_APPEND(unusedScreen, &totalReg, pRgn);
REGION_DESTROY(unusedScreen, pRgn);
}
if(dstShared)
break;
}
if(pGC->graphicsExposures) {
ScreenPtr pScreen = pDst->pScreen;
RegionRec totalReg;
Bool overlap;
REGION_NULL(pScreen, &totalReg);
FOR_NSCREENS_BACKWARD(j) {
if(pRgn[j]) {
if(srcIsRoot) {
REGION_TRANSLATE(pScreen, pRgn[j],
panoramiXdataPtr[j].x, panoramiXdataPtr[j].y);
}
REGION_APPEND(pScreen, &totalReg, pRgn[j]);
REGION_DESTROY(pScreen, pRgn[j]);
}
}
REGION_VALIDATE(pScreen, &totalReg, &overlap);
REGION_VALIDATE(unusedScreen, &totalReg, &overlap);
(*pScreen->SendGraphicsExpose)(
client, &totalReg, stuff->dstDrawable, X_CopyArea, 0);
REGION_UNINIT(pScreen, &totalReg);
REGION_UNINIT(unusedScreen, &totalReg);
}
}
@ -1163,7 +1158,7 @@ int PanoramiXCopyPlane(ClientPtr client)
Bool srcShared, dstShared;
DrawablePtr psrcDraw, pdstDraw = NULL;
GCPtr pGC = NULL;
RegionPtr pRgn[MAXSCREENS];
RegionRec totalReg;
REQUEST(xCopyPlaneReq);
REQUEST_SIZE_MATCH(xCopyPlaneReq);
@ -1198,17 +1193,19 @@ int PanoramiXCopyPlane(ClientPtr client)
srcx = stuff->srcX; srcy = stuff->srcY;
dstx = stuff->dstX; dsty = stuff->dstY;
REGION_NULL(unusedScreen, &totalReg);
FOR_NSCREENS_BACKWARD(j) {
RegionPtr pRgn;
stuff->dstDrawable = dst->info[j].id;
stuff->srcDrawable = src->info[j].id;
stuff->gc = gc->info[j].id;
if (srcIsRoot) {
stuff->srcX = srcx - panoramiXdataPtr[j].x;
stuff->srcY = srcy - panoramiXdataPtr[j].y;
stuff->srcX = srcx - screenInfo.screens[j]->x;
stuff->srcY = srcy - screenInfo.screens[j]->y;
}
if (dstIsRoot) {
stuff->dstX = dstx - panoramiXdataPtr[j].x;
stuff->dstY = dsty - panoramiXdataPtr[j].y;
stuff->dstX = dstx - screenInfo.screens[j]->x;
stuff->dstY = dsty - screenInfo.screens[j]->y;
}
VALIDATE_DRAWABLE_AND_GC(stuff->dstDrawable, pdstDraw, DixWriteAccess);
@ -1231,33 +1228,26 @@ int PanoramiXCopyPlane(ClientPtr client)
return(BadValue);
}
pRgn[j] = (*pGC->ops->CopyPlane)(psrcDraw, pdstDraw, pGC,
pRgn = (*pGC->ops->CopyPlane)(psrcDraw, pdstDraw, pGC,
stuff->srcX, stuff->srcY,
stuff->width, stuff->height,
stuff->dstX, stuff->dstY, stuff->bitPlane);
if(dstShared) {
while(j--) pRgn[j] = NULL;
break;
if(pGC->graphicsExposures && pRgn) {
REGION_APPEND(unusedScreen, &totalReg, pRgn);
REGION_DESTROY(unusedScreen, pRgn);
}
if(dstShared)
break;
}
if(pGC->graphicsExposures) {
ScreenPtr pScreen = pdstDraw->pScreen;
RegionRec totalReg;
Bool overlap;
REGION_NULL(pScreen, &totalReg);
FOR_NSCREENS_BACKWARD(j) {
if(pRgn[j]) {
REGION_APPEND(pScreen, &totalReg, pRgn[j]);
REGION_DESTROY(pScreen, pRgn[j]);
}
}
REGION_VALIDATE(pScreen, &totalReg, &overlap);
REGION_VALIDATE(unusedScreen, &totalReg, &overlap);
(*pScreen->SendGraphicsExpose)(
client, &totalReg, stuff->dstDrawable, X_CopyPlane, 0);
REGION_UNINIT(pScreen, &totalReg);
REGION_UNINIT(unusedScreen, &totalReg);
}
return Success;
@ -1297,8 +1287,8 @@ int PanoramiXPolyPoint(ClientPtr client)
if(j) memcpy(&stuff[1], origPts, npoint * sizeof(xPoint));
if (isRoot) {
int x_off = panoramiXdataPtr[j].x;
int y_off = panoramiXdataPtr[j].y;
int x_off = screenInfo.screens[j]->x;
int y_off = screenInfo.screens[j]->y;
if(x_off || y_off) {
xPoint *pnts = (xPoint*)&stuff[1];
@ -1357,8 +1347,8 @@ int PanoramiXPolyLine(ClientPtr client)
if(j) memcpy(&stuff[1], origPts, npoint * sizeof(xPoint));
if (isRoot) {
int x_off = panoramiXdataPtr[j].x;
int y_off = panoramiXdataPtr[j].y;
int x_off = screenInfo.screens[j]->x;
int y_off = screenInfo.screens[j]->y;
if(x_off || y_off) {
xPoint *pnts = (xPoint*)&stuff[1];
@ -1420,8 +1410,8 @@ int PanoramiXPolySegment(ClientPtr client)
if(j) memcpy(&stuff[1], origSegs, nsegs * sizeof(xSegment));
if (isRoot) {
int x_off = panoramiXdataPtr[j].x;
int y_off = panoramiXdataPtr[j].y;
int x_off = screenInfo.screens[j]->x;
int y_off = screenInfo.screens[j]->y;
if(x_off || y_off) {
xSegment *segs = (xSegment*)&stuff[1];
@ -1483,8 +1473,8 @@ int PanoramiXPolyRectangle(ClientPtr client)
if(j) memcpy(&stuff[1], origRecs, nrects * sizeof(xRectangle));
if (isRoot) {
int x_off = panoramiXdataPtr[j].x;
int y_off = panoramiXdataPtr[j].y;
int x_off = screenInfo.screens[j]->x;
int y_off = screenInfo.screens[j]->y;
if(x_off || y_off) {
@ -1545,8 +1535,8 @@ int PanoramiXPolyArc(ClientPtr client)
if(j) memcpy(&stuff[1], origArcs, narcs * sizeof(xArc));
if (isRoot) {
int x_off = panoramiXdataPtr[j].x;
int y_off = panoramiXdataPtr[j].y;
int x_off = screenInfo.screens[j]->x;
int y_off = screenInfo.screens[j]->y;
if(x_off || y_off) {
xArc *arcs = (xArc *) &stuff[1];
@ -1603,8 +1593,8 @@ int PanoramiXFillPoly(ClientPtr client)
if(j) memcpy(&stuff[1], locPts, count * sizeof(DDXPointRec));
if (isRoot) {
int x_off = panoramiXdataPtr[j].x;
int y_off = panoramiXdataPtr[j].y;
int x_off = screenInfo.screens[j]->x;
int y_off = screenInfo.screens[j]->y;
if(x_off || y_off) {
DDXPointPtr pnts = (DDXPointPtr)&stuff[1];
@ -1666,8 +1656,8 @@ int PanoramiXPolyFillRectangle(ClientPtr client)
if(j) memcpy(&stuff[1], origRects, things * sizeof(xRectangle));
if (isRoot) {
int x_off = panoramiXdataPtr[j].x;
int y_off = panoramiXdataPtr[j].y;
int x_off = screenInfo.screens[j]->x;
int y_off = screenInfo.screens[j]->y;
if(x_off || y_off) {
xRectangle *rects = (xRectangle *) &stuff[1];
@ -1727,8 +1717,8 @@ int PanoramiXPolyFillArc(ClientPtr client)
if(j) memcpy(&stuff[1], origArcs, narcs * sizeof(xArc));
if (isRoot) {
int x_off = panoramiXdataPtr[j].x;
int y_off = panoramiXdataPtr[j].y;
int x_off = screenInfo.screens[j]->x;
int y_off = screenInfo.screens[j]->y;
if(x_off || y_off) {
xArc *arcs = (xArc *) &stuff[1];
@ -1780,8 +1770,8 @@ int PanoramiXPutImage(ClientPtr client)
orig_y = stuff->dstY;
FOR_NSCREENS_BACKWARD(j){
if (isRoot) {
stuff->dstX = orig_x - panoramiXdataPtr[j].x;
stuff->dstY = orig_y - panoramiXdataPtr[j].y;
stuff->dstX = orig_x - screenInfo.screens[j]->x;
stuff->dstY = orig_y - screenInfo.screens[j]->y;
}
stuff->drawable = draw->info[j].id;
stuff->gc = gc->info[j].id;
@ -1846,10 +1836,10 @@ int PanoramiXGetImage(ClientPtr client)
return(BadMatch);
} else {
if( /* check for being onscreen */
panoramiXdataPtr[0].x + pDraw->x + x < 0 ||
panoramiXdataPtr[0].x + pDraw->x + x + w > PanoramiXPixWidth ||
panoramiXdataPtr[0].y + pDraw->y + y < 0 ||
panoramiXdataPtr[0].y + pDraw->y + y + h > PanoramiXPixHeight ||
screenInfo.screens[0]->x + pDraw->x + x < 0 ||
screenInfo.screens[0]->x + pDraw->x + x + w > PanoramiXPixWidth ||
screenInfo.screens[0]->y + pDraw->y + y < 0 ||
screenInfo.screens[0]->y + pDraw->y + y + h > PanoramiXPixHeight ||
/* check for being inside of border */
x < - wBorderWidth((WindowPtr)pDraw) ||
x + w > wBorderWidth((WindowPtr)pDraw) + (int)pDraw->width ||
@ -1983,8 +1973,8 @@ PanoramiXPolyText8(ClientPtr client)
stuff->drawable = draw->info[j].id;
stuff->gc = gc->info[j].id;
if (isRoot) {
stuff->x = orig_x - panoramiXdataPtr[j].x;
stuff->y = orig_y - panoramiXdataPtr[j].y;
stuff->x = orig_x - screenInfo.screens[j]->x;
stuff->y = orig_y - screenInfo.screens[j]->y;
}
result = (*SavedProcVector[X_PolyText8])(client);
if(result != Success) break;
@ -2024,8 +2014,8 @@ PanoramiXPolyText16(ClientPtr client)
stuff->drawable = draw->info[j].id;
stuff->gc = gc->info[j].id;
if (isRoot) {
stuff->x = orig_x - panoramiXdataPtr[j].x;
stuff->y = orig_y - panoramiXdataPtr[j].y;
stuff->x = orig_x - screenInfo.screens[j]->x;
stuff->y = orig_y - screenInfo.screens[j]->y;
}
result = (*SavedProcVector[X_PolyText16])(client);
if(result != Success) break;
@ -2065,8 +2055,8 @@ int PanoramiXImageText8(ClientPtr client)
stuff->drawable = draw->info[j].id;
stuff->gc = gc->info[j].id;
if (isRoot) {
stuff->x = orig_x - panoramiXdataPtr[j].x;
stuff->y = orig_y - panoramiXdataPtr[j].y;
stuff->x = orig_x - screenInfo.screens[j]->x;
stuff->y = orig_y - screenInfo.screens[j]->y;
}
result = (*SavedProcVector[X_ImageText8])(client);
if(result != Success) break;
@ -2106,8 +2096,8 @@ int PanoramiXImageText16(ClientPtr client)
stuff->drawable = draw->info[j].id;
stuff->gc = gc->info[j].id;
if (isRoot) {
stuff->x = orig_x - panoramiXdataPtr[j].x;
stuff->y = orig_y - panoramiXdataPtr[j].y;
stuff->x = orig_x - screenInfo.screens[j]->x;
stuff->y = orig_y - screenInfo.screens[j]->y;
}
result = (*SavedProcVector[X_ImageText16])(client);
if(result != Success) break;

3
Xext/panoramiXsrv.h
View File

@ -9,7 +9,6 @@
#include "panoramiX.h"
extern _X_EXPORT int PanoramiXNumScreens;
extern _X_EXPORT PanoramiXData *panoramiXdataPtr;
extern _X_EXPORT int PanoramiXPixWidth;
extern _X_EXPORT int PanoramiXPixHeight;
@ -22,8 +21,6 @@ extern _X_EXPORT int XineramaDeleteResource(pointer, XID);
extern _X_EXPORT void XineramaReinitData(ScreenPtr);
extern _X_EXPORT RegionRec XineramaScreenRegions[MAXSCREENS];
extern _X_EXPORT unsigned long XRC_DRAWABLE;
extern _X_EXPORT unsigned long XRT_WINDOW;
extern _X_EXPORT unsigned long XRT_PIXMAP;

18
Xext/saver.c
View File

@ -285,7 +285,7 @@ CheckScreenPrivate (ScreenPtr pScreen)
{
free(pPriv);
SetScreenPrivate (pScreen, NULL);
savedScreenInfo[pScreen->myNum].ExternalScreenSaver = NULL;
pScreen->screensaver.ExternalScreenSaver = NULL;
}
}
@ -304,7 +304,7 @@ MakeScreenPrivate (ScreenPtr pScreen)
pPriv->hasWindow = FALSE;
pPriv->installedMap = None;
SetScreenPrivate (pScreen, pPriv);
savedScreenInfo[pScreen->myNum].ExternalScreenSaver = ScreenSaverHandle;
pScreen->screensaver.ExternalScreenSaver = ScreenSaverHandle;
return pPriv;
}
@ -503,8 +503,8 @@ SendScreenSaverNotify (ScreenPtr pScreen, int state, Bool forced)
ev.type = ScreenSaverNotify + ScreenSaverEventBase;
ev.state = state;
ev.timestamp = currentTime.milliseconds;
ev.root = WindowTable[pScreen->myNum]->drawable.id;
ev.window = savedScreenInfo[pScreen->myNum].wid;
ev.root = pScreen->root->drawable.id;
ev.window = pScreen->screensaver.wid;
ev.kind = kind;
ev.forced = forced;
WriteEventsToClient (pEv->client, 1, (xEvent *) &ev);
@ -559,7 +559,7 @@ CreateSaverWindow (ScreenPtr pScreen)
Colormap wantMap;
ColormapPtr pCmap;
pSaver = &savedScreenInfo[pScreen->myNum];
pSaver = &pScreen->screensaver;
if (pSaver->pWindow)
{
pSaver->pWindow = NullWindow;
@ -580,7 +580,7 @@ CreateSaverWindow (ScreenPtr pScreen)
if (GrabInProgress && GrabInProgress != pAttr->client->index)
return FALSE;
pWin = CreateWindow (pSaver->wid, WindowTable[pScreen->myNum],
pWin = CreateWindow (pSaver->wid, pScreen->root,
pAttr->x, pAttr->y, pAttr->width, pAttr->height,
pAttr->borderWidth, pAttr->class,
pAttr->mask, (XID *)pAttr->values,
@ -672,7 +672,7 @@ DestroySaverWindow (ScreenPtr pScreen)
if (!pPriv || !pPriv->hasWindow)
return FALSE;
pSaver = &savedScreenInfo[pScreen->myNum];
pSaver = &pScreen->screensaver;
if (pSaver->pWindow)
{
pSaver->pWindow = NullWindow;
@ -756,7 +756,7 @@ ProcScreenSaverQueryInfo (ClientPtr client)
if (rc != Success)
return rc;
pSaver = &savedScreenInfo[pDraw->pScreen->myNum];
pSaver = &pDraw->pScreen->screensaver;
pPriv = GetScreenPrivate (pDraw->pScreen);
UpdateCurrentTime ();
@ -866,7 +866,7 @@ ScreenSaverSetAttributes (ClientPtr client)
if (ret != Success)
return ret;
pScreen = pDraw->pScreen;
pParent = WindowTable[pScreen->myNum];
pParent = pScreen->root;
ret = XaceHook(XACE_SCREENSAVER_ACCESS, client, pScreen, DixSetAttrAccess);
if (ret != Success)

12
Xext/shm.c
View File

@ -598,8 +598,8 @@ ProcPanoramiXShmPutImage(ClientPtr client)
stuff->drawable = draw->info[j].id;
stuff->gc = gc->info[j].id;
if (isRoot) {
stuff->dstX = orig_x - panoramiXdataPtr[j].x;
stuff->dstY = orig_y - panoramiXdataPtr[j].y;
stuff->dstX = orig_x - screenInfo.screens[j]->x;
stuff->dstY = orig_y - screenInfo.screens[j]->y;
}
result = ProcShmPutImage(client);
if(result != Success) break;
@ -660,10 +660,10 @@ ProcPanoramiXShmGetImage(ClientPtr client)
return(BadMatch);
} else {
if( /* check for being onscreen */
panoramiXdataPtr[0].x + pDraw->x + x < 0 ||
panoramiXdataPtr[0].x + pDraw->x + x + w > PanoramiXPixWidth ||
panoramiXdataPtr[0].y + pDraw->y + y < 0 ||
panoramiXdataPtr[0].y + pDraw->y + y + h > PanoramiXPixHeight ||
screenInfo.screens[0]->x + pDraw->x + x < 0 ||
screenInfo.screens[0]->x + pDraw->x + x + w > PanoramiXPixWidth ||
screenInfo.screens[0]->y + pDraw->y + y < 0 ||
screenInfo.screens[0]->y + pDraw->y + y + h > PanoramiXPixHeight ||
/* check for being inside of border */
x < - wBorderWidth((WindowPtr)pDraw) ||
x + w > wBorderWidth((WindowPtr)pDraw) + (int)pDraw->width ||

16
Xext/xvdisp.c
View File

@ -1690,8 +1690,8 @@ XineramaXvShmPutImage(ClientPtr client)
stuff->drw_x = x;
stuff->drw_y = y;
if(isRoot) {
stuff->drw_x -= panoramiXdataPtr[i].x;
stuff->drw_y -= panoramiXdataPtr[i].y;
stuff->drw_x -= screenInfo.screens[i]->x;
stuff->drw_y -= screenInfo.screens[i]->y;
}
stuff->send_event = (send_event && !i) ? 1 : 0;
@ -1742,8 +1742,8 @@ XineramaXvPutImage(ClientPtr client)
stuff->drw_x = x;
stuff->drw_y = y;
if(isRoot) {
stuff->drw_x -= panoramiXdataPtr[i].x;
stuff->drw_y -= panoramiXdataPtr[i].y;
stuff->drw_x -= screenInfo.screens[i]->x;
stuff->drw_y -= screenInfo.screens[i]->y;
}
result = ProcXvPutImage(client);
@ -1790,8 +1790,8 @@ XineramaXvPutVideo(ClientPtr client)
stuff->drw_x = x;
stuff->drw_y = y;
if(isRoot) {
stuff->drw_x -= panoramiXdataPtr[i].x;
stuff->drw_y -= panoramiXdataPtr[i].y;
stuff->drw_x -= screenInfo.screens[i]->x;
stuff->drw_y -= screenInfo.screens[i]->y;
}
result = ProcXvPutVideo(client);
@ -1838,8 +1838,8 @@ XineramaXvPutStill(ClientPtr client)
stuff->drw_x = x;
stuff->drw_y = y;
if(isRoot) {
stuff->drw_x -= panoramiXdataPtr[i].x;
stuff->drw_y -= panoramiXdataPtr[i].y;
stuff->drw_x -= screenInfo.screens[i]->x;
stuff->drw_y -= screenInfo.screens[i]->y;
}
result = ProcXvPutStill(client);

2
Xi/closedev.c
View File

@ -156,7 +156,7 @@ ProcXCloseDevice(ClientPtr client)
* Delete passive grabs from all windows for this device. */
for (i = 0; i < screenInfo.numScreens; i++) {
pWin = WindowTable[i];
pWin = screenInfo.screens[i]->root;
DeleteDeviceEvents(d, pWin, client);
p1 = pWin->firstChild;
DeleteEventsFromChildren(d, p1, client);

6
Xi/exevents.c
View File

@ -926,7 +926,7 @@ ProcessRawEvent(RawDeviceEvent *ev, DeviceIntPtr device)
}
for (i = 0; i < screenInfo.numScreens; i++)
DeliverEventsToWindow(device, WindowTable[i], xi, 1,
DeliverEventsToWindow(device, screenInfo.screens[i]->root, xi, 1,
GetEventFilter(device, xi), NULL);
free(xi);
}
@ -1042,7 +1042,7 @@ ProcessOtherEvent(InternalEvent *ev, DeviceIntPtr device)
/* see comment in EnqueueEvents regarding the next three lines */
if (ev->any.type == ET_Motion)
ev->device_event.root = WindowTable[pSprite->hotPhys.pScreen->myNum]->drawable.id;
ev->device_event.root = pSprite->hotPhys.pScreen->root->drawable.id;
eventinfo.device = device;
eventinfo.event = ev;
@ -2120,7 +2120,7 @@ SendEventToAllWindows(DeviceIntPtr dev, Mask mask, xEvent * ev, int count)
WindowPtr pWin, p1;
for (i = 0; i < screenInfo.numScreens; i++) {
pWin = WindowTable[i];
pWin = screenInfo.screens[i]->root;
if (!pWin)
continue;
DeliverEventsToWindow(dev, pWin, ev, count, mask, NullGrab);

2
Xi/xichangecursor.c
View File

@ -93,7 +93,7 @@ int ProcXIChangeCursor(ClientPtr client)
if (stuff->cursor == None)
{
if (pWin == WindowTable[pWin->drawable.pScreen->myNum])
if (pWin == pWin->drawable.pScreen->root)
pCursor = rootCursor;
else
pCursor = (CursorPtr)None;

9
Xi/xiquerypointer.c
View File

@ -43,6 +43,7 @@
#include "exevents.h"
#include "exglobals.h"
#include "eventconvert.h"
#include "scrnintstr.h"
#include "xkbsrv.h"
#ifdef PANORAMIX
@ -181,12 +182,12 @@ ProcXIQueryPointer(ClientPtr client)
#ifdef PANORAMIX
if(!noPanoramiXExtension) {
rep.root_x += FP1616(panoramiXdataPtr[0].x, 0);
rep.root_y += FP1616(panoramiXdataPtr[0].y, 0);
rep.root_x += FP1616(screenInfo.screens[0]->x, 0);
rep.root_y += FP1616(screenInfo.screens[0]->y, 0);
if (stuff->win == rep.root)
{
rep.win_x += FP1616(panoramiXdataPtr[0].x, 0);
rep.win_y += FP1616(panoramiXdataPtr[0].y, 0);
rep.win_x += FP1616(screenInfo.screens[0]->x, 0);
rep.win_y += FP1616(screenInfo.screens[0]->y, 0);
}
}
#endif

2
composite/compinit.c
View File

@ -141,7 +141,7 @@ compScreenUpdate (ScreenPtr pScreen)
compCheckTree (pScreen);
if (cs->damaged)
{
compWindowUpdate (WindowTable[pScreen->myNum]);
compWindowUpdate (pScreen->root);
cs->damaged = FALSE;
}
}

2
composite/compoverlay.c
View File

@ -124,7 +124,7 @@ Bool
compCreateOverlayWindow (ScreenPtr pScreen)
{
CompScreenPtr cs = GetCompScreen(pScreen);
WindowPtr pRoot = WindowTable[pScreen->myNum];
WindowPtr pRoot = pScreen->root;
WindowPtr pWin;
XID attrs[] = { None, TRUE }; /* backPixmap, overrideRedirect */
int result;

2
composite/compwindow.c
View File

@ -800,7 +800,7 @@ CompositeRealChildHead (WindowPtr pWin)
if (!pWin->parent &&
(screenIsSaved == SCREEN_SAVER_ON) &&
(HasSaverWindow (pWin->drawable.pScreen->myNum))) {
(HasSaverWindow (pWin->drawable.pScreen))) {
/* First child is the screen saver; see if next child is the overlay */
pChildBefore = pWin->firstChild;

6
dix/devices.c
View File

@ -360,9 +360,9 @@ EnableDevice(DeviceIntPtr dev, BOOL sendevent)
/* Sprites appear on first root window, so we can hardcode it */
if (dev->spriteInfo->spriteOwner)
{
InitializeSprite(dev, WindowTable[0]);
InitializeSprite(dev, screenInfo.screens[0]->root);
/* mode doesn't matter */
EnterWindow(dev, WindowTable[0], NotifyAncestor);
EnterWindow(dev, screenInfo.screens[0]->root, NotifyAncestor);
}
else if ((other = NextFreePointerDevice()) == NULL)
{
@ -2435,7 +2435,7 @@ AttachDevice(ClientPtr client, DeviceIntPtr dev, DeviceIntPtr master)
if (dev->spriteInfo->sprite)
currentRoot = dev->spriteInfo->sprite->spriteTrace[0];
else /* new device auto-set to floating */
currentRoot = WindowTable[0];
currentRoot = screenInfo.screens[0]->root;
/* we need to init a fake sprite */
screen = currentRoot->drawable.pScreen;

13
dix/dispatch.c
View File

@ -562,7 +562,7 @@ CreateConnectionBlock(void)
VisualPtr pVisual;
pScreen = screenInfo.screens[i];
root.windowId = WindowTable[i]->drawable.id;
root.windowId = pScreen->root->drawable.id;
root.defaultColormap = pScreen->defColormap;
root.whitePixel = pScreen->whitePixel;
root.blackPixel = pScreen->blackPixel;
@ -912,7 +912,7 @@ GetGeometry(ClientPtr client, xGetGeometryReply *rep)
rep->type = X_Reply;
rep->length = 0;
rep->sequenceNumber = client->sequence;
rep->root = WindowTable[pDraw->pScreen->myNum]->drawable.id;
rep->root = pDraw->pScreen->root->drawable.id;
rep->depth = pDraw->depth;
rep->width = pDraw->width;
rep->height = pDraw->height;
@ -972,7 +972,7 @@ ProcQueryTree(ClientPtr client)
return rc;
memset(&reply, 0, sizeof(xQueryTreeReply));
reply.type = X_Reply;
reply.root = WindowTable[pWin->drawable.pScreen->myNum]->drawable.id;
reply.root = pWin->drawable.pScreen->root->drawable.id;
reply.sequenceNumber = client->sequence;
if (pWin->parent)
reply.parent = pWin->parent->drawable.id;
@ -2055,7 +2055,7 @@ DoGetImage(ClientPtr client, int format, Drawable drawable,
}
else
{
pBoundingDraw = (DrawablePtr)WindowTable[pDraw->pScreen->myNum];
pBoundingDraw = (DrawablePtr)pDraw->pScreen->root;
}
xgi.visual = wVisual (pWin);
@ -3666,9 +3666,9 @@ SendConnSetup(ClientPtr client, char *reason)
{
unsigned int j;
xDepth *pDepth;
WindowPtr pRoot = screenInfo.screens[i]->root;
root->currentInputMask = WindowTable[i]->eventMask |
wOtherEventMasks (WindowTable[i]);
root->currentInputMask = pRoot->eventMask | wOtherEventMasks(pRoot);
pDepth = (xDepth *)(root + 1);
for (j = 0; j < root->nDepths; j++)
{
@ -3916,7 +3916,6 @@ AddScreen(
any of the strings pointed to by argv. They may be passed to
multiple screens.
*/
WindowTable[i] = NullWindow;
screenInfo.screens[i] = pScreen;
screenInfo.numScreens++;
if (!(*pfnInit)(i, pScreen, argc, argv))

12
dix/enterleave.c
View File

@ -1077,7 +1077,7 @@ CoreFocusPointerRootNoneSwitch(DeviceIntPtr dev,
for (i = 0; i < nscreens; i++)
{
root = WindowTable[i];
root = screenInfo.screens[i]->root;
if (!HasOtherPointer(root, GetPairedDevice(dev)) && !FirstFocusChild(root))
{
/* If pointer was on PointerRootWin and changes to NoneWin, and
@ -1138,7 +1138,7 @@ CoreFocusToPointerRootOrNone(DeviceIntPtr dev,
for (i = 0; i < nscreens; i++)
{
root = WindowTable[i];
root = screenInfo.screens[i]->root;
if (!HasFocus(root) && !FirstFocusChild(root))
{
CoreFocusEvent(dev, FocusIn, mode, B ? NotifyPointerRoot : NotifyDetailNone, root);
@ -1169,7 +1169,7 @@ CoreFocusFromPointerRootOrNone(DeviceIntPtr dev,
for (i = 0; i < nscreens; i++)
{
root = WindowTable[i];
root = screenInfo.screens[i]->root;
if (!HasFocus(root) && !FirstFocusChild(root))
{
/* If pointer was on PointerRootWin and changes to NoneWin, and
@ -1279,7 +1279,7 @@ DeviceFocusEvents(DeviceIntPtr dev,
NotifyPointer);
/* Notify all the roots */
for (i = 0; i < nscreens; i++)
DeviceFocusEvent(dev, XI_FocusOut, mode, out, WindowTable[i]);
DeviceFocusEvent(dev, XI_FocusOut, mode, out, screenInfo.screens[i]->root);
}
else
{
@ -1293,7 +1293,7 @@ DeviceFocusEvents(DeviceIntPtr dev,
}
/* Notify all the roots */
for (i = 0; i < nscreens; i++)
DeviceFocusEvent(dev, XI_FocusIn, mode, in, WindowTable[i]);
DeviceFocusEvent(dev, XI_FocusIn, mode, in, screenInfo.screens[i]->root);
if (to == PointerRootWin)
DeviceFocusInEvents(dev, RootWindow(dev), sprite->win, mode, NotifyPointer);
}
@ -1305,7 +1305,7 @@ DeviceFocusEvents(DeviceIntPtr dev,
DeviceFocusOutEvents(dev, sprite->win, RootWindow(dev), mode,
NotifyPointer);
for (i = 0; i < nscreens; i++)
DeviceFocusEvent(dev, XI_FocusOut, mode, out, WindowTable[i]);
DeviceFocusEvent(dev, XI_FocusOut, mode, out, screenInfo.screens[i]->root);
if (to->parent != NullWindow)
DeviceFocusInEvents(dev, RootWindow(dev), to, mode, NotifyNonlinearVirtual);
DeviceFocusEvent(dev, XI_FocusIn, mode, NotifyNonlinear, to);

179
dix/events.c
View File

@ -485,6 +485,13 @@ SyntheticMotion(DeviceIntPtr dev, int x, int y) {
#ifdef PANORAMIX
static void PostNewCursor(DeviceIntPtr pDev);
static Bool
pointOnScreen(ScreenPtr pScreen, int x, int y)
{
return x >= pScreen->x && x < pScreen->x + pScreen->width &&
y >= pScreen->y && y < pScreen->y + pScreen->height;
}
static Bool
XineramaSetCursorPosition(
DeviceIntPtr pDev,
@ -493,7 +500,6 @@ XineramaSetCursorPosition(
Bool generateEvent
){
ScreenPtr pScreen;
BoxRec box;
int i;
SpritePtr pSprite = pDev->spriteInfo->sprite;
@ -502,17 +508,16 @@ XineramaSetCursorPosition(
that screen are. */
pScreen = pSprite->screen;
x += panoramiXdataPtr[0].x;
y += panoramiXdataPtr[0].y;
x += screenInfo.screens[0]->x;
y += screenInfo.screens[0]->y;
if(!POINT_IN_REGION(pScreen, &XineramaScreenRegions[pScreen->myNum],
x, y, &box))
if(!pointOnScreen(pScreen, x, y))
{
FOR_NSCREENS(i)
{
if(i == pScreen->myNum)
continue;
if(POINT_IN_REGION(pScreen, &XineramaScreenRegions[i], x, y, &box))
if(pointOnScreen(screenInfo.screens[i], x, y))
{
pScreen = screenInfo.screens[i];
break;
@ -521,10 +526,10 @@ XineramaSetCursorPosition(
}
pSprite->screen = pScreen;
pSprite->hotPhys.x = x - panoramiXdataPtr[0].x;
pSprite->hotPhys.y = y - panoramiXdataPtr[0].y;
x -= panoramiXdataPtr[pScreen->myNum].x;
y -= panoramiXdataPtr[pScreen->myNum].y;
pSprite->hotPhys.x = x - screenInfo.screens[0]->x;
pSprite->hotPhys.y = y - screenInfo.screens[0]->y;
x -= pScreen->x;
y -= pScreen->y;
return (*pScreen->SetCursorPosition)(pDev, pScreen, x, y, generateEvent);
}
@ -542,10 +547,10 @@ XineramaConstrainCursor(DeviceIntPtr pDev)
/* Translate the constraining box to the screen
the sprite is actually on */
newBox.x1 += panoramiXdataPtr[0].x - panoramiXdataPtr[pScreen->myNum].x;
newBox.x2 += panoramiXdataPtr[0].x - panoramiXdataPtr[pScreen->myNum].x;
newBox.y1 += panoramiXdataPtr[0].y - panoramiXdataPtr[pScreen->myNum].y;
newBox.y2 += panoramiXdataPtr[0].y - panoramiXdataPtr[pScreen->myNum].y;
newBox.x1 += screenInfo.screens[0]->x - pScreen->x;
newBox.x2 += screenInfo.screens[0]->x - pScreen->x;
newBox.y1 += screenInfo.screens[0]->y - pScreen->y;
newBox.y2 += screenInfo.screens[0]->y - pScreen->y;
(* pScreen->ConstrainCursor)(pDev, pScreen, &newBox);
}
@ -556,9 +561,10 @@ XineramaSetWindowPntrs(DeviceIntPtr pDev, WindowPtr pWin)
{
SpritePtr pSprite = pDev->spriteInfo->sprite;
if(pWin == WindowTable[0]) {
memcpy(pSprite->windows, WindowTable,
PanoramiXNumScreens*sizeof(WindowPtr));
if(pWin == screenInfo.screens[0]->root) {
int i;
for (i = 0; i < PanoramiXNumScreens; i++)
pSprite->windows[i] = screenInfo.screens[i]->root;
} else {
PanoramiXRes *win;
int rc, i;
@ -594,12 +600,12 @@ XineramaConfineCursorToWindow(DeviceIntPtr pDev,
REGION_COPY(pSprite->screen, &pSprite->Reg1,
&pSprite->windows[i]->borderSize);
off_x = panoramiXdataPtr[i].x;
off_y = panoramiXdataPtr[i].y;
off_x = screenInfo.screens[i]->x;
off_y = screenInfo.screens[i]->y;
while(i--) {
x = off_x - panoramiXdataPtr[i].x;
y = off_y - panoramiXdataPtr[i].y;
x = off_x - screenInfo.screens[i]->x;
y = off_y - screenInfo.screens[i]->y;
if(x || y)
REGION_TRANSLATE(pSprite->screen, &pSprite->Reg1, x, y);
@ -607,8 +613,8 @@ XineramaConfineCursorToWindow(DeviceIntPtr pDev,
REGION_UNION(pSprite->screen, &pSprite->Reg1, &pSprite->Reg1,
&pSprite->windows[i]->borderSize);
off_x = panoramiXdataPtr[i].x;
off_y = panoramiXdataPtr[i].y;
off_x = screenInfo.screens[i]->x;
off_y = screenInfo.screens[i]->y;
}
pSprite->hotLimits = *REGION_EXTENTS(pSprite->screen, &pSprite->Reg1);
@ -619,7 +625,7 @@ XineramaConfineCursorToWindow(DeviceIntPtr pDev,
pSprite->hotShape = NullRegion;
pSprite->confined = FALSE;
pSprite->confineWin = (pWin == WindowTable[0]) ? NullWindow : pWin;
pSprite->confineWin = (pWin == screenInfo.screens[0]->root) ? NullWindow : pWin;
CheckPhysLimits(pDev, pSprite->current, generateEvents, FALSE, NULL);
}
@ -813,12 +819,12 @@ CheckVirtualMotion(
REGION_COPY(pSprite->screen, &pSprite->Reg2,
&pSprite->windows[i]->borderSize);
off_x = panoramiXdataPtr[i].x;
off_y = panoramiXdataPtr[i].y;
off_x = screenInfo.screens[i]->x;
off_y = screenInfo.screens[i]->y;
while(i--) {
x = off_x - panoramiXdataPtr[i].x;
y = off_y - panoramiXdataPtr[i].y;
x = off_x - screenInfo.screens[i]->x;
y = off_y - screenInfo.screens[i]->y;
if(x || y)
REGION_TRANSLATE(pSprite->screen, &pSprite->Reg2, x, y);
@ -826,8 +832,8 @@ CheckVirtualMotion(
REGION_UNION(pSprite->screen, &pSprite->Reg2, &pSprite->Reg2,
&pSprite->windows[i]->borderSize);
off_x = panoramiXdataPtr[i].x;
off_y = panoramiXdataPtr[i].y;
off_x = screenInfo.screens[i]->x;
off_y = screenInfo.screens[i]->y;
}
} else
#endif
@ -875,7 +881,7 @@ CheckVirtualMotion(
#ifdef PANORAMIX
if (noPanoramiXExtension) /* No typo. Only set the root win if disabled */
#endif
RootWindow(pDev) = WindowTable[pSprite->hot.pScreen->myNum];
RootWindow(pDev) = pSprite->hot.pScreen->root;
}
static void
@ -1123,7 +1129,7 @@ EnqueueEvent(InternalEvent *ev, DeviceIntPtr device)
* updated yet.
*/
if (ev->any.type == ET_Motion)
ev->device_event.root = WindowTable[pSprite->hotPhys.pScreen->myNum]->drawable.id;
ev->device_event.root = pSprite->hotPhys.pScreen->root->drawable.id;
eventinfo.event = ev;
eventinfo.device = device;
@ -1134,10 +1140,8 @@ EnqueueEvent(InternalEvent *ev, DeviceIntPtr device)
{
#ifdef PANORAMIX
if(!noPanoramiXExtension) {
event->root_x += panoramiXdataPtr[pSprite->screen->myNum].x -
panoramiXdataPtr[0].x;
event->root_y += panoramiXdataPtr[pSprite->screen->myNum].y -
panoramiXdataPtr[0].y;
event->root_x += pSprite->screen->x - screenInfo.screens[0]->x;
event->root_y += pSprite->screen->y - screenInfo.screens[0]->y;
}
#endif
pSprite->hotPhys.x = event->root_x;
@ -1217,10 +1221,10 @@ PlayReleasedEvents(void)
case ET_KeyRelease:
case ET_ProximityIn:
case ET_ProximityOut:
ev->root_x += panoramiXdataPtr[0].x -
panoramiXdataPtr[pDev->spriteInfo->sprite->screen->myNum].x;
ev->root_y += panoramiXdataPtr[0].y -
panoramiXdataPtr[pDev->spriteInfo->sprite->screen->myNum].y;
ev->root_x += screenInfo.screens[0]->x -
pDev->spriteInfo->sprite->screen->x;
ev->root_y += screenInfo.screens[0]->y -
pDev->spriteInfo->sprite->screen->y;
break;
default:
break;
@ -1339,7 +1343,7 @@ playmore:
}
else
ConfineCursorToWindow(dev,
WindowTable[dev->spriteInfo->sprite->hotPhys.pScreen->myNum],
dev->spriteInfo->sprite->hotPhys.pScreen->root,
TRUE, FALSE);
PostNewCursor(dev);
}
@ -1369,7 +1373,7 @@ ScreenRestructured (ScreenPtr pScreen)
}
else
ConfineCursorToWindow(pDev,
WindowTable[pDev->spriteInfo->sprite->hotPhys.pScreen->myNum],
pDev->spriteInfo->sprite->hotPhys.pScreen->root,
TRUE, FALSE);
}
}
@ -2560,8 +2564,8 @@ PointInBorderSize(WindowPtr pWin, int x, int y)
for(i = 1; i < PanoramiXNumScreens; i++) {
if(POINT_IN_REGION(pSprite->screen,
&pSprite->windows[i]->borderSize,
x + panoramiXdataPtr[0].x - panoramiXdataPtr[i].x,
y + panoramiXdataPtr[0].y - panoramiXdataPtr[i].y,
x + screenInfo.screens[0]->x - screenInfo.screens[i]->x,
y + screenInfo.screens[0]->y - screenInfo.screens[i]->y,
&box))
return TRUE;
}
@ -2756,17 +2760,15 @@ CheckMotion(DeviceEvent *ev, DeviceIntPtr pDev)
/* Motion events entering DIX get translated to Screen 0
coordinates. Replayed events have already been
translated since they've entered DIX before */
ev->root_x += panoramiXdataPtr[pSprite->screen->myNum].x -
panoramiXdataPtr[0].x;
ev->root_y += panoramiXdataPtr[pSprite->screen->myNum].y -
panoramiXdataPtr[0].y;
ev->root_x += pSprite->screen->x - screenInfo.screens[0]->x;
ev->root_y += pSprite->screen->y - screenInfo.screens[0]->y;
} else
#endif
{
if (pSprite->hot.pScreen != pSprite->hotPhys.pScreen)
{
pSprite->hot.pScreen = pSprite->hotPhys.pScreen;
RootWindow(pDev) = WindowTable[pSprite->hot.pScreen->myNum];
RootWindow(pDev) = pSprite->hot.pScreen->root;
}
}
@ -2849,7 +2851,7 @@ WindowsRestructured(void)
#ifdef PANORAMIX
/* This was added to support reconfiguration under Xdmx. The problem is
* that if the 0th screen (i.e., WindowTable[0]) is moved to an origin
* that if the 0th screen (i.e., screenInfo.screens[0]) is moved to an origin
* other than 0,0, the information in the private sprite structure must
* be updated accordingly, or XYToWindow (and other routines) will not
* compute correctly. */
@ -2892,7 +2894,7 @@ void ReinitializeRootWindow(WindowPtr win, int xoff, int yoff)
} else
ConfineCursorToWindow(
pDev,
WindowTable[pSprite->hotPhys.pScreen->myNum],
pSprite->hotPhys.pScreen->root,
TRUE, FALSE);
}
@ -3007,10 +3009,10 @@ InitializeSprite(DeviceIntPtr pDev, WindowPtr pWin)
}
#ifdef PANORAMIX
if(!noPanoramiXExtension) {
pSprite->hotLimits.x1 = -panoramiXdataPtr[0].x;
pSprite->hotLimits.y1 = -panoramiXdataPtr[0].y;
pSprite->hotLimits.x2 = PanoramiXPixWidth - panoramiXdataPtr[0].x;
pSprite->hotLimits.y2 = PanoramiXPixHeight - panoramiXdataPtr[0].y;
pSprite->hotLimits.x1 = -screenInfo.screens[0]->x;
pSprite->hotLimits.y1 = -screenInfo.screens[0]->y;
pSprite->hotLimits.x2 = PanoramiXPixWidth - screenInfo.screens[0]->x;
pSprite->hotLimits.y2 = PanoramiXPixHeight - screenInfo.screens[0]->y;
pSprite->physLimits = pSprite->hotLimits;
pSprite->confineWin = NullWindow;
pSprite->hotShape = NullRegion;
@ -3051,7 +3053,7 @@ UpdateSpriteForScreen(DeviceIntPtr pDev, ScreenPtr pScreen)
pSprite = pDev->spriteInfo->sprite;
win = WindowTable[pScreen->myNum];
win = pScreen->root;
pSprite->hotPhys.pScreen = pScreen;
pSprite->hot = pSprite->hotPhys;
@ -3077,10 +3079,10 @@ UpdateSpriteForScreen(DeviceIntPtr pDev, ScreenPtr pScreen)
#ifdef PANORAMIX
if(!noPanoramiXExtension) {
pSprite->hotLimits.x1 = -panoramiXdataPtr[0].x;
pSprite->hotLimits.y1 = -panoramiXdataPtr[0].y;
pSprite->hotLimits.x2 = PanoramiXPixWidth - panoramiXdataPtr[0].x;
pSprite->hotLimits.y2 = PanoramiXPixHeight - panoramiXdataPtr[0].y;
pSprite->hotLimits.x1 = -screenInfo.screens[0]->x;
pSprite->hotLimits.y1 = -screenInfo.screens[0]->y;
pSprite->hotLimits.x2 = PanoramiXPixWidth - screenInfo.screens[0]->x;
pSprite->hotLimits.y2 = PanoramiXPixHeight - screenInfo.screens[0]->y;
pSprite->physLimits = pSprite->hotLimits;
pSprite->screen = pScreen;
}
@ -3113,10 +3115,8 @@ NewCurrentScreen(DeviceIntPtr pDev, ScreenPtr newScreen, int x, int y)
pSprite->hotPhys.y = y;
#ifdef PANORAMIX
if(!noPanoramiXExtension) {
pSprite->hotPhys.x += panoramiXdataPtr[newScreen->myNum].x -
panoramiXdataPtr[0].x;
pSprite->hotPhys.y += panoramiXdataPtr[newScreen->myNum].y -
panoramiXdataPtr[0].y;
pSprite->hotPhys.x += newScreen->x - screenInfo.screens[0]->x;
pSprite->hotPhys.y += newScreen->y - screenInfo.screens[0]->y;
if (newScreen != pSprite->screen) {
pSprite->screen = newScreen;
/* Make sure we tell the DDX to update its copy of the screen */
@ -3124,23 +3124,22 @@ NewCurrentScreen(DeviceIntPtr pDev, ScreenPtr newScreen, int x, int y)
XineramaConfineCursorToWindow(pDev,
pSprite->confineWin, TRUE);
else
XineramaConfineCursorToWindow(pDev, WindowTable[0], TRUE);
XineramaConfineCursorToWindow(pDev, screenInfo.screens[0]->root, TRUE);
/* if the pointer wasn't confined, the DDX won't get
told of the pointer warp so we reposition it here */
if(!syncEvents.playingEvents)
(*pSprite->screen->SetCursorPosition)(
pDev,
pSprite->screen,
pSprite->hotPhys.x + panoramiXdataPtr[0].x -
panoramiXdataPtr[pSprite->screen->myNum].x,
pSprite->hotPhys.y + panoramiXdataPtr[0].y -
panoramiXdataPtr[pSprite->screen->myNum].y, FALSE);
pSprite->hotPhys.x + screenInfo.screens[0]->x -
pSprite->screen->x,
pSprite->hotPhys.y + screenInfo.screens[0]->y -
pSprite->screen->y, FALSE);
}
} else
#endif
if (newScreen != pSprite->hotPhys.pScreen)
ConfineCursorToWindow(pDev, WindowTable[newScreen->myNum],
TRUE, FALSE);
ConfineCursorToWindow(pDev, newScreen->root, TRUE, FALSE);
}
#ifdef PANORAMIX
@ -3163,14 +3162,14 @@ XineramaPointInWindowIsVisible(
if(!XineramaSetWindowPntrs(inputInfo.pointer, pWin)) return FALSE;
xoff = x + panoramiXdataPtr[0].x;
yoff = y + panoramiXdataPtr[0].y;
xoff = x + screenInfo.screens[0]->x;
yoff = y + screenInfo.screens[0]->y;
for(i = 1; i < PanoramiXNumScreens; i++) {
pWin = inputInfo.pointer->spriteInfo->sprite->windows[i];
pScreen = pWin->drawable.pScreen;
x = xoff - panoramiXdataPtr[i].x;
y = yoff - panoramiXdataPtr[i].y;
x = xoff - screenInfo.screens[i]->x;
y = yoff - screenInfo.screens[i]->y;
if(POINT_IN_REGION(pScreen, &pWin->borderClip, x, y, &box)
&& (!wInputShape(pWin) ||
@ -3215,9 +3214,9 @@ XineramaWarpPointer(ClientPtr client)
winX = source->drawable.x;
winY = source->drawable.y;
if(source == WindowTable[0]) {
winX -= panoramiXdataPtr[0].x;
winY -= panoramiXdataPtr[0].y;
if(source == screenInfo.screens[0]->root) {
winX -= screenInfo.screens[0]->x;
winY -= screenInfo.screens[0]->y;
}
if (x < winX + stuff->srcX ||
y < winY + stuff->srcY ||
@ -3231,9 +3230,9 @@ XineramaWarpPointer(ClientPtr client)
if (dest) {
x = dest->drawable.x;
y = dest->drawable.y;
if(dest == WindowTable[0]) {
x -= panoramiXdataPtr[0].x;
y -= panoramiXdataPtr[0].y;
if(dest == screenInfo.screens[0]->root) {
x -= screenInfo.screens[0]->x;
y -= screenInfo.screens[0]->y;
}
}
@ -4997,11 +4996,11 @@ ProcQueryPointer(ClientPtr client)
#ifdef PANORAMIX
if(!noPanoramiXExtension) {
rep.rootX += panoramiXdataPtr[0].x;
rep.rootY += panoramiXdataPtr[0].y;
rep.rootX += screenInfo.screens[0]->x;
rep.rootY += screenInfo.screens[0]->y;
if(stuff->id == rep.root) {
rep.winX += panoramiXdataPtr[0].x;
rep.winY += panoramiXdataPtr[0].y;
rep.winX += screenInfo.screens[0]->x;
rep.winY += screenInfo.screens[0]->y;
}
}
#endif
@ -5670,7 +5669,7 @@ WriteEventsToClient(ClientPtr pClient, int count, xEvent *events)
#ifdef PANORAMIX
if(!noPanoramiXExtension &&
(panoramiXdataPtr[0].x || panoramiXdataPtr[0].y))
(screenInfo.screens[0]->x || screenInfo.screens[0]->y))
{
switch(events->u.u.type) {
case MotionNotify:
@ -5687,13 +5686,13 @@ WriteEventsToClient(ClientPtr pClient, int count, xEvent *events)
*/
count = 1; /* should always be 1 */
memcpy(&eventCopy, events, sizeof(xEvent));
eventCopy.u.keyButtonPointer.rootX += panoramiXdataPtr[0].x;
eventCopy.u.keyButtonPointer.rootY += panoramiXdataPtr[0].y;
eventCopy.u.keyButtonPointer.rootX += screenInfo.screens[0]->x;
eventCopy.u.keyButtonPointer.rootY += screenInfo.screens[0]->y;
if(eventCopy.u.keyButtonPointer.event ==
eventCopy.u.keyButtonPointer.root)
{
eventCopy.u.keyButtonPointer.eventX += panoramiXdataPtr[0].x;
eventCopy.u.keyButtonPointer.eventY += panoramiXdataPtr[0].y;
eventCopy.u.keyButtonPointer.eventX += screenInfo.screens[0]->x;
eventCopy.u.keyButtonPointer.eventY += screenInfo.screens[0]->y;
}
events = &eventCopy;
break;

4
dix/getevents.c
View File

@ -1210,8 +1210,8 @@ PostSyntheticMotion(DeviceIntPtr pDev,
will translate from sprite screen to screen 0 upon reentry
to the DIX layer. */
if (!noPanoramiXExtension) {
x += panoramiXdataPtr[0].x - panoramiXdataPtr[screen].x;
y += panoramiXdataPtr[0].y - panoramiXdataPtr[screen].y;
x += screenInfo.screens[0]->x - screenInfo.screens[screen]->x;
y += screenInfo.screens[0]->y - screenInfo.screens[screen]->y;
}
#endif

4
dix/globals.c
View File

@ -83,8 +83,6 @@ ClientPtr serverClient;
int currentMaxClients; /* current size of clients array */
long maxBigRequestSize = MAX_BIG_REQUEST_SIZE;
WindowPtr WindowTable[MAXSCREENS];
unsigned long globalSerialNumber = 0;
unsigned long serverGeneration = 0;
@ -137,5 +135,3 @@ char *display;
char *ConnectionInfo;
CARD32 TimeOutValue = DEFAULT_TIMEOUT * MILLI_PER_SECOND;
DDXPointRec dixScreenOrigins[MAXSCREENS];

5
dix/main.c
View File

@ -249,7 +249,7 @@ int main(int argc, char *argv[], char *envp[])
#endif
for (i = 0; i < screenInfo.numScreens; i++)
InitRootWindow(WindowTable[i]);
InitRootWindow(screenInfo.screens[i]->root);
InitCoreDevices();
InitInput(argc, argv);
@ -303,7 +303,8 @@ int main(int argc, char *argv[], char *envp[])
CloseInput();
memset(WindowTable, 0, sizeof(WindowTable));
for (i = 0; i < screenInfo.numScreens; i++)
screenInfo.screens[i]->root = NullWindow;
CloseDownDevices();
CloseDownEvents();

102
dix/window.c
View File

@ -151,12 +151,10 @@ WindowSeekDeviceCursor(WindowPtr pWin,
int screenIsSaved = SCREEN_SAVER_OFF;
ScreenSaverStuffRec savedScreenInfo[MAXSCREENS];
static int FocusPrivatesKeyIndex;
DevPrivateKey FocusPrivatesKey = &FocusPrivatesKeyIndex;
static Bool TileScreenSaver(int i, int kind);
static Bool TileScreenSaver(ScreenPtr pScreen, int kind);
#define INPUTONLY_LEGAL_MASK (CWWinGravity | CWEventMask | \
@ -212,7 +210,7 @@ PrintWindowTree(void)
for (i=0; i<screenInfo.numScreens; i++)
{
ErrorF("[dix] WINDOW %d\n", i);
pWin = WindowTable[i];
pWin = screenInfo.screens[i]->root;
miPrintRegion(&pWin->clipList);
p1 = pWin->firstChild;
PrintChildren(p1, 4);
@ -258,7 +256,7 @@ TraverseTree(WindowPtr pWin, VisitWindowProcPtr func, pointer data)
int
WalkTree(ScreenPtr pScreen, VisitWindowProcPtr func, pointer data)
{
return(TraverseTree(WindowTable[pScreen->myNum], func, data));
return(TraverseTree(pScreen->root, func, data));
}
/* hack for forcing backing store on all windows */
@ -363,12 +361,12 @@ CreateRootWindow(ScreenPtr pScreen)
if (!pWin)
return FALSE;
savedScreenInfo[pScreen->myNum].pWindow = NULL;
savedScreenInfo[pScreen->myNum].wid = FakeClientID(0);
savedScreenInfo[pScreen->myNum].ExternalScreenSaver = NULL;
pScreen->screensaver.pWindow = NULL;
pScreen->screensaver.wid = FakeClientID(0);
pScreen->screensaver.ExternalScreenSaver = NULL;
screenIsSaved = SCREEN_SAVER_OFF;
WindowTable[pScreen->myNum] = pWin;
pScreen->root = pWin;
pWin->drawable.pScreen = pScreen;
pWin->drawable.type = DRAWABLE_WINDOW;
@ -539,7 +537,7 @@ RealChildHead(WindowPtr pWin)
if (!pWin->parent &&
(screenIsSaved == SCREEN_SAVER_ON) &&
(HasSaverWindow (pWin->drawable.pScreen->myNum)))
(HasSaverWindow (pWin->drawable.pScreen)))
return (pWin->firstChild);
else
return (NullWindow);
@ -1329,7 +1327,7 @@ ChangeWindowAttributes(WindowPtr pWin, Mask vmask, XID *vlist, ClientPtr client)
*/
if ( cursorID == None)
{
if (pWin == WindowTable[pWin->drawable.pScreen->myNum])
if (pWin == pWin->drawable.pScreen->root)
pCursor = rootCursor;
else
pCursor = (CursorPtr) None;
@ -2238,8 +2236,8 @@ ConfigureWindow(WindowPtr pWin, Mask mask, XID *vlist, ClientPtr client)
event.u.configureRequest.y = y;
#ifdef PANORAMIX
if(!noPanoramiXExtension && (!pParent || !pParent->parent)) {
event.u.configureRequest.x += panoramiXdataPtr[0].x;
event.u.configureRequest.y += panoramiXdataPtr[0].y;
event.u.configureRequest.x += screenInfo.screens[0]->x;
event.u.configureRequest.y += screenInfo.screens[0]->y;
}
#endif
event.u.configureRequest.width = w;
@ -2319,8 +2317,8 @@ ActuallyDoSomething:
event.u.configureNotify.y = y;
#ifdef PANORAMIX
if(!noPanoramiXExtension && (!pParent || !pParent->parent)) {
event.u.configureNotify.x += panoramiXdataPtr[0].x;
event.u.configureNotify.y += panoramiXdataPtr[0].y;
event.u.configureNotify.x += screenInfo.screens[0]->x;
event.u.configureNotify.y += screenInfo.screens[0]->y;
}
#endif
event.u.configureNotify.width = w;
@ -2473,8 +2471,8 @@ ReparentWindow(WindowPtr pWin, WindowPtr pParent,
event.u.reparent.y = y;
#ifdef PANORAMIX
if(!noPanoramiXExtension && !pParent->parent) {
event.u.reparent.x += panoramiXdataPtr[0].x;
event.u.reparent.y += panoramiXdataPtr[0].y;
event.u.reparent.x += screenInfo.screens[0]->x;
event.u.reparent.y += screenInfo.screens[0]->y;
}
#endif
event.u.reparent.override = pWin->overrideRedirect;
@ -2966,7 +2964,7 @@ HandleSaveSet(ClientPtr client)
pWin = SaveSetWindow(client->saveSet[j]);
#ifdef XFIXES
if (SaveSetToRoot(client->saveSet[j]))
pParent = WindowTable[pWin->drawable.pScreen->myNum];
pParent = pWin->drawable.pScreen->root;
else
#endif
{
@ -3034,7 +3032,7 @@ NotClippedByChildren(WindowPtr pWin)
pReg = REGION_CREATE(pScreen, NullBox, 1);
if (pWin->parent ||
screenIsSaved != SCREEN_SAVER_ON ||
!HasSaverWindow (pWin->drawable.pScreen->myNum))
!HasSaverWindow (pWin->drawable.pScreen))
{
REGION_INTERSECT(pScreen, pReg, &pWin->borderClip, &pWin->winSize);
}
@ -3152,33 +3150,33 @@ dixSaveScreens(ClientPtr client, int on, int mode)
}
for (i = 0; i < screenInfo.numScreens; i++)
{
ScreenPtr pScreen = screenInfo.screens[i];
if (on == SCREEN_SAVER_FORCER)
(* screenInfo.screens[i]->SaveScreen) (screenInfo.screens[i], on);
if (savedScreenInfo[i].ExternalScreenSaver)
(* pScreen->SaveScreen) (pScreen, on);
if (pScreen->screensaver.ExternalScreenSaver)
{
if ((*savedScreenInfo[i].ExternalScreenSaver)
(screenInfo.screens[i], type, on == SCREEN_SAVER_FORCER))
if ((*pScreen->screensaver.ExternalScreenSaver)
(pScreen, type, on == SCREEN_SAVER_FORCER))
continue;
}
if (type == screenIsSaved)
continue;
switch (type) {
case SCREEN_SAVER_OFF:
if (savedScreenInfo[i].blanked == SCREEN_IS_BLANKED)
if (pScreen->screensaver.blanked == SCREEN_IS_BLANKED)
{
(* screenInfo.screens[i]->SaveScreen) (screenInfo.screens[i],
what);
(* pScreen->SaveScreen) (pScreen, what);
}
else if (HasSaverWindow (i))
else if (HasSaverWindow (pScreen))
{
savedScreenInfo[i].pWindow = NullWindow;
FreeResource(savedScreenInfo[i].wid, RT_NONE);
pScreen->screensaver.pWindow = NullWindow;
FreeResource(pScreen->screensaver.wid, RT_NONE);
}
break;
case SCREEN_SAVER_CYCLE:
if (savedScreenInfo[i].blanked == SCREEN_IS_TILED)
if (pScreen->screensaver.blanked == SCREEN_IS_TILED)
{
WindowPtr pWin = savedScreenInfo[i].pWindow;
WindowPtr pWin = pScreen->screensaver.pWindow;
/* make it look like screen saver is off, so that
* NotClippedByChildren will compute a clip list
* for the root window, so miPaintWindow works
@ -3202,35 +3200,33 @@ dixSaveScreens(ClientPtr client, int on, int mode)
* Call the DDX saver in case it wants to do something
* at cycle time
*/
else if (savedScreenInfo[i].blanked == SCREEN_IS_BLANKED)
else if (pScreen->screensaver.blanked == SCREEN_IS_BLANKED)
{
(* screenInfo.screens[i]->SaveScreen) (screenInfo.screens[i],
type);
(* pScreen->SaveScreen) (pScreen, type);
}
break;
case SCREEN_SAVER_ON:
if (ScreenSaverBlanking != DontPreferBlanking)
{
if ((* screenInfo.screens[i]->SaveScreen)
(screenInfo.screens[i], what))
if ((* pScreen->SaveScreen) (pScreen, what))
{
savedScreenInfo[i].blanked = SCREEN_IS_BLANKED;
pScreen->screensaver.blanked = SCREEN_IS_BLANKED;
continue;
}
if ((ScreenSaverAllowExposures != DontAllowExposures) &&
TileScreenSaver(i, SCREEN_IS_BLACK))
TileScreenSaver(pScreen, SCREEN_IS_BLACK))
{
savedScreenInfo[i].blanked = SCREEN_IS_BLACK;
pScreen->screensaver.blanked = SCREEN_IS_BLACK;
continue;
}
}
if ((ScreenSaverAllowExposures != DontAllowExposures) &&
TileScreenSaver(i, SCREEN_IS_TILED))
TileScreenSaver(pScreen, SCREEN_IS_TILED))
{
savedScreenInfo[i].blanked = SCREEN_IS_TILED;
pScreen->screensaver.blanked = SCREEN_IS_TILED;
}
else
savedScreenInfo[i].blanked = SCREEN_ISNT_SAVED;
pScreen->screensaver.blanked = SCREEN_ISNT_SAVED;
break;
}
}
@ -3252,7 +3248,7 @@ SaveScreens(int on, int mode)
}
static Bool
TileScreenSaver(int i, int kind)
TileScreenSaver(ScreenPtr pScreen, int kind)
{
int j;
int result;
@ -3269,9 +3265,9 @@ TileScreenSaver(int i, int kind)
attri = 0;
switch (kind) {
case SCREEN_IS_TILED:
switch (WindowTable[i]->backgroundState) {
switch (pScreen->root->backgroundState) {
case BackgroundPixel:
attributes[attri++] = WindowTable[i]->background.pixel;
attributes[attri++] = pScreen->root->background.pixel;
mask |= CWBackPixel;
break;
case BackgroundPixmap:
@ -3283,7 +3279,7 @@ TileScreenSaver(int i, int kind)
}
break;
case SCREEN_IS_BLACK:
attributes[attri++] = WindowTable[i]->drawable.pScreen->blackPixel;
attributes[attri++] = pScreen->root->drawable.pScreen->blackPixel;
mask |= CWBackPixel;
break;
}
@ -3330,14 +3326,14 @@ TileScreenSaver(int i, int kind)
}
}
pWin = savedScreenInfo[i].pWindow =
CreateWindow(savedScreenInfo[i].wid,
WindowTable[i],
pWin = pScreen->screensaver.pWindow =
CreateWindow(pScreen->screensaver.wid,
pScreen->root,
-RANDOM_WIDTH, -RANDOM_WIDTH,
(unsigned short)screenInfo.screens[i]->width + RANDOM_WIDTH,
(unsigned short)screenInfo.screens[i]->height + RANDOM_WIDTH,
(unsigned short)pScreen->width + RANDOM_WIDTH,
(unsigned short)pScreen->height + RANDOM_WIDTH,
0, InputOutput, mask, attributes, 0, serverClient,
wVisual (WindowTable[i]), &result);
wVisual (pScreen->root), &result);
if (cursor)
FreeResource (cursorID, RT_NONE);
@ -3346,7 +3342,7 @@ TileScreenSaver(int i, int kind)
return FALSE;
if (!AddResource(pWin->drawable.id, RT_WINDOW,
(pointer)savedScreenInfo[i].pWindow))
(pointer)pScreen->screensaver.pWindow))
return FALSE;
if (mask & CWBackPixmap)

2
fb/fb.h
View File

@ -740,7 +740,7 @@ typedef struct {
#define fbWindowEnabled(pWin) \
REGION_NOTEMPTY((pWin)->drawable.pScreen, \
&WindowTable[(pWin)->drawable.pScreen->myNum]->borderClip)
&(pWin)->drawable.pScreen->root->borderClip)
#define fbDrawableEnabled(pDrawable) \
((pDrawable)->type == DRAWABLE_PIXMAP ? \

60
hw/dmx/dmxcursor.c
View File

@ -230,7 +230,7 @@ static int dmxSLFindNext(int *list)
/** Make one pass over all the screens and return the number updated. */
static int dmxTryComputeScreenOrigins(int *screensLeft)
{
ScreenPtr pScreen;
ScreenPtr pScreen, refScreen;
DMXScreenInfo *screen;
int i, ref;
int changed = 0;
@ -239,54 +239,56 @@ static int dmxTryComputeScreenOrigins(int *screensLeft)
if (!screensLeft[i])
continue;
screen = &dmxScreens[i];
pScreen = screenInfo.screens[i];
switch (screen->where) {
case PosAbsolute:
dixScreenOrigins[i].x = screen->whereX;
dixScreenOrigins[i].y = screen->whereY;
pScreen->x = screen->whereX;
pScreen->y = screen->whereY;
++changed, screensLeft[i] = 0;
break;
case PosRelative:
ref = screen->whereRefScreen;
if (screensLeft[ref])
break;
dixScreenOrigins[i].x = dixScreenOrigins[ref].x + screen->whereX;
dixScreenOrigins[i].y = dixScreenOrigins[ref].y + screen->whereY;
refScreen = screenInfo.screens[ref];
pScreen->x = refScreen->x + screen->whereX;
pScreen->y = refScreen->y + screen->whereY;
++changed, screensLeft[i] = 0;
break;
case PosRightOf:
ref = screen->whereRefScreen;
if (screensLeft[ref])
break;
pScreen = screenInfo.screens[ref];
dixScreenOrigins[i].x = dixScreenOrigins[ref].x + pScreen->width;
dixScreenOrigins[i].y = dixScreenOrigins[ref].y;
refScreen = screenInfo.screens[ref];
pScreen->x = refScreen->x + refScreen->width;
pScreen->y = refScreen->y;
++changed, screensLeft[i] = 0;
break;
case PosLeftOf:
ref = screen->whereRefScreen;
if (screensLeft[ref])
break;
pScreen = screenInfo.screens[i];
dixScreenOrigins[i].x = dixScreenOrigins[ref].x - pScreen->width;
dixScreenOrigins[i].y = dixScreenOrigins[ref].y;
refScreen = screenInfo.screens[ref];
pScreen->x = refScreen->x - pScreen->width;
pScreen->y = refScreen->y;
++changed, screensLeft[i] = 0;
break;
case PosBelow:
ref = screen->whereRefScreen;
if (screensLeft[ref])
break;
pScreen = screenInfo.screens[ref];
dixScreenOrigins[i].x = dixScreenOrigins[ref].x;
dixScreenOrigins[i].y = dixScreenOrigins[ref].y + pScreen->height;
refScreen = screenInfo.screens[ref];
pScreen->x = refScreen->x;
pScreen->y = refScreen->y + refScreen->height;
++changed, screensLeft[i] = 0;
break;
case PosAbove:
ref = screen->whereRefScreen;
if (screensLeft[ref])
break;
pScreen = screenInfo.screens[i];
dixScreenOrigins[i].x = dixScreenOrigins[ref].x;
dixScreenOrigins[i].y = dixScreenOrigins[ref].y - pScreen->height;
refScreen = screenInfo.screens[ref];
pScreen->x = refScreen->x;
pScreen->y = refScreen->y - pScreen->height;
++changed, screensLeft[i] = 0;
break;
case PosNone:
@ -298,6 +300,7 @@ static int dmxTryComputeScreenOrigins(int *screensLeft)
static void dmxComputeScreenOrigins(void)
{
ScreenPtr pScreen;
int *screensLeft;
int i, ref;
int minX, minY;
@ -313,7 +316,8 @@ static void dmxComputeScreenOrigins(void)
* guarantees that we will eventually terminate.
*/
ref = dmxScreens[i].whereRefScreen;
dixScreenOrigins[ref].x = dixScreenOrigins[ref].y = 0;
pScreen = screenInfo.screens[ref];
pScreen->x = pScreen->y = 0;
screensLeft[ref] = 0;
}
}
@ -322,18 +326,18 @@ static void dmxComputeScreenOrigins(void)
/* Justify the topmost and leftmost to
* (0,0). */
minX = dixScreenOrigins[0].x;
minY = dixScreenOrigins[0].y;
minX = screenInfo.screens[0]->x;
minY = screenInfo.screens[0]->y;
for (i = 1; i < dmxNumScreens; i++) { /* Compute minX, minY */
if (dixScreenOrigins[i].x < minX)
minX = dixScreenOrigins[i].x;
if (dixScreenOrigins[i].y < minY)
minY = dixScreenOrigins[i].y;
if (screenInfo.screens[i]->x < minX)
minX = screenInfo.screens[i]->x;
if (screenInfo.screens[i]->y < minY)
minY = screenInfo.screens[i]->y;
}
if (minX || minY) {
for (i = 0; i < dmxNumScreens; i++) {
dixScreenOrigins[i].x -= minX;
dixScreenOrigins[i].y -= minY;
screenInfo.screens[i]->x -= minX;
screenInfo.screens[i]->y -= minY;
}
}
}
@ -398,8 +402,8 @@ void dmxInitOrigins(void)
for (i = 0; i < dmxNumScreens; i++) {
DMXScreenInfo *dmxScreen = &dmxScreens[i];
dmxScreen->rootXOrigin = dixScreenOrigins[i].x;
dmxScreen->rootYOrigin = dixScreenOrigins[i].y;
dmxScreen->rootXOrigin = screenInfo.screens[i]->x;
dmxScreen->rootYOrigin = screenInfo.screens[i]->y;
}
dmxReInitOrigins();

26
hw/dmx/dmxextension.c
View File

@ -297,7 +297,7 @@ void dmxFlushPendingSyncs(void)
void dmxUpdateScreenResources(ScreenPtr pScreen, int x, int y, int w, int h)
{
DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum];
WindowPtr pRoot = WindowTable[pScreen->myNum];
WindowPtr pRoot = pScreen->root;
WindowPtr pChild;
Bool anyMarked = FALSE;
@ -402,7 +402,7 @@ static void dmxConfigureScreenWindow(int idx,
static void dmxConfigureRootWindow(int idx, int x, int y, int w, int h)
{
DMXScreenInfo *dmxScreen = &dmxScreens[idx];
WindowPtr pRoot = WindowTable[idx];
WindowPtr pRoot = screenInfo.screens[idx]->root;
/* NOTE: Either this function or the ones that it calls must handle
* the case where w == 0 || h == 0. Currently, the functions that
@ -437,7 +437,7 @@ static void dmxSetRootWindowOrigin(int idx, int x, int y)
{
DMXScreenInfo *dmxScreen = &dmxScreens[idx];
ScreenPtr pScreen = screenInfo.screens[idx];
WindowPtr pRoot = WindowTable[idx];
WindowPtr pRoot = pScreen->root;
WindowPtr pChild;
int xoff;
int yoff;
@ -447,18 +447,18 @@ static void dmxSetRootWindowOrigin(int idx, int x, int y)
dmxScreen->rootYOrigin = y;
/* Compute offsets here in case <x,y> has been changed above */
xoff = x - dixScreenOrigins[idx].x;
yoff = y - dixScreenOrigins[idx].y;
xoff = x - pScreen->x;
yoff = y - pScreen->y;
/* Adjust the root window's position in dixScreenOrigins */
dixScreenOrigins[idx].x = dmxScreen->rootXOrigin;
dixScreenOrigins[idx].y = dmxScreen->rootYOrigin;
/* Adjust the root window's position */
pScreen->x = dmxScreen->rootXOrigin;
pScreen->y = dmxScreen->rootYOrigin;
/* Recalculate the Xinerama regions and data structs */
XineramaReinitData(pScreen);
/* Adjust each of the root window's children */
if (!idx) ReinitializeRootWindow(WindowTable[0], xoff, yoff);
if (!idx) ReinitializeRootWindow(screenInfo.screens[0]->root, xoff, yoff);
pChild = pRoot->firstChild;
while (pChild) {
/* Adjust child window's position */
@ -634,7 +634,7 @@ int dmxConfigureDesktop(DMXDesktopAttributesPtr attribs)
int i;
for (i = 0; i < dmxNumScreens; i++) {
ScreenPtr pScreen = screenInfo.screens[i];
WindowPtr pChild = WindowTable[i]->firstChild;
WindowPtr pChild = pScreen->root->firstChild;
while (pChild) {
/* Adjust child window's position */
pScreen->MoveWindow(pChild,
@ -914,7 +914,7 @@ static void dmxBECreateResources(pointer value, XID id, RESTYPE type,
static void dmxBECreateWindowTree(int idx)
{
DMXScreenInfo *dmxScreen = &dmxScreens[idx];
WindowPtr pRoot = WindowTable[idx];
WindowPtr pRoot = screenInfo.screens[idx]->root;
dmxWinPrivPtr pWinPriv = DMX_GET_WINDOW_PRIV(pRoot);
WindowPtr pWin;
@ -982,7 +982,7 @@ static void dmxBECreateWindowTree(int idx)
static void dmxForceExposures(int idx)
{
ScreenPtr pScreen = screenInfo.screens[idx];
WindowPtr pRoot = WindowTable[idx];
WindowPtr pRoot = pScreen->root;
Bool anyMarked = FALSE;
WindowPtr pChild;
@ -1510,7 +1510,7 @@ static void dmxBEDestroyScratchGCs(int scrnNum)
* destroy a window as well as all of it's children. */
static void dmxBEDestroyWindowTree(int idx)
{
WindowPtr pWin = WindowTable[idx];
WindowPtr pWin = screenInfo.screens[idx]->root;
WindowPtr pChild = pWin;
while (1) {

15
hw/dmx/doc/dmx.xml
View File

@ -1497,9 +1497,7 @@ PanoramiX prefix.
<para>The Xinerama extension is registered by calling AddExtension().
</para>
<para>A local per-screen array of data structures
(panoramiXdataPtr&lsqb;&rsqb;)
is allocated for each physical screen, and GC and Screen private
<para>GC and Screen private
indexes are allocated, and both GC and Screen private areas are
allocated for each physical screen. These hold Xinerama-specific
per-GC and per-Screen data. Each screen's CreateGC and CloseScreen
@ -1509,13 +1507,10 @@ PanoramiX prefix.
Xinerama windows, pixmaps and colormaps.
</para>
<para>A region (XineramaScreenRegions&lsqb;i&rsqb;) is initialized for each
physical screen, and single region (PanoramiXScreenRegion) is
initialized to be the union of the screen regions. The
panoramiXdataPtr&lsqb;&rsqb; array is also initialized with the size and
origin of each screen. The relative positioning information for the
physical screens is taken from the array
dixScreenOrigins&lsqb;&rsqb;, which
<para>A region (PanoramiXScreenRegion) is
initialized to be the union of the screen regions.
The relative positioning information for the
physical screens is taken from the ScreenRec x and y members, which
the DDX layer must initialize in InitOutput(). The bounds of the
combined screen is also calculated (PanoramiXPixWidth and
PanoramiXPixHeight).

9
hw/dmx/input/dmxcommon.c
View File

@ -370,7 +370,7 @@ void dmxCommonOthGetInfo(DevicePtr pDev, DMXLocalInitInfoPtr info)
Display *display = priv->display;
int num;
int i, j, k;
int (*handler)(Display *, char *, char *);
XextErrorHandler handler;
if (!display && !(display = XOpenDisplay(dmxInput->name)))
return;
@ -526,10 +526,9 @@ int dmxFindPointerScreen(int x, int y)
int i;
for (i = 0; i < dmxNumScreens; i++) {
if (x >= dixScreenOrigins[i].x
&& x < dixScreenOrigins[i].x + screenInfo.screens[i]->width
&& y >= dixScreenOrigins[i].y
&& y < dixScreenOrigins[i].y + screenInfo.screens[i]->height)
ScreenPtr pScreen = screenInfo.screens[i];
if (x >= pScreen->x && x < pScreen->x + pScreen->width &&
y >= pScreen->y && y < pScreen->y + pScreen->height)
return i;
}
return -1;

25
hw/dmx/input/dmxconsole.c
View File

@ -204,7 +204,8 @@ static void dmxConsoleDrawWindows(pointer private)
XUnionRectWithRegion(&rect, whole, whole);
for (i = 0; i < dmxNumScreens; i++) {
WindowPtr pRoot = WindowTable[i];
ScreenPtr pScreen = screenInfo.screens[i];
WindowPtr pRoot = pScreen->root;
WindowPtr pChild;
#if DMX_WINDOW_DEBUG
@ -227,10 +228,8 @@ static void dmxConsoleDrawWindows(pointer private)
pChild->overrideRedirect,
REGION_NUM_RECTS(&pChild->clipList));
#endif
rect.x = scalex(priv, pChild->drawable.x
+ dixScreenOrigins[i].x);
rect.y = scaley(priv, pChild->drawable.y
+ dixScreenOrigins[i].y);
rect.x = scalex(priv, pChild->drawable.x + pScreen->x);
rect.y = scaley(priv, pChild->drawable.y + pScreen->y);
rect.width = scalex(priv, pChild->drawable.width);
rect.height = scaley(priv, pChild->drawable.height);
XDrawRectangle(dpy, priv->pixmap, priv->gc,
@ -263,15 +262,15 @@ static void dmxConsoleDraw(myPrivate *priv, int updateCursor, int update)
DMXScreenInfo *dmxScreen = &dmxScreens[i];
XFillRectangle(dpy, priv->pixmap,
dmxScreen->beDisplay ? priv->gcRev : priv->gcDet,
scalex(priv, dixScreenOrigins[i].x),
scaley(priv, dixScreenOrigins[i].y),
scalex(priv, screenInfo.screens[i]->x),
scaley(priv, screenInfo.screens[i]->y),
scalex(priv, screenInfo.screens[i]->width),
scaley(priv, screenInfo.screens[i]->height));
}
for (i = 0; i < dmxNumScreens; i++) {
XDrawRectangle(dpy, priv->pixmap, priv->gc,
scalex(priv, dixScreenOrigins[i].x),
scaley(priv, dixScreenOrigins[i].y),
scalex(priv, screenInfo.screens[i]->x),
scaley(priv, screenInfo.screens[i]->y),
scalex(priv, screenInfo.screens[i]->width),
scaley(priv, screenInfo.screens[i]->height));
}
@ -671,11 +670,11 @@ static void dmxConsoleComputeWidthHeight(myPrivate *priv,
* possible by computing the visible
* bounding box. */
for (i = 0; i < dmxNumScreens; i++) {
if (dixScreenOrigins[i].x+screenInfo.screens[i]->width > *width)
*width = dixScreenOrigins[i].x+screenInfo.screens[i]->width;
if (screenInfo.screens[i]->x+screenInfo.screens[i]->width > *width)
*width = screenInfo.screens[i]->x+screenInfo.screens[i]->width;
if (dixScreenOrigins[i].y+screenInfo.screens[i]->height > *height)
*height = dixScreenOrigins[i].y+screenInfo.screens[i]->height;
if (screenInfo.screens[i]->y+screenInfo.screens[i]->height > *height)
*height = screenInfo.screens[i]->y+screenInfo.screens[i]->height;
}
#endif

6
hw/dmx/input/dmxinputinit.c
View File

@ -570,7 +570,7 @@ static void dmxUpdateWindowInformation(DMXInputInfo *dmxInput,
int i;
#ifdef PANORAMIX
if (!noPanoramiXExtension && pWindow && pWindow->parent != WindowTable[0])
if (!noPanoramiXExtension && pWindow && pWindow->parent != screenInfo.screens[0]->root)
return;
#endif
#if DMX_WINDOW_DEBUG
@ -827,7 +827,7 @@ static void dmxPopulateLocal(DMXInputInfo *dmxInput, dmxArg a)
}
}
int dmxInputExtensionErrorHandler(Display *dsp, char *name, char *reason)
int dmxInputExtensionErrorHandler(Display *dsp, _Xconst char *name, _Xconst char *reason)
{
return 0;
}
@ -839,7 +839,7 @@ static void dmxInputScanForExtensions(DMXInputInfo *dmxInput, int doXI)
Display *display;
int num;
int i, j;
int (*handler)(Display *, char *, char *);
XextErrorHandler handler;
if (!(display = XOpenDisplay(dmxInput->name))) return;

4
hw/dmx/input/dmxinputinit.h
View File

@ -276,8 +276,8 @@ extern void dmxKeyboardKbdCtrlProc(DeviceIntPtr pDevice, KeybdCtrl *ctrl);
extern void dmxKeyboardBellProc(int percent, DeviceIntPtr pDevice,
pointer ctrl, int unknown);
extern int dmxInputExtensionErrorHandler(Display *dsp, char *name,
char *reason);
extern int dmxInputExtensionErrorHandler(Display *dsp, _Xconst char *name,
_Xconst char *reason);
extern int dmxInputDetach(DMXInputInfo *dmxInput);
extern void dmxInputDetachAll(DMXScreenInfo *dmxScreen);

7
hw/kdrive/src/kdrive.c
View File

@ -95,7 +95,7 @@ KdOsFuncs *kdOsFuncs;
void
KdSetRootClip (ScreenPtr pScreen, BOOL enable)
{
WindowPtr pWin = WindowTable[pScreen->myNum];
WindowPtr pWin = pScreen->root;
WindowPtr pChild;
Bool WasViewable;
Bool anyMarked = FALSE;
@ -941,9 +941,8 @@ KdScreenInit(int index, ScreenPtr pScreen, int argc, char **argv)
pScreenPriv->card = card;
pScreenPriv->bytesPerPixel = screen->fb.bitsPerPixel >> 3;
pScreenPriv->dpmsState = KD_DPMS_NORMAL;
#ifdef PANORAMIX
dixScreenOrigins[pScreen->myNum] = screen->origin;
#endif
pScreen->x = screen->origin.x;
pScreen->y = screen->origin.y;
if (!monitorResolution)
monitorResolution = 75;

94
hw/xfree86/common/xf86Cursor.c
View File

@ -581,7 +581,7 @@ xf86InitOrigins(void)
{
unsigned long screensLeft, prevScreensLeft, mask;
screenLayoutPtr screen;
ScreenPtr pScreen;
ScreenPtr pScreen, refScreen;
int x1, x2, y1, y2, left, right, top, bottom;
int i, j, ref, minX, minY, min, max;
xf86ScreenLayoutPtr pLayout;
@ -608,6 +608,7 @@ xf86InitOrigins(void)
continue;
}
pScreen = xf86Screens[i]->pScreen;
switch(screen->where) {
case PosObsolete:
OldStyleConfig = TRUE;
@ -620,7 +621,7 @@ xf86InitOrigins(void)
break;
}
pLayout->left = AddEdge(pLayout->left,
0, xf86Screens[i]->pScreen->height,
0, pScreen->height,
xf86Screens[ref]->pScreen->width, 0, ref);
}
if(screen->right) {
@ -629,7 +630,6 @@ xf86InitOrigins(void)
ErrorF("Referenced uninitialized screen in Layout!\n");
break;
}
pScreen = xf86Screens[i]->pScreen;
pLayout->right = AddEdge(pLayout->right,
0, pScreen->height, -pScreen->width, 0, ref);
}
@ -640,7 +640,7 @@ xf86InitOrigins(void)
break;
}
pLayout->up = AddEdge(pLayout->up,
0, xf86Screens[i]->pScreen->width,
0, pScreen->width,
0, xf86Screens[ref]->pScreen->height, ref);
}
if(screen->bottom) {
@ -649,7 +649,6 @@ xf86InitOrigins(void)
ErrorF("Referenced uninitialized screen in Layout!\n");
break;
}
pScreen = xf86Screens[i]->pScreen;
pLayout->down = AddEdge(pLayout->down,
0, pScreen->width, 0, -pScreen->height, ref);
}
@ -658,8 +657,8 @@ xf86InitOrigins(void)
screen->x = screen->y = 0;
/* FALLTHROUGH */
case PosAbsolute:
dixScreenOrigins[i].x = screen->x;
dixScreenOrigins[i].y = screen->y;
pScreen->x = screen->x;
pScreen->y = screen->y;
screensLeft &= ~(1 << i);
break;
case PosRelative:
@ -669,8 +668,9 @@ xf86InitOrigins(void)
break;
}
if(screensLeft & (1 << ref)) break;
dixScreenOrigins[i].x = dixScreenOrigins[ref].x + screen->x;
dixScreenOrigins[i].y = dixScreenOrigins[ref].y + screen->y;
refScreen = xf86Screens[ref]->pScreen;
pScreen->x = refScreen->x + screen->x;
pScreen->y = refScreen->y + screen->y;
screensLeft &= ~(1 << i);
break;
case PosRightOf:
@ -680,10 +680,9 @@ xf86InitOrigins(void)
break;
}
if(screensLeft & (1 << ref)) break;
pScreen = xf86Screens[ref]->pScreen;
dixScreenOrigins[i].x =
dixScreenOrigins[ref].x + pScreen->width;
dixScreenOrigins[i].y = dixScreenOrigins[ref].y;
refScreen = xf86Screens[ref]->pScreen;
pScreen->x = refScreen->x + refScreen->width;
pScreen->y = refScreen->y;
screensLeft &= ~(1 << i);
break;
case PosLeftOf:
@ -693,10 +692,9 @@ xf86InitOrigins(void)
break;
}
if(screensLeft & (1 << ref)) break;
pScreen = xf86Screens[i]->pScreen;
dixScreenOrigins[i].x =
dixScreenOrigins[ref].x - pScreen->width;
dixScreenOrigins[i].y = dixScreenOrigins[ref].y;
refScreen = xf86Screens[ref]->pScreen;
pScreen->x = refScreen->x - pScreen->width;
pScreen->y = refScreen->y;
screensLeft &= ~(1 << i);
break;
case PosBelow:
@ -706,10 +704,9 @@ xf86InitOrigins(void)
break;
}
if(screensLeft & (1 << ref)) break;
pScreen = xf86Screens[ref]->pScreen;
dixScreenOrigins[i].x = dixScreenOrigins[ref].x;
dixScreenOrigins[i].y =
dixScreenOrigins[ref].y + pScreen->height;
refScreen = xf86Screens[ref]->pScreen;
pScreen->x = refScreen->x;
pScreen->y = refScreen->y + refScreen->height;
screensLeft &= ~(1 << i);
break;
case PosAbove:
@ -719,10 +716,9 @@ xf86InitOrigins(void)
break;
}
if(screensLeft & (1 << ref)) break;
pScreen = xf86Screens[i]->pScreen;
dixScreenOrigins[i].x = dixScreenOrigins[ref].x;
dixScreenOrigins[i].y =
dixScreenOrigins[ref].y - pScreen->height;
refScreen = xf86Screens[ref]->pScreen;
pScreen->x = refScreen->x;
pScreen->y = refScreen->y - pScreen->height;
screensLeft &= ~(1 << i);
break;
default:
@ -741,7 +737,7 @@ xf86InitOrigins(void)
while(!((1 << i) & screensLeft)){ i++; }
ref = xf86ConfigLayout.screens[i].refscreen->screennum;
dixScreenOrigins[ref].x = dixScreenOrigins[ref].y = 0;
xf86Screens[ref]->pScreen->x = xf86Screens[ref]->pScreen->y = 0;
screensLeft &= ~(1 << ref);
}
@ -749,20 +745,20 @@ xf86InitOrigins(void)
}
/* justify the topmost and leftmost to (0,0) */
minX = dixScreenOrigins[0].x;
minY = dixScreenOrigins[0].y;
minX = xf86Screens[0]->pScreen->x;
minY = xf86Screens[0]->pScreen->y;
for(i = 1; i < xf86NumScreens; i++) {
if(dixScreenOrigins[i].x < minX)
minX = dixScreenOrigins[i].x;
if(dixScreenOrigins[i].y < minY)
minY = dixScreenOrigins[i].y;
if(xf86Screens[i]->pScreen->x < minX)
minX = xf86Screens[i]->pScreen->x;
if(xf86Screens[i]->pScreen->y < minY)
minY = xf86Screens[i]->pScreen->y;
}
if (minX || minY) {
for(i = 0; i < xf86NumScreens; i++) {
dixScreenOrigins[i].x -= minX;
dixScreenOrigins[i].y -= minY;
xf86Screens[i]->pScreen->x -= minX;
xf86Screens[i]->pScreen->y -= minY;
}
}
@ -775,18 +771,20 @@ xf86InitOrigins(void)
pScreen = xf86Screens[i]->pScreen;
left = dixScreenOrigins[i].x;
left = pScreen->x;
right = left + pScreen->width;
top = dixScreenOrigins[i].y;
top = pScreen->y;
bottom = top + pScreen->height;
for(j = 0; j < xf86NumScreens; j++) {
if(i == j) continue;
x1 = dixScreenOrigins[j].x;
x2 = x1 + xf86Screens[j]->pScreen->width;
y1 = dixScreenOrigins[j].y;
y2 = y1 + xf86Screens[j]->pScreen->height;
refScreen = xf86Screens[j]->pScreen;
x1 = refScreen->x;
x2 = x1 + refScreen->width;
y1 = refScreen->y;
y2 = y1 + refScreen->height;
if((bottom > y1) && (top < y2)) {
min = y1 - top;
@ -796,13 +794,13 @@ xf86InitOrigins(void)
if(((left - 1) >= x1) && ((left - 1) < x2))
pLayout->left = AddEdge(pLayout->left, min, max,
dixScreenOrigins[i].x - dixScreenOrigins[j].x,
dixScreenOrigins[i].y - dixScreenOrigins[j].y, j);
pScreen->x - refScreen->x,
pScreen->y - refScreen->y, j);
if((right >= x1) && (right < x2))
pLayout->right = AddEdge(pLayout->right, min, max,
dixScreenOrigins[i].x - dixScreenOrigins[j].x,
dixScreenOrigins[i].y - dixScreenOrigins[j].y, j);
pScreen->x - refScreen->x,
pScreen->y - refScreen->y, j);
}
@ -814,13 +812,13 @@ xf86InitOrigins(void)
if(((top - 1) >= y1) && ((top - 1) < y2))
pLayout->up = AddEdge(pLayout->up, min, max,
dixScreenOrigins[i].x - dixScreenOrigins[j].x,
dixScreenOrigins[i].y - dixScreenOrigins[j].y, j);
pScreen->x - refScreen->x,
pScreen->y - refScreen->y, j);
if((bottom >= y1) && (bottom < y2))
pLayout->down = AddEdge(pLayout->down, min, max,
dixScreenOrigins[i].x - dixScreenOrigins[j].x,
dixScreenOrigins[i].y - dixScreenOrigins[j].y, j);
pScreen->x - refScreen->x,
pScreen->y - refScreen->y, j);
}
}
}

2
hw/xfree86/common/xf86Helper.c
View File

@ -1062,7 +1062,7 @@ xf86SetBlackWhitePixels(ScreenPtr pScreen)
static void
xf86SetRootClip (ScreenPtr pScreen, Bool enable)
{
WindowPtr pWin = WindowTable[pScreen->myNum];
WindowPtr pWin = pScreen->root;
WindowPtr pChild;
Bool WasViewable = (Bool)(pWin->viewable);
Bool anyMarked = FALSE;

2
hw/xfree86/common/xf86RandR.c
View File

@ -159,7 +159,7 @@ xf86RandRSetMode (ScreenPtr pScreen,
int oldmmHeight = pScreen->mmHeight;
int oldVirtualX = scrp->virtualX;
int oldVirtualY = scrp->virtualY;
WindowPtr pRoot = WindowTable[pScreen->myNum];
WindowPtr pRoot = pScreen->root;
Bool ret = TRUE;
if (pRoot && scrp->vtSema)

2
hw/xfree86/common/xf86xv.c
View File

@ -1881,7 +1881,7 @@ xf86XVFillKeyHelperDrawable (DrawablePtr pDraw, CARD32 key, RegionPtr clipboxes)
void
xf86XVFillKeyHelper (ScreenPtr pScreen, CARD32 key, RegionPtr clipboxes)
{
DrawablePtr root = &WindowTable[pScreen->myNum]->drawable;
DrawablePtr root = &pScreen->root->drawable;
ChangeGCVal pval[2];
BoxPtr pbox = REGION_RECTS(clipboxes);
int i, nbox = REGION_NUM_RECTS(clipboxes);

2
hw/xfree86/dixmods/extmod/xf86vmode.c
View File

@ -347,7 +347,7 @@ SendXF86VidModeNotify(ScreenPtr pScreen, int state, Bool forced)
ev.type = XF86VidModeNotify + XF86VidModeEventBase;
ev.state = state;
ev.timestamp = currentTime.milliseconds;
ev.root = WindowTable[pScreen->myNum]->drawable.id;
ev.root = pScreen->root->drawable.id;
ev.kind = kind;
ev.forced = forced;
WriteEventsToClient (pEv->client, 1, (xEvent *) &ev);

2
hw/xfree86/dri/dri.c
View File

@ -1187,7 +1187,7 @@ DRIDriverClipNotify(ScreenPtr pScreen)
if (pDRIPriv->nrWindows > 0) {
pDRIPriv->nrWalked = 0;
TraverseTree(WindowTable[pScreen->myNum], DRIDCNTreeTraversal,
TraverseTree(pScreen->root, DRIDCNTreeTraversal,
(pointer)pDRIWindows);
}

2
hw/xfree86/dri2/dri2.c
View File

@ -607,7 +607,7 @@ DRI2CanFlip(DrawablePtr pDraw)
if (pDraw->type == DRAWABLE_PIXMAP)
return TRUE;
pRoot = WindowTable[pScreen->myNum];
pRoot = pScreen->root;
pRootPixmap = pScreen->GetWindowPixmap(pRoot);
pWin = (WindowPtr) pDraw;

6
hw/xfree86/modes/xf86RandR12.c
View File

@ -517,7 +517,7 @@ xf86RandR12SetMode (ScreenPtr pScreen,
int oldHeight = pScreen->height;
int oldmmWidth = pScreen->mmWidth;
int oldmmHeight = pScreen->mmHeight;
WindowPtr pRoot = WindowTable[pScreen->myNum];
WindowPtr pRoot = pScreen->root;
DisplayModePtr currentMode = NULL;
Bool ret = TRUE;
PixmapPtr pspix = NULL;
@ -685,7 +685,7 @@ xf86RandR12ScreenSetSize (ScreenPtr pScreen,
XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
ScrnInfoPtr pScrn = XF86SCRNINFO(pScreen);
xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
WindowPtr pRoot = WindowTable[pScreen->myNum];
WindowPtr pRoot = pScreen->root;
PixmapPtr pScrnPix = (*pScreen->GetScreenPixmap)(pScreen);
Bool ret = FALSE;
int c;
@ -739,7 +739,7 @@ finish:
if (pRoot && pScrn->vtSema)
(*pScrn->EnableDisableFBAccess) (pScreen->myNum, TRUE);
#if RANDR_12_INTERFACE
if (xf86RandR12Key && WindowTable[pScreen->myNum] && ret)
if (xf86RandR12Key && pScreen->root && ret)
RRScreenSizeNotify (pScreen);
#endif
return ret;

4
hw/xfree86/modes/xf86Rotate.c
View File

@ -76,9 +76,9 @@ xf86RotateCrtcRedisplay (xf86CrtcPtr crtc, RegionPtr region)
{
ScrnInfoPtr scrn = crtc->scrn;
ScreenPtr screen = scrn->pScreen;
WindowPtr root = WindowTable[screen->myNum];
WindowPtr root = screen->root;
PixmapPtr dst_pixmap = crtc->rotatedPixmap;
PictFormatPtr format = compWindowFormat (WindowTable[screen->myNum]);
PictFormatPtr format = compWindowFormat (screen->root);
int error;
PicturePtr src, dst;
int n = REGION_NUM_RECTS(region);

2
hw/xfree86/xaa/xaaCpyWin.c
View File

@ -47,7 +47,7 @@ XAACopyWindow(
return;
}
pwinRoot = WindowTable[pScreen->myNum];
pwinRoot = pScreen->root;
REGION_NULL(pScreen, &rgnDst);

2
hw/xfree86/xaa/xaaOverlay.c
View File

@ -54,7 +54,7 @@ XAACopyWindow8_32(
return;
}
pwinRoot = WindowTable[pScreen->myNum];
pwinRoot = pScreen->root;
if(doUnderlay)
freeReg = miOverlayCollectUnderlayRegions(pWin, &borderClip);

2
hw/xfree86/xaa/xaaOverlayDF.c
View File

@ -324,7 +324,7 @@ XAAOverCopyWindow(
RegionRec rgnDst;
BoxPtr pbox;
int i, nbox, dx, dy;
WindowPtr pRoot = WindowTable[pScreen->myNum];
WindowPtr pRoot = pScreen->root;
if (!pScrn->vtSema || !infoRec->ScreenToScreenBitBlt) {

6
hw/xquartz/applewm.c
View File

@ -140,10 +140,8 @@ AppleWMSetScreenOrigin(
{
int32_t data[2];
data[0] = (dixScreenOrigins[pWin->drawable.pScreen->myNum].x
+ darwinMainScreenX);
data[1] = (dixScreenOrigins[pWin->drawable.pScreen->myNum].y
+ darwinMainScreenY);
data[0] = pWin->drawable.pScreen->x + darwinMainScreenX;
data[1] = pWin->drawable.pScreen->y + darwinMainScreenY;
dixChangeWindowProperty(serverClient, pWin, xa_native_screen_origin(),
XA_INTEGER, 32, PropModeReplace, 2, data, TRUE);

24
hw/xquartz/darwin.c
View File

@ -262,8 +262,8 @@ static Bool DarwinScreenInit(int index, ScreenPtr pScreen, int argc, char **argv
return FALSE;
}
dixScreenOrigins[index].x = dfb->x;
dixScreenOrigins[index].y = dfb->y;
pScreen->x = dfb->x;
pScreen->y = dfb->y;
/* ErrorF("Screen %d added: %dx%d @ (%d,%d)\n",
index, dfb->width, dfb->height, dfb->x, dfb->y); */
@ -526,16 +526,16 @@ DarwinAdjustScreenOrigins(ScreenInfo *pScreenInfo)
{
int i, left, top;
left = dixScreenOrigins[0].x;
top = dixScreenOrigins[0].y;
left = pScreenInfo->screens[0]->x;
top = pScreenInfo->screens[0]->y;
/* Find leftmost screen. If there's a tie, take the topmost of the two. */
for (i = 1; i < pScreenInfo->numScreens; i++) {
if (dixScreenOrigins[i].x < left ||
(dixScreenOrigins[i].x == left && dixScreenOrigins[i].y < top))
if (pScreenInfo->screens[i]->x < left ||
(pScreenInfo->screens[i]->x == left && pScreenInfo->screens[i]->y < top))
{
left = dixScreenOrigins[i].x;
top = dixScreenOrigins[i].y;
left = pScreenInfo->screens[i]->x;
top = pScreenInfo->screens[i]->y;
}
}
@ -551,10 +551,10 @@ DarwinAdjustScreenOrigins(ScreenInfo *pScreenInfo)
if (darwinMainScreenX != 0 || darwinMainScreenY != 0) {
for (i = 0; i < pScreenInfo->numScreens; i++) {
dixScreenOrigins[i].x -= darwinMainScreenX;
dixScreenOrigins[i].y -= darwinMainScreenY;
pScreenInfo->screens[i]->x -= darwinMainScreenX;
pScreenInfo->screens[i]->y -= darwinMainScreenY;
DEBUG_LOG("Screen %d placed at X11 coordinate (%d,%d).\n",
i, dixScreenOrigins[i].x, dixScreenOrigins[i].y);
i, pScreenInfo->screens[i]->x, pScreenInfo->screens[i]->y);
}
}
}
@ -793,7 +793,7 @@ void AbortDDX( void )
void
xf86SetRootClip (ScreenPtr pScreen, int enable)
{
WindowPtr pWin = WindowTable[pScreen->myNum];
WindowPtr pWin = pScreen->root;
WindowPtr pChild;
Bool WasViewable = (Bool)(pWin->viewable);
Bool anyMarked = TRUE;

4
hw/xquartz/darwinEvents.c
View File

@ -377,8 +377,8 @@ static void DarwinPrepareValuators(DeviceIntPtr pDev, int *valuators, ScreenPtr
float pointer_x, float pointer_y,
float pressure, float tilt_x, float tilt_y) {
/* Fix offset between darwin and X screens */
pointer_x -= darwinMainScreenX + dixScreenOrigins[screen->myNum].x;
pointer_y -= darwinMainScreenY + dixScreenOrigins[screen->myNum].y;
pointer_x -= darwinMainScreenX + screen->x;
pointer_y -= darwinMainScreenY + screen->y;
if(pointer_x < 0.0)
pointer_x = 0.0;

4
hw/xquartz/pseudoramiX.c
View File

@ -255,9 +255,9 @@ static int ProcPseudoramiXGetScreenSize(ClientPtr client)
rep.sequenceNumber = client->sequence;
/* screen dimensions */
rep.width = pseudoramiXScreens[stuff->screen].w;
// was panoramiXdataPtr[stuff->screen].width;
// was screenInfo.screens[stuff->screen]->width;
rep.height = pseudoramiXScreens[stuff->screen].h;
// was panoramiXdataPtr[stuff->screen].height;
// was screenInfo.screens[stuff->screen]->height;
if (client->swapped) {
swaps (&rep.sequenceNumber, n);
swapl (&rep.length, n);

14
hw/xquartz/quartz.c
View File

@ -259,8 +259,8 @@ void QuartzUpdateScreens(void) {
PseudoramiXResetScreens();
quartzProcs->AddPseudoramiXScreens(&x, &y, &width, &height);
dixScreenOrigins[pScreen->myNum].x = x;
dixScreenOrigins[pScreen->myNum].y = y;
pScreen->x = x;
pScreen->y = y;
pScreen->mmWidth = pScreen->mmWidth * ((double) width / pScreen->width);
pScreen->mmHeight = pScreen->mmHeight * ((double) height / pScreen->height);
pScreen->width = width;
@ -269,14 +269,14 @@ void QuartzUpdateScreens(void) {
DarwinAdjustScreenOrigins(&screenInfo);
quartzProcs->UpdateScreen(pScreen);
/* DarwinAdjustScreenOrigins or UpdateScreen may change dixScreenOrigins,
/* DarwinAdjustScreenOrigins or UpdateScreen may change pScreen->x/y,
* so use it rather than x/y
*/
sx = dixScreenOrigins[pScreen->myNum].x + darwinMainScreenX;
sy = dixScreenOrigins[pScreen->myNum].y + darwinMainScreenY;
sx = pScreen->x + darwinMainScreenX;
sy = pScreen->y + darwinMainScreenY;
/* Adjust the root window. */
pRoot = WindowTable[pScreen->myNum];
pRoot = pScreen->root;
AppleWMSetScreenOrigin(pRoot);
pScreen->ResizeWindow(pRoot, x - sx, y - sy, width, height, NULL);
miPaintWindow(pRoot, &pRoot->borderClip, PW_BACKGROUND);
@ -292,7 +292,7 @@ void QuartzUpdateScreens(void) {
inputInfo.pointer->spriteInfo->sprite->physLimits = bounds;
inputInfo.pointer->spriteInfo->sprite->hotLimits = bounds;
DEBUG_LOG("Root Window: %dx%d @ (%d, %d) darwinMainScreen (%d, %d) xy (%d, %d) dixScreenOrigins (%d, %d)\n", width, height, x - sx, y - sy, darwinMainScreenX, darwinMainScreenY, x, y, dixScreenOrigins[pScreen->myNum].x, dixScreenOrigins[pScreen->myNum].y);
DEBUG_LOG("Root Window: %dx%d @ (%d, %d) darwinMainScreen (%d, %d) xy (%d, %d) dixScreenOrigins (%d, %d)\n", width, height, x - sx, y - sy, darwinMainScreenX, darwinMainScreenY, x, y, pScreen->x, pScreen->y);
/* Send an event for the root reconfigure */
e.u.u.type = ConfigureNotify;

4
hw/xquartz/xpr/xprCursor.c
View File

@ -296,8 +296,8 @@ QuartzWarpCursor(DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
{
int sx, sy;
sx = dixScreenOrigins[pScreen->myNum].x + darwinMainScreenX;
sy = dixScreenOrigins[pScreen->myNum].y + darwinMainScreenY;
sx = pScreen->x + darwinMainScreenX;
sy = pScreen->y + darwinMainScreenY;
CGWarpMouseCursorPosition(CGPointMake(sx + x, sy + y));
}

2
hw/xquartz/xpr/xprFrame.c
View File

@ -576,7 +576,7 @@ xprHideWindows(Bool hide)
for (screen = 0; screen < screenInfo.numScreens; screen++) {
RootlessFrameID prevWid = NULL;
pRoot = WindowTable[screenInfo.screens[screen]->myNum];
pRoot = screenInfo.screens[screen]->root;
for (pWin = pRoot->firstChild; pWin; pWin = pWin->nextSib) {
RootlessWindowRec *winRec = WINREC(pWin);

4
hw/xquartz/xpr/xprScreen.c
View File

@ -397,7 +397,7 @@ xprUpdateScreen(ScreenPtr pScreen)
rootlessGlobalOffsetX = darwinMainScreenX;
rootlessGlobalOffsetY = darwinMainScreenY;
AppleWMSetScreenOrigin(WindowTable[pScreen->myNum]);
AppleWMSetScreenOrigin(pScreen->root);
RootlessRepositionWindows(pScreen);
RootlessUpdateScreenPixmap(pScreen);
@ -416,7 +416,7 @@ xprInitInput(int argc, char **argv)
rootlessGlobalOffsetY = darwinMainScreenY;
for (i = 0; i < screenInfo.numScreens; i++)
AppleWMSetScreenOrigin(WindowTable[i]);
AppleWMSetScreenOrigin(screenInfo.screens[i]->root);
}
/*

2
hw/xwin/winkeybd.c
View File

@ -262,7 +262,7 @@ winRestoreModeKeyStates (void)
/* Only process events if the rootwindow is mapped. The keyboard events
* will cause segfaults otherwise */
if (WindowTable && WindowTable[0] && WindowTable[0]->mapped == FALSE)
if (screenInfo.screens[0]->root && screenInfo.screens[0]->root->mapped == FALSE)
processEvents = FALSE;
/* Force to process all pending events in the mi event queue */

6
hw/xwin/winscrinit.c
View File

@ -243,11 +243,11 @@ winScreenInit (int index,
Note the screen origin in a normalized coordinate space where (0,0) is at the top left
of the native virtual desktop area
*/
dixScreenOrigins[index].x = pScreenInfo->dwInitialX - GetSystemMetrics(SM_XVIRTUALSCREEN);
dixScreenOrigins[index].y = pScreenInfo->dwInitialY - GetSystemMetrics(SM_YVIRTUALSCREEN);
pScreen->x = pScreenInfo->dwInitialX - GetSystemMetrics(SM_XVIRTUALSCREEN);
pScreen->y = pScreenInfo->dwInitialY - GetSystemMetrics(SM_YVIRTUALSCREEN);
ErrorF("Screen %d added at virtual desktop coordinate (%d,%d).\n",
index, dixScreenOrigins[index].x, dixScreenOrigins[index].y);
index, pScreen->x, pScreen->y);
#if CYGDEBUG || YES
winDebug ("winScreenInit - returning\n");

2
hw/xwin/winwin32rootlesswindow.c
View File

@ -407,7 +407,7 @@ void
winMWExtWMRestackWindows (ScreenPtr pScreen)
{
winScreenPriv(pScreen);
WindowPtr pRoot = WindowTable[pScreen->myNum];
WindowPtr pRoot = pScreen->root;
WindowPtr pWin = NULL;
WindowPtr pWinPrev = NULL;
win32RootlessWindowPtr pRLWin = NULL;

2
hw/xwin/winwindow.c
View File

@ -144,7 +144,7 @@ winCopyWindowNativeGDI (WindowPtr pWin,
#endif
/* Get a pointer to the root window */
pwinRoot = WindowTable[pWin->drawable.pScreen->myNum];
pwinRoot = pWin->drawable.pScreen->root;
/* Create a region for the destination */
prgnDst = REGION_CREATE(pWin->drawable.pScreen, NULL, 1);

3
include/globals.h
View File

@ -19,12 +19,9 @@ extern _X_EXPORT char *defaultFontPath;
extern _X_EXPORT int monitorResolution;
extern _X_EXPORT int defaultColorVisualClass;
extern _X_EXPORT WindowPtr WindowTable[MAXSCREENS];
extern _X_EXPORT int GrabInProgress;
extern _X_EXPORT Bool noTestExtensions;
extern _X_EXPORT DDXPointRec dixScreenOrigins[MAXSCREENS];
extern _X_EXPORT char *ConnectionInfo;
#ifdef DPMSExtension

14
include/scrnintstr.h
View File

@ -82,6 +82,16 @@ typedef struct _Depth {
VisualID *vids; /* block of visual ids for this depth */
} DepthRec;
typedef struct _ScreenSaverStuff {
WindowPtr pWindow;
XID wid;
char blanked;
Bool (*ExternalScreenSaver)(
ScreenPtr /*pScreen*/,
int /*xstate*/,
Bool /*force*/);
} ScreenSaverStuffRec;
/*
* There is a typedef for each screen function pointer so that code that
@ -446,7 +456,7 @@ typedef void (* DeviceCursorCleanupProcPtr)(
typedef struct _Screen {
int myNum; /* index of this instance in Screens[] */
ATOM id;
short width, height;
short x, y, width, height;
short mmWidth, mmHeight;
short numDepths;
unsigned char rootDepth;
@ -468,6 +478,8 @@ typedef struct _Screen {
pointer devPrivate;
short numVisuals;
VisualPtr visuals;
WindowPtr root;
ScreenSaverStuffRec screensaver;
/* Random screen procedures */

13
include/windowstr.h
View File

@ -204,24 +204,15 @@ extern _X_EXPORT Mask DontPropagateMasks[];
#define HasBorder(w) ((w)->borderWidth || wClipShape(w))
typedef struct _ScreenSaverStuff {
WindowPtr pWindow;
XID wid;
char blanked;
Bool (*ExternalScreenSaver)(
ScreenPtr /*pScreen*/,
int /*xstate*/,
Bool /*force*/);
} ScreenSaverStuffRec, *ScreenSaverStuffPtr;
typedef struct _ScreenSaverStuff *ScreenSaverStuffPtr;
#define SCREEN_IS_BLANKED 0
#define SCREEN_ISNT_SAVED 1
#define SCREEN_IS_TILED 2
#define SCREEN_IS_BLACK 3
#define HasSaverWindow(i) (savedScreenInfo[i].pWindow != NullWindow)
#define HasSaverWindow(pScreen) (pScreen->screensaver.pWindow != NullWindow)
extern _X_EXPORT int screenIsSaved;
extern _X_EXPORT ScreenSaverStuffRec savedScreenInfo[MAXSCREENS];
#endif /* WINDOWSTRUCT_H */

276
mi/midispcur.c
View File

@ -66,12 +66,9 @@ static DevPrivateKey miDCSpriteKey = miDCSpriteKeyIndex;
typedef struct {
GCPtr pSourceGC, pMaskGC;
GCPtr pSaveGC, pRestoreGC;
GCPtr pMoveGC;
GCPtr pPixSourceGC, pPixMaskGC;
PixmapPtr pSave, pTemp;
PixmapPtr pSave;
#ifdef ARGB_CURSOR
PicturePtr pRootPicture;
PicturePtr pTempPicture;
#endif
} miDCBufferRec, *miDCBufferPtr;
@ -408,7 +405,7 @@ miDCPutUpCursor (DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor,
}
pScreenPriv = (miDCScreenPtr)dixLookupPrivate(&pScreen->devPrivates,
miDCScreenKey);
pWin = WindowTable[pScreen->myNum];
pWin = pScreen->root;
pBuffer = MIDCBUFFER(pDev, pScreen);
#ifdef ARGB_CURSOR
@ -451,7 +448,7 @@ miDCSaveUnderCursor (DeviceIntPtr pDev, ScreenPtr pScreen,
pBuffer = MIDCBUFFER(pDev, pScreen);
pSave = pBuffer->pSave;
pWin = WindowTable[pScreen->myNum];
pWin = pScreen->root;
if (!pSave || pSave->drawable.width < w || pSave->drawable.height < h)
{
if (pSave)
@ -485,7 +482,7 @@ miDCRestoreUnderCursor (DeviceIntPtr pDev, ScreenPtr pScreen,
pBuffer = MIDCBUFFER(pDev, pScreen);
pSave = pBuffer->pSave;
pWin = WindowTable[pScreen->myNum];
pWin = pScreen->root;
if (!pSave)
return FALSE;
@ -497,244 +494,11 @@ miDCRestoreUnderCursor (DeviceIntPtr pDev, ScreenPtr pScreen,
return TRUE;
}
Bool
miDCChangeSave (DeviceIntPtr pDev, ScreenPtr pScreen,
int x, int y, int w, int h, int dx, int dy)
{
miDCScreenPtr pScreenPriv;
miDCBufferPtr pBuffer;
PixmapPtr pSave;
WindowPtr pWin;
GCPtr pGC;
int sourcex, sourcey, destx, desty, copyw, copyh;
pScreenPriv = (miDCScreenPtr)dixLookupPrivate(&pScreen->devPrivates,
miDCScreenKey);
pBuffer = MIDCBUFFER(pDev, pScreen);
pSave = pBuffer->pSave;
pWin = WindowTable[pScreen->myNum];
/*
* restore the bits which are about to get trashed
*/
if (!pSave)
return FALSE;
pGC = pBuffer->pRestoreGC;
if (pWin->drawable.serialNumber != pGC->serialNumber)
ValidateGC ((DrawablePtr) pWin, pGC);
/*
* copy the old bits to the screen.
*/
if (dy > 0)
{
(*pGC->ops->CopyArea) ((DrawablePtr) pSave, (DrawablePtr) pWin, pGC,
0, h - dy, w, dy, x + dx, y + h);
}
else if (dy < 0)
{
(*pGC->ops->CopyArea) ((DrawablePtr) pSave, (DrawablePtr) pWin, pGC,
0, 0, w, -dy, x + dx, y + dy);
}
if (dy >= 0)
{
desty = y + dy;
sourcey = 0;
copyh = h - dy;
}
else
{
desty = y;
sourcey = - dy;
copyh = h + dy;
}
if (dx > 0)
{
(*pGC->ops->CopyArea) ((DrawablePtr) pSave, (DrawablePtr) pWin, pGC,
w - dx, sourcey, dx, copyh, x + w, desty);
}
else if (dx < 0)
{
(*pGC->ops->CopyArea) ((DrawablePtr) pSave, (DrawablePtr) pWin, pGC,
0, sourcey, -dx, copyh, x + dx, desty);
}
pGC = pBuffer->pSaveGC;
if (pSave->drawable.serialNumber != pGC->serialNumber)
ValidateGC ((DrawablePtr) pSave, pGC);
/*
* move the bits that are still valid within the pixmap
*/
if (dx >= 0)
{
sourcex = 0;
destx = dx;
copyw = w - dx;
}
else
{
destx = 0;
sourcex = - dx;
copyw = w + dx;
}
if (dy >= 0)
{
sourcey = 0;
desty = dy;
copyh = h - dy;
}
else
{
desty = 0;
sourcey = -dy;
copyh = h + dy;
}
(*pGC->ops->CopyArea) ((DrawablePtr) pSave, (DrawablePtr) pSave, pGC,
sourcex, sourcey, copyw, copyh, destx, desty);
/*
* copy the new bits from the screen into the remaining areas of the
* pixmap
*/
if (dy > 0)
{
(*pGC->ops->CopyArea) ((DrawablePtr) pWin, (DrawablePtr) pSave, pGC,
x, y, w, dy, 0, 0);
}
else if (dy < 0)
{
(*pGC->ops->CopyArea) ((DrawablePtr) pWin, (DrawablePtr) pSave, pGC,
x, y + h + dy, w, -dy, 0, h + dy);
}
if (dy >= 0)
{
desty = dy;
sourcey = y + dy;
copyh = h - dy;
}
else
{
desty = 0;
sourcey = y;
copyh = h + dy;
}
if (dx > 0)
{
(*pGC->ops->CopyArea) ((DrawablePtr) pWin, (DrawablePtr) pSave, pGC,
x, sourcey, dx, copyh, 0, desty);
}
else if (dx < 0)
{
(*pGC->ops->CopyArea) ((DrawablePtr) pWin, (DrawablePtr) pSave, pGC,
x + w + dx, sourcey, -dx, copyh, w + dx, desty);
}
return TRUE;
}
Bool
miDCMoveCursor (DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor,
int x, int y, int w, int h, int dx, int dy,
unsigned long source, unsigned long mask)
{
miDCCursorPtr pPriv;
miDCScreenPtr pScreenPriv;
miDCBufferPtr pBuffer;
int status;
WindowPtr pWin;
GCPtr pGC;
XID gcval = FALSE;
PixmapPtr pTemp;
pPriv = (miDCCursorPtr)dixLookupPrivate(&pCursor->bits->devPrivates,
CursorScreenKey(pScreen));
if (!pPriv)
{
pPriv = miDCRealize(pScreen, pCursor);
if (!pPriv)
return FALSE;
}
pScreenPriv = (miDCScreenPtr)dixLookupPrivate(&pScreen->devPrivates,
miDCScreenKey);
pWin = WindowTable[pScreen->myNum];
pBuffer = MIDCBUFFER(pDev, pScreen);
pTemp = pBuffer->pTemp;
if (!pTemp ||
pTemp->drawable.width != pBuffer->pSave->drawable.width ||
pTemp->drawable.height != pBuffer->pSave->drawable.height)
{
if (pTemp)
(*pScreen->DestroyPixmap) (pTemp);
#ifdef ARGB_CURSOR
if (pBuffer->pTempPicture)
{
FreePicture (pBuffer->pTempPicture, 0);
pBuffer->pTempPicture = 0;
}
#endif
pBuffer->pTemp = pTemp = (*pScreen->CreatePixmap)
(pScreen, w, h, pBuffer->pSave->drawable.depth, 0);
if (!pTemp)
return FALSE;
}
if (!pBuffer->pMoveGC)
{
pBuffer->pMoveGC = CreateGC ((DrawablePtr)pTemp,
GCGraphicsExposures, &gcval, &status, (XID)0, serverClient);
if (!pBuffer->pMoveGC)
return FALSE;
}
/*
* copy the saved area to a temporary pixmap
*/
pGC = pBuffer->pMoveGC;
if (pGC->serialNumber != pTemp->drawable.serialNumber)
ValidateGC ((DrawablePtr) pTemp, pGC);
(*pGC->ops->CopyArea)((DrawablePtr)pBuffer->pSave,
(DrawablePtr)pTemp, pGC, 0, 0, w, h, 0, 0);
/*
* draw the cursor in the temporary pixmap
*/
#ifdef ARGB_CURSOR
if (pPriv->pPicture)
{
if (!EnsurePicture(pBuffer->pTempPicture, &pTemp->drawable, pWin))
return FALSE;
CompositePicture (PictOpOver,
pPriv->pPicture,
NULL,
pBuffer->pTempPicture,
0, 0, 0, 0,
dx, dy,
pCursor->bits->width,
pCursor->bits->height);
}
else
#endif
{
miDCPutBits ((DrawablePtr)pTemp, pPriv,
pBuffer->pPixSourceGC, pBuffer->pPixMaskGC,
dx, dy, pCursor->bits->width, pCursor->bits->height,
source, mask);
}
pGC = pBuffer->pRestoreGC;
if (pWin->drawable.serialNumber != pGC->serialNumber)
ValidateGC ((DrawablePtr) pWin, pGC);
(*pGC->ops->CopyArea) ((DrawablePtr) pTemp, (DrawablePtr) pWin,
pGC,
0, 0, w, h, x, y);
return TRUE;
}
Bool
miDCDeviceInitialize(DeviceIntPtr pDev, ScreenPtr pScreen)
{
miDCBufferPtr pBuffer;
WindowPtr pWin;
XID gcval = FALSE;
int status;
int i;
if (!DevHasCursor(pDev))
@ -749,7 +513,7 @@ miDCDeviceInitialize(DeviceIntPtr pDev, ScreenPtr pScreen)
goto failure;
dixSetPrivate(&pDev->devPrivates, miDCSpriteKey + pScreen->myNum, pBuffer);
pWin = WindowTable[pScreen->myNum];
pWin = pScreen->root;
pBuffer->pSourceGC = miDCMakeGC(pWin);
if (!pBuffer->pSourceGC)
@ -767,28 +531,12 @@ miDCDeviceInitialize(DeviceIntPtr pDev, ScreenPtr pScreen)
if (!pBuffer->pRestoreGC)
goto failure;
pBuffer->pMoveGC = CreateGC ((DrawablePtr)pWin,
GCGraphicsExposures, &gcval, &status, (XID)0, serverClient);
if (!pBuffer->pMoveGC)
goto failure;
pBuffer->pPixSourceGC = CreateGC ((DrawablePtr)pWin,
GCGraphicsExposures, &gcval, &status, (XID)0, serverClient);
if (!pBuffer->pPixSourceGC)
goto failure;
pBuffer->pPixMaskGC = CreateGC ((DrawablePtr)pWin,
GCGraphicsExposures, &gcval, &status, (XID)0, serverClient);
if (!pBuffer->pPixMaskGC)
goto failure;
#ifdef ARGB_CURSOR
pBuffer->pRootPicture = NULL;
pBuffer->pTempPicture = NULL;
#endif
// these get (re)allocated lazily depending on the cursor size
pBuffer->pSave = pBuffer->pTemp = NULL;
/* (re)allocated lazily depending on the cursor size */
pBuffer->pSave = NULL;
}
return TRUE;
@ -820,12 +568,14 @@ miDCDeviceCleanup(DeviceIntPtr pDev, ScreenPtr pScreen)
if (pBuffer->pMaskGC) FreeGC(pBuffer->pMaskGC, (GContext) 0);
if (pBuffer->pSaveGC) FreeGC(pBuffer->pSaveGC, (GContext) 0);
if (pBuffer->pRestoreGC) FreeGC(pBuffer->pRestoreGC, (GContext) 0);
if (pBuffer->pMoveGC) FreeGC(pBuffer->pMoveGC, (GContext) 0);
if (pBuffer->pPixSourceGC) FreeGC(pBuffer->pPixSourceGC, (GContext) 0);
if (pBuffer->pPixMaskGC) FreeGC(pBuffer->pPixMaskGC, (GContext) 0);
#ifdef ARGB_CURSOR
/* If a pRootPicture was allocated for a root window, it
* is freed when that root window is destroyed, so don't
* free it again here. */
#endif
if (pBuffer->pSave) (*pScreen->DestroyPixmap)(pBuffer->pSave);
if (pBuffer->pTemp) (*pScreen->DestroyPixmap)(pBuffer->pTemp);
free(pBuffer);
dixSetPrivate(&pDev->devPrivates, miDCSpriteKey + pScreen->myNum, NULL);

6
mi/miexpose.c
View File

@ -424,9 +424,9 @@ miSendExposures( WindowPtr pWin, RegionPtr pRgn, int dx, int dy)
XID realWin = 0;
if(!pWin->parent) {
x = panoramiXdataPtr[scrnum].x;
y = panoramiXdataPtr[scrnum].y;
pWin = WindowTable[0];
x = screenInfo.screens[scrnum]->x;
y = screenInfo.screens[scrnum]->y;
pWin = screenInfo.screens[0]->root;
realWin = pWin->drawable.id;
} else if (scrnum) {
PanoramiXRes *win;

6
mi/mioverlay.c
View File

@ -306,7 +306,7 @@ miOverlayReparentWindow(WindowPtr pWin, WindowPtr pPriorParent)
{
if(IN_UNDERLAY(pWin) || HasUnderlayChildren(pWin)) {
/* This could probably be more optimal */
RebuildTree(WindowTable[pWin->drawable.pScreen->myNum]->firstChild);
RebuildTree(pWin->drawable.pScreen->root->firstChild);
}
}
@ -1610,7 +1610,7 @@ miOverlayChangeBorderWidth(
void
miOverlaySetRootClip(ScreenPtr pScreen, Bool enable)
{
WindowPtr pRoot = WindowTable[pScreen->myNum];
WindowPtr pRoot = pScreen->root;
miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pRoot);
MARK_UNDERLAY(pRoot);
@ -1741,7 +1741,7 @@ miOverlayComputeCompositeClip(GCPtr pGC, WindowPtr pWin)
pregWin = REGION_CREATE(pScreen, NullBox, 1);
freeTmpClip = TRUE;
if (pWin->parent || (screenIsSaved != SCREEN_SAVER_ON) ||
!HasSaverWindow (pScreen->myNum))
!HasSaverWindow (pScreen))
{
REGION_INTERSECT(pScreen,pregWin,&pTree->borderClip,&pWin->winSize);
}

66
mi/misprite.c
View File

@ -798,74 +798,10 @@ miSpriteSetCursor (DeviceIntPtr pDev, ScreenPtr pScreen,
miSpriteFindColors (pPointer, pScreen);
}
if (pPointer->isUp) {
#if 0
/* FIXME: Disabled for MPX, should be rewritten */
int sx, sy;
/*
* check to see if the old saved region
* encloses the new sprite, in which case we use
* the flicker-free MoveCursor primitive.
*/
sx = pointer->x - (int)pCursor->bits->xhot;
sy = pointer->y - (int)pCursor->bits->yhot;
if (sx + (int) pCursor->bits->width >= pointer->saved.x1 &&
sx < pointer->saved.x2 &&
sy + (int) pCursor->bits->height >= pointer->saved.y1 &&
sy < pointer->saved.y2 &&
(int) pCursor->bits->width + (2 * SPRITE_PAD) ==
pointer->saved.x2 - pointer->saved.x1 &&
(int) pCursor->bits->height + (2 * SPRITE_PAD) ==
pointer->saved.y2 - pointer->saved.y1
)
{
DamageDrawInternal (pScreen, TRUE);
miSpriteIsDown(pCursorInfo);
if (!(sx >= pointer->saved.x1 &&
sx + (int)pCursor->bits->width < pointer->saved.x2
&& sy >= pointer->saved.y1 &&
sy + (int)pCursor->bits->height <
pointer->saved.y2))
{
int oldx1, oldy1, dx, dy;
oldx1 = pointer->saved.x1;
oldy1 = pointer->saved.y1;
dx = oldx1 - (sx - SPRITE_PAD);
dy = oldy1 - (sy - SPRITE_PAD);
pointer->saved.x1 -= dx;
pointer->saved.y1 -= dy;
pointer->saved.x2 -= dx;
pointer->saved.y2 -= dy;
(void) miDCChangeSave(pScreen,
pointer->saved.x1,
pointer->saved.y1,
pointer->saved.x2 -
pointer->saved.x1,
pointer->saved.y2 -
pointer->saved.y1,
dx, dy);
}
(void) miDCMoveCursor(pScreen, pCursor,
pointer->saved.x1,
pointer->saved.y1,
pointer->saved.x2 -
pointer->saved.x1,
pointer->saved.y2 -
pointer->saved.y1,
sx - pointer->saved.x1,
sy - pointer->saved.y1,
pointer->colors[SOURCE_COLOR].pixel,
pointer->colors[MASK_COLOR].pixel);
miSpriteIsUp(pCursorInfo);
DamageDrawInternal (pScreen, FALSE);
}
else
#endif
{
/* TODO: reimplement flicker-free MoveCursor */
SPRITE_DEBUG (("SetCursor remove %d\n", pDev->id));
miSpriteRemoveCursor (pDev, pScreen);
}
}
if (!pPointer->isUp && pPointer->pCursor)
{

7
mi/misprite.h
View File

@ -46,12 +46,5 @@ extern Bool miDCSaveUnderCursor(DeviceIntPtr pDev, ScreenPtr pScreen,
int x, int y, int w, int h);
extern Bool miDCRestoreUnderCursor(DeviceIntPtr pDev, ScreenPtr pScreen,
int x, int y, int w, int h);
extern Bool miDCMoveCursor(DeviceIntPtr pDev, ScreenPtr pScreen,
CursorPtr pCursor, int x, int y,
int w, int h, int dx, int dy,
unsigned long source, unsigned long mask);
extern Bool miDCChangeSave(DeviceIntPtr pDev, ScreenPtr pScreen,
int x, int y, int w, int h,
int dx, int dy);
extern Bool miDCDeviceInitialize(DeviceIntPtr pDev, ScreenPtr pScreen);
extern void miDCDeviceCleanup(DeviceIntPtr pDev, ScreenPtr pScreen);

4
miext/rootless/rootlessCommon.c
View File

@ -447,7 +447,7 @@ RootlessRedisplay(WindowPtr pWindow)
void
RootlessRepositionWindows(ScreenPtr pScreen)
{
WindowPtr root = WindowTable[pScreen->myNum];
WindowPtr root = pScreen->root;
WindowPtr win;
if (root != NULL) {
@ -468,7 +468,7 @@ RootlessRepositionWindows(ScreenPtr pScreen)
void
RootlessRedisplayScreen(ScreenPtr pScreen)
{
WindowPtr root = WindowTable[pScreen->myNum];
WindowPtr root = pScreen->root;
if (root != NULL) {
WindowPtr win;

2
miext/rootless/rootlessCommon.h
View File

@ -213,7 +213,7 @@ extern RegionRec rootlessHugeRoot;
// Returns TRUE if this window is a root window
#define IsRoot(pWin) \
((pWin) == WindowTable[(pWin)->drawable.pScreen->myNum])
((pWin) == (pWin)->drawable.pScreen->root)
/*

2
miext/rootless/rootlessScreen.c
View File

@ -493,7 +493,7 @@ static void expose_1 (WindowPtr pWin) {
void
RootlessScreenExpose (ScreenPtr pScreen)
{
expose_1 (WindowTable[pScreen->myNum]);
expose_1 (pScreen->root);
}

26
miext/rootless/rootlessWindow.c
View File

@ -53,9 +53,9 @@ extern Bool no_configure_window;
#ifdef ROOTLESS_GLOBAL_COORDS
#define SCREEN_TO_GLOBAL_X \
(dixScreenOrigins[pScreen->myNum].x + rootlessGlobalOffsetX)
(pScreen->x + rootlessGlobalOffsetX)
#define SCREEN_TO_GLOBAL_Y \
(dixScreenOrigins[pScreen->myNum].y + rootlessGlobalOffsetY)
(pScreen->y + rootlessGlobalOffsetY)
#else
#define SCREEN_TO_GLOBAL_X 0
#define SCREEN_TO_GLOBAL_Y 0
@ -109,8 +109,8 @@ void RootlessNativeWindowMoved (WindowPtr pWin) {
if (xp_get_window_bounds (MAKE_WINDOW_ID(winRec->wid), &bounds) != Success) return;
sx = dixScreenOrigins[pWin->drawable.pScreen->myNum].x + darwinMainScreenX;
sy = dixScreenOrigins[pWin->drawable.pScreen->myNum].y + darwinMainScreenY;
sx = pWin->drawable.pScreen->x + darwinMainScreenX;
sy = pWin->drawable.pScreen->y + darwinMainScreenY;
/* Fake up a ConfigureWindow packet to resize the window to the current bounds. */
vlist[0] = (INT16) bounds.x1 - sx;
@ -1517,7 +1517,7 @@ RootlessOrderAllWindows (void)
RL_DEBUG_MSG("RootlessOrderAllWindows() ");
for (i = 0; i < screenInfo.numScreens; i++) {
if (screenInfo.screens[i] == NULL) continue;
pWin = WindowTable[i];
pWin = screenInfo.screens[i]->root;
if (pWin == NULL) continue;
for (pWin = pWin->firstChild; pWin != NULL; pWin = pWin->nextSib) {
@ -1533,7 +1533,7 @@ void
RootlessEnableRoot (ScreenPtr pScreen)
{
WindowPtr pRoot;
pRoot = WindowTable[pScreen->myNum];
pRoot = pScreen->root;
RootlessEnsureFrame (pRoot);
(*pScreen->ClearToBackground) (pRoot, 0, 0, 0, 0, TRUE);
@ -1546,7 +1546,7 @@ RootlessDisableRoot (ScreenPtr pScreen)
WindowPtr pRoot;
RootlessWindowRec *winRec;
pRoot = WindowTable[pScreen->myNum];
pRoot = pScreen->root;
winRec = WINREC (pRoot);
if (NULL == winRec)
@ -1572,8 +1572,10 @@ RootlessHideAllWindows (void)
for (i = 0; i < screenInfo.numScreens; i++)
{
pScreen = screenInfo.screens[i];
pWin = WindowTable[i];
if (pScreen == NULL || pWin == NULL)
if (pScreen == NULL)
continue;
pWin = pScreen->root;
if (pWin == NULL)
continue;
for (pWin = pWin->firstChild; pWin != NULL; pWin = pWin->nextSib)
@ -1609,8 +1611,10 @@ RootlessShowAllWindows (void)
for (i = 0; i < screenInfo.numScreens; i++)
{
pScreen = screenInfo.screens[i];
pWin = WindowTable[i];
if (pScreen == NULL || pWin == NULL)
if (pScreen == NULL)
continue;
pWin = pScreen->root;
if (pWin == NULL)
continue;
for (pWin = pWin->firstChild; pWin != NULL; pWin = pWin->nextSib)

10
randr/rrscreen.c
View File

@ -73,7 +73,7 @@ RREditConnectionInfo (ScreenPtr pScreen)
void
RRSendConfigNotify (ScreenPtr pScreen)
{
WindowPtr pWin = WindowTable[pScreen->myNum];
WindowPtr pWin = pScreen->root;
xEvent event;
event.u.u.type = ConfigureNotify;
@ -97,7 +97,7 @@ RRDeliverScreenEvent (ClientPtr client, WindowPtr pWin, ScreenPtr pScreen)
rrScrPriv (pScreen);
xRRScreenChangeNotifyEvent se;
RRCrtcPtr crtc = pScrPriv->numCrtcs ? pScrPriv->crtcs[0] : NULL;
WindowPtr pRoot = WindowTable[pScreen->myNum];
WindowPtr pRoot = pScreen->root;
se.type = RRScreenChangeNotify + RREventBase;
se.rotation = (CARD8) (crtc ? crtc->rotation : RR_Rotate_0);
@ -620,7 +620,7 @@ ProcRRGetScreenInfo (ClientPtr client)
rep.setOfRotations = RR_Rotate_0;
rep.sequenceNumber = client->sequence;
rep.length = 0;
rep.root = WindowTable[pWin->drawable.pScreen->myNum]->drawable.id;
rep.root = pWin->drawable.pScreen->root->drawable.id;
rep.timestamp = currentTime.milliseconds;
rep.configTimestamp = currentTime.milliseconds;
rep.nSizes = 0;
@ -649,7 +649,7 @@ ProcRRGetScreenInfo (ClientPtr client)
rep.setOfRotations = output->crtc->rotations;
rep.sequenceNumber = client->sequence;
rep.length = 0;
rep.root = WindowTable[pWin->drawable.pScreen->myNum]->drawable.id;
rep.root = pWin->drawable.pScreen->root->drawable.id;
rep.timestamp = pScrPriv->lastSetTime.milliseconds;
rep.configTimestamp = pScrPriv->lastConfigTime.milliseconds;
rep.rotation = output->crtc->rotation;
@ -961,7 +961,7 @@ sendReply:
rep.newTimestamp = pScrPriv->lastSetTime.milliseconds;
rep.newConfigTimestamp = pScrPriv->lastConfigTime.milliseconds;
rep.root = WindowTable[pDraw->pScreen->myNum]->drawable.id;
rep.root = pDraw->pScreen->root->drawable.id;
if (client->swapped)
{

2
randr/rrxinerama.c
View File

@ -216,7 +216,7 @@ ProcRRXineramaGetScreenSize(ClientPtr client)
return rc;
pScreen = pWin->drawable.pScreen;
pRoot = WindowTable[pScreen->myNum];
pRoot = pScreen->root;
rep.type = X_Reply;
rep.length = 0;

9
record/record.c
View File

@ -43,6 +43,7 @@ and Jim Haggerty of Metheus.
#include "swaprep.h"
#include "inputstr.h"
#include "eventconvert.h"
#include "scrnintstr.h"
#include <stdio.h>
@ -755,11 +756,11 @@ RecordSendProtocolEvents(RecordClientsAndProtocolPtr pRCAP,
int scr = XineramaGetCursorScreen(inputInfo.pointer);
memcpy(&shiftedEvent, pev, sizeof(xEvent));
shiftedEvent.u.keyButtonPointer.rootX +=
panoramiXdataPtr[scr].x -
panoramiXdataPtr[0].x;
screenInfo.screens[scr]->x -
screenInfo.screens[0]->x;
shiftedEvent.u.keyButtonPointer.rootY +=
panoramiXdataPtr[scr].y -
panoramiXdataPtr[0].y;
screenInfo.screens[scr]->y -
screenInfo.screens[0]->y;
pEvToRecord = &shiftedEvent;
}
#endif /* PANORAMIX */

46
render/render.c
View File

@ -2681,7 +2681,7 @@ PanoramiXRenderCreatePicture (ClientPtr client)
newPict->info[0].id = stuff->pid;
if (refDraw->type == XRT_WINDOW &&
stuff->drawable == WindowTable[0]->drawable.id)
stuff->drawable == screenInfo.screens[0]->root->drawable.id)
{
newPict->u.pict.root = TRUE;
}
@ -2832,22 +2832,22 @@ PanoramiXRenderComposite (ClientPtr client)
stuff->src = src->info[j].id;
if (src->u.pict.root)
{
stuff->xSrc = orig.xSrc - panoramiXdataPtr[j].x;
stuff->ySrc = orig.ySrc - panoramiXdataPtr[j].y;
stuff->xSrc = orig.xSrc - screenInfo.screens[j]->x;
stuff->ySrc = orig.ySrc - screenInfo.screens[j]->y;
}
stuff->dst = dst->info[j].id;
if (dst->u.pict.root)
{
stuff->xDst = orig.xDst - panoramiXdataPtr[j].x;
stuff->yDst = orig.yDst - panoramiXdataPtr[j].y;
stuff->xDst = orig.xDst - screenInfo.screens[j]->x;
stuff->yDst = orig.yDst - screenInfo.screens[j]->y;
}
if (msk)
{
stuff->mask = msk->info[j].id;
if (msk->u.pict.root)
{
stuff->xMask = orig.xMask - panoramiXdataPtr[j].x;
stuff->yMask = orig.yMask - panoramiXdataPtr[j].y;
stuff->xMask = orig.xMask - screenInfo.screens[j]->x;
stuff->yMask = orig.yMask - screenInfo.screens[j]->y;
}
}
result = (*PanoramiXSaveRenderVector[X_RenderComposite]) (client);
@ -2881,14 +2881,14 @@ PanoramiXRenderCompositeGlyphs (ClientPtr client)
stuff->src = src->info[j].id;
if (src->u.pict.root)
{
stuff->xSrc = xSrc - panoramiXdataPtr[j].x;
stuff->ySrc = ySrc - panoramiXdataPtr[j].y;
stuff->xSrc = xSrc - screenInfo.screens[j]->x;
stuff->ySrc = ySrc - screenInfo.screens[j]->y;
}
stuff->dst = dst->info[j].id;
if (dst->u.pict.root)
{
elt->deltax = origElt.deltax - panoramiXdataPtr[j].x;
elt->deltay = origElt.deltay - panoramiXdataPtr[j].y;
elt->deltax = origElt.deltax - screenInfo.screens[j]->x;
elt->deltay = origElt.deltay - screenInfo.screens[j]->y;
}
result = (*PanoramiXSaveRenderVector[stuff->renderReqType]) (client);
if(result != Success) break;
@ -2918,8 +2918,8 @@ PanoramiXRenderFillRectangles (ClientPtr client)
if (j) memcpy (stuff + 1, extra, extra_len);
if (dst->u.pict.root)
{
int x_off = panoramiXdataPtr[j].x;
int y_off = panoramiXdataPtr[j].y;
int x_off = screenInfo.screens[j]->x;
int y_off = screenInfo.screens[j]->y;
if(x_off || y_off) {
xRectangle *rects = (xRectangle *) (stuff + 1);
@ -2966,8 +2966,8 @@ PanoramiXRenderTrapezoids(ClientPtr client)
FOR_NSCREENS_FORWARD(j) {
if (j) memcpy (stuff + 1, extra, extra_len);
if (dst->u.pict.root) {
int x_off = panoramiXdataPtr[j].x;
int y_off = panoramiXdataPtr[j].y;
int x_off = screenInfo.screens[j]->x;
int y_off = screenInfo.screens[j]->y;
if(x_off || y_off) {
xTrapezoid *trap = (xTrapezoid *) (stuff + 1);
@ -3026,8 +3026,8 @@ PanoramiXRenderTriangles(ClientPtr client)
FOR_NSCREENS_FORWARD(j) {
if (j) memcpy (stuff + 1, extra, extra_len);
if (dst->u.pict.root) {
int x_off = panoramiXdataPtr[j].x;
int y_off = panoramiXdataPtr[j].y;
int x_off = screenInfo.screens[j]->x;
int y_off = screenInfo.screens[j]->y;
if(x_off || y_off) {
xTriangle *tri = (xTriangle *) (stuff + 1);
@ -3082,8 +3082,8 @@ PanoramiXRenderTriStrip(ClientPtr client)
FOR_NSCREENS_FORWARD(j) {
if (j) memcpy (stuff + 1, extra, extra_len);
if (dst->u.pict.root) {
int x_off = panoramiXdataPtr[j].x;
int y_off = panoramiXdataPtr[j].y;
int x_off = screenInfo.screens[j]->x;
int y_off = screenInfo.screens[j]->y;
if(x_off || y_off) {
xPointFixed *fixed = (xPointFixed *) (stuff + 1);
@ -3134,8 +3134,8 @@ PanoramiXRenderTriFan(ClientPtr client)
FOR_NSCREENS_FORWARD(j) {
if (j) memcpy (stuff + 1, extra, extra_len);
if (dst->u.pict.root) {
int x_off = panoramiXdataPtr[j].x;
int y_off = panoramiXdataPtr[j].y;
int x_off = screenInfo.screens[j]->x;
int y_off = screenInfo.screens[j]->y;
if(x_off || y_off) {
xPointFixed *fixed = (xPointFixed *) (stuff + 1);
@ -3188,8 +3188,8 @@ PanoramiXRenderAddTraps (ClientPtr client)
if (picture->u.pict.root)
{
stuff->xOff = x_off + panoramiXdataPtr[j].x;
stuff->yOff = y_off + panoramiXdataPtr[j].y;
stuff->xOff = x_off + screenInfo.screens[j]->x;
stuff->yOff = y_off + screenInfo.screens[j]->y;
}
result = (*PanoramiXSaveRenderVector[X_RenderAddTraps]) (client);
if(result != Success) break;

2
xfixes/cursor.c
View File

@ -690,7 +690,7 @@ ReplaceCursor (CursorPtr pCursor,
}
}
/* this "knows" that WindowHasNewCursor doesn't depend on it's argument */
WindowHasNewCursor (WindowTable[0]);
WindowHasNewCursor (screenInfo.screens[0]->root);
}
static Bool

3
xkb/xkbInit.c
View File

@ -43,6 +43,7 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include "inputstr.h"
#include "opaque.h"
#include "property.h"
#include "scrnintstr.h"
#define XKBSRV_NEED_FILE_FUNCS
#include <xkbsrv.h>
#include "xkbgeom.h"
@ -210,7 +211,7 @@ char * pval;
ErrorF("[xkb] Internal Error! bad size (%d!=%d) for _XKB_RULES_NAMES\n",
out,len);
}
dixChangeWindowProperty(serverClient, WindowTable[0], name, XA_STRING, 8,
dixChangeWindowProperty(serverClient, screenInfo.screens[0]->root, name, XA_STRING, 8,
PropModeReplace, len, pval, TRUE);
free(pval);
return TRUE;