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

bug #230 Revert to Xinerama 1.1 In order to make a "quick" release it has 

been decided that the priority is to preserve the server's internal
    API/ABI so that third-party drivers that depend on symbols like
    noPanoramiXExtension, etc., would not need to be recompiled. Too bad
    gcc on Linux doesn't support ELF's weak symbols as that would have been
    a reasonable solution for preserving the ABI. N.B.: While symbols, i.e.
    functions and variables revert to the old name, I did not revert build
    names, i.e. -DXINERAMA, to the old -DPANORAMIX. There was no need, and
    it's just a build issue that has no impact on the binary output of the
    build.
This commit is contained in:
Kaleb Keithley 2004-02-25 21:47:10 +00:00
parent 14ab4ade74
commit b052486adb
37 changed files with 445 additions and 447 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
XTrap/xtrapdi.c
View File

@ -1,4 +1,4 @@
/* $XdotOrg$ */ /* $XdotOrg: xc/programs/Xserver/XTrap/xtrapdi.c,v 1.1.4.2 2003/12/18 19:29:12 kaleb Exp $ */
/* $XFree86: xc/programs/Xserver/XTrap/xtrapdi.c,v 1.7 2003/10/28 22:52:10 tsi Exp $ */ /* $XFree86: xc/programs/Xserver/XTrap/xtrapdi.c,v 1.7 2003/10/28 22:52:10 tsi Exp $ */
/***************************************************************************** /*****************************************************************************
Copyright 1987, 1988, 1989, 1990, 1991 by Digital Equipment Corp., Maynard, MA Copyright 1987, 1988, 1989, 1990, 1991 by Digital Equipment Corp., Maynard, MA
@ -78,8 +78,8 @@ CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <X11/extensions/xtrapproto.h> #include <X11/extensions/xtrapproto.h>
#include "colormapst.h" #include "colormapst.h"
#ifdef XINERAMA #ifdef XINERAMA
#include "xinerama.h" #include "panoramiX.h"
#include "xineramaSrv.h" #include "panoramiXsrv.h"
#include "cursor.h" #include "cursor.h"
#endif #endif
@ -1560,7 +1560,7 @@ void XETrapStampAndMail(xEvent *x_event)
(void)memcpy(&(data.u.event),x_event,sizeof(xEvent)); (void)memcpy(&(data.u.event),x_event,sizeof(xEvent));
#ifdef XINERAMA #ifdef XINERAMA
if (!noXineramaExtension && if (!noPanoramiXExtension &&
(data.u.event.u.u.type == MotionNotify || (data.u.event.u.u.type == MotionNotify ||
data.u.event.u.u.type == ButtonPress || data.u.event.u.u.type == ButtonPress ||
data.u.event.u.u.type == ButtonRelease || data.u.event.u.u.type == ButtonRelease ||
@ -1568,9 +1568,9 @@ void XETrapStampAndMail(xEvent *x_event)
data.u.event.u.u.type == KeyRelease)) { data.u.event.u.u.type == KeyRelease)) {
int scr = XineramaGetCursorScreen(); int scr = XineramaGetCursorScreen();
data.u.event.u.keyButtonPointer.rootX += data.u.event.u.keyButtonPointer.rootX +=
xineramaDataPtr[scr].x - xineramaDataPtr[0].x; panoramiXdataPtr[scr].x - panoramiXdataPtr[0].x;
data.u.event.u.keyButtonPointer.rootY += data.u.event.u.keyButtonPointer.rootY +=
xineramaDataPtr[scr].y - xineramaDataPtr[0].y; panoramiXdataPtr[scr].y - panoramiXdataPtr[0].y;
} }
#endif #endif

36
Xext/saver.c
View File

@ -1,4 +1,4 @@
/* $XdotOrg$ */ /* $XdotOrg: xc/programs/Xserver/Xext/saver.c,v 1.1.4.2 2003/12/18 19:29:12 kaleb Exp $ */
/* /*
* $XConsortium: saver.c,v 1.12 94/04/17 20:59:36 dpw Exp $ * $XConsortium: saver.c,v 1.12 94/04/17 20:59:36 dpw Exp $
* *
@ -48,8 +48,8 @@ in this Software without prior written authorization from the X Consortium.
#include "cursorstr.h" #include "cursorstr.h"
#include "colormapst.h" #include "colormapst.h"
#ifdef XINERAMA #ifdef XINERAMA
#include "xinerama.h" #include "panoramiX.h"
#include "xineramaSrv.h" #include "panoramiXsrv.h"
#endif #endif
@ -678,7 +678,7 @@ ScreenSaverHandle (pScreen, xstate, force)
} }
#ifdef XINERAMA #ifdef XINERAMA
if(noXineramaExtension || !pScreen->myNum) if(noPanoramiXExtension || !pScreen->myNum)
#endif #endif
SendScreenSaverNotify (pScreen, state, force); SendScreenSaverNotify (pScreen, state, force);
return ret; return ret;
@ -1196,19 +1196,19 @@ static int
ProcScreenSaverSetAttributes (ClientPtr client) ProcScreenSaverSetAttributes (ClientPtr client)
{ {
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension) { if(!noPanoramiXExtension) {
REQUEST(xScreenSaverSetAttributesReq); REQUEST(xScreenSaverSetAttributesReq);
XineramaRes *draw; PanoramiXRes *draw;
XineramaRes *backPix = NULL; PanoramiXRes *backPix = NULL;
XineramaRes *bordPix = NULL; PanoramiXRes *bordPix = NULL;
XineramaRes *cmap = NULL; PanoramiXRes *cmap = NULL;
int i, status = 0, len; int i, status = 0, len;
int pback_offset = 0, pbord_offset = 0, cmap_offset = 0; int pback_offset = 0, pbord_offset = 0, cmap_offset = 0;
XID orig_visual, tmp; XID orig_visual, tmp;
REQUEST_AT_LEAST_SIZE (xScreenSaverSetAttributesReq); REQUEST_AT_LEAST_SIZE (xScreenSaverSetAttributesReq);
if(!(draw = (XineramaRes *)SecurityLookupIDByClass( if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess))) client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
return BadDrawable; return BadDrawable;
@ -1220,7 +1220,7 @@ ProcScreenSaverSetAttributes (ClientPtr client)
pback_offset = Ones((Mask)stuff->mask & (CWBackPixmap - 1)); pback_offset = Ones((Mask)stuff->mask & (CWBackPixmap - 1));
tmp = *((CARD32 *) &stuff[1] + pback_offset); tmp = *((CARD32 *) &stuff[1] + pback_offset);
if ((tmp != None) && (tmp != ParentRelative)) { if ((tmp != None) && (tmp != ParentRelative)) {
if(!(backPix = (XineramaRes*) SecurityLookupIDByType( if(!(backPix = (PanoramiXRes*) SecurityLookupIDByType(
client, tmp, XRT_PIXMAP, SecurityReadAccess))) client, tmp, XRT_PIXMAP, SecurityReadAccess)))
return BadPixmap; return BadPixmap;
} }
@ -1230,7 +1230,7 @@ ProcScreenSaverSetAttributes (ClientPtr client)
pbord_offset = Ones((Mask)stuff->mask & (CWBorderPixmap - 1)); pbord_offset = Ones((Mask)stuff->mask & (CWBorderPixmap - 1));
tmp = *((CARD32 *) &stuff[1] + pbord_offset); tmp = *((CARD32 *) &stuff[1] + pbord_offset);
if (tmp != CopyFromParent) { if (tmp != CopyFromParent) {
if(!(bordPix = (XineramaRes*) SecurityLookupIDByType( if(!(bordPix = (PanoramiXRes*) SecurityLookupIDByType(
client, tmp, XRT_PIXMAP, SecurityReadAccess))) client, tmp, XRT_PIXMAP, SecurityReadAccess)))
return BadPixmap; return BadPixmap;
} }
@ -1240,7 +1240,7 @@ ProcScreenSaverSetAttributes (ClientPtr client)
cmap_offset = Ones((Mask)stuff->mask & (CWColormap - 1)); cmap_offset = Ones((Mask)stuff->mask & (CWColormap - 1));
tmp = *((CARD32 *) &stuff[1] + cmap_offset); tmp = *((CARD32 *) &stuff[1] + cmap_offset);
if ((tmp != CopyFromParent) && (tmp != None)) { if ((tmp != CopyFromParent) && (tmp != None)) {
if(!(cmap = (XineramaRes*) SecurityLookupIDByType( if(!(cmap = (PanoramiXRes*) SecurityLookupIDByType(
client, tmp, XRT_COLORMAP, SecurityReadAccess))) client, tmp, XRT_COLORMAP, SecurityReadAccess)))
return BadColor; return BadColor;
} }
@ -1259,7 +1259,7 @@ ProcScreenSaverSetAttributes (ClientPtr client)
if (orig_visual != CopyFromParent) if (orig_visual != CopyFromParent)
stuff->visualID = stuff->visualID =
XineramaVisualTable[(orig_visual*MAXSCREENS) + i]; PanoramiXVisualTable[(orig_visual*MAXSCREENS) + i];
status = ScreenSaverSetAttributes(client); status = ScreenSaverSetAttributes(client);
} }
@ -1275,16 +1275,16 @@ static int
ProcScreenSaverUnsetAttributes (ClientPtr client) ProcScreenSaverUnsetAttributes (ClientPtr client)
{ {
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension) { if(!noPanoramiXExtension) {
REQUEST(xScreenSaverUnsetAttributesReq); REQUEST(xScreenSaverUnsetAttributesReq);
XineramaRes *draw; PanoramiXRes *draw;
int i; int i;
if(!(draw = (XineramaRes *)SecurityLookupIDByClass( if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess))) client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
return BadDrawable; return BadDrawable;
for(i = XineramaNumScreens - 1; i > 0; i--) { for(i = PanoramiXNumScreens - 1; i > 0; i--) {
stuff->drawable = draw->info[i].id; stuff->drawable = draw->info[i].id;
ScreenSaverUnsetAttributes(client); ScreenSaverUnsetAttributes(client);
} }

34
Xext/shape.c
View File

@ -1,4 +1,4 @@
/* $XdotOrg: xc/programs/Xserver/Xext/shape.c,v 3.19 2003/11/17 22:20:26 dawes Exp $ */ /* $XdotOrg: xc/programs/Xserver/Xext/shape.c,v 1.1.4.3 2003/12/18 19:29:12 kaleb Exp $ */
/* $XFree86: xc/programs/Xserver/Xext/shape.c,v 3.19 2003/11/17 22:20:26 dawes Exp $ */ /* $XFree86: xc/programs/Xserver/Xext/shape.c,v 3.19 2003/11/17 22:20:26 dawes Exp $ */
/************************************************************ /************************************************************
@ -114,8 +114,8 @@ static DISPATCH_PROC(SProcShapeRectangles);
static DISPATCH_PROC(SProcShapeSelectInput); static DISPATCH_PROC(SProcShapeSelectInput);
#ifdef XINERAMA #ifdef XINERAMA
#include "xinerama.h" #include "panoramiX.h"
#include "xineramaSrv.h" #include "panoramiXsrv.h"
#endif #endif
#if 0 #if 0
@ -382,12 +382,12 @@ ProcXineramaShapeRectangles(
register ClientPtr client) register ClientPtr client)
{ {
REQUEST(xShapeRectanglesReq); REQUEST(xShapeRectanglesReq);
XineramaRes *win; PanoramiXRes *win;
int j, result = 0; int j, result = 0;
REQUEST_AT_LEAST_SIZE (xShapeRectanglesReq); REQUEST_AT_LEAST_SIZE (xShapeRectanglesReq);
if(!(win = (XineramaRes *)SecurityLookupIDByType( if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
client, stuff->dest, XRT_WINDOW, SecurityWriteAccess))) client, stuff->dest, XRT_WINDOW, SecurityWriteAccess)))
return BadWindow; return BadWindow;
@ -471,17 +471,17 @@ ProcXineramaShapeMask(
register ClientPtr client) register ClientPtr client)
{ {
REQUEST(xShapeMaskReq); REQUEST(xShapeMaskReq);
XineramaRes *win, *pmap; PanoramiXRes *win, *pmap;
int j, result = 0; int j, result = 0;
REQUEST_SIZE_MATCH (xShapeMaskReq); REQUEST_SIZE_MATCH (xShapeMaskReq);
if(!(win = (XineramaRes *)SecurityLookupIDByType( if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
client, stuff->dest, XRT_WINDOW, SecurityWriteAccess))) client, stuff->dest, XRT_WINDOW, SecurityWriteAccess)))
return BadWindow; return BadWindow;
if(stuff->src != None) { if(stuff->src != None) {
if(!(pmap = (XineramaRes *)SecurityLookupIDByType( if(!(pmap = (PanoramiXRes *)SecurityLookupIDByType(
client, stuff->src, XRT_PIXMAP, SecurityReadAccess))) client, stuff->src, XRT_PIXMAP, SecurityReadAccess)))
return BadPixmap; return BadPixmap;
} else } else
@ -586,16 +586,16 @@ ProcXineramaShapeCombine(
register ClientPtr client) register ClientPtr client)
{ {
REQUEST(xShapeCombineReq); REQUEST(xShapeCombineReq);
XineramaRes *win, *win2; PanoramiXRes *win, *win2;
int j, result = 0; int j, result = 0;
REQUEST_AT_LEAST_SIZE (xShapeCombineReq); REQUEST_AT_LEAST_SIZE (xShapeCombineReq);
if(!(win = (XineramaRes *)SecurityLookupIDByType( if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
client, stuff->dest, XRT_WINDOW, SecurityWriteAccess))) client, stuff->dest, XRT_WINDOW, SecurityWriteAccess)))
return BadWindow; return BadWindow;
if(!(win2 = (XineramaRes *)SecurityLookupIDByType( if(!(win2 = (PanoramiXRes *)SecurityLookupIDByType(
client, stuff->src, XRT_WINDOW, SecurityReadAccess))) client, stuff->src, XRT_WINDOW, SecurityReadAccess)))
return BadWindow; return BadWindow;
@ -655,12 +655,12 @@ ProcXineramaShapeOffset(
register ClientPtr client) register ClientPtr client)
{ {
REQUEST(xShapeOffsetReq); REQUEST(xShapeOffsetReq);
XineramaRes *win; PanoramiXRes *win;
int j, result = 0; int j, result = 0;
REQUEST_AT_LEAST_SIZE (xShapeOffsetReq); REQUEST_AT_LEAST_SIZE (xShapeOffsetReq);
if(!(win = (XineramaRes *)SecurityLookupIDByType( if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
client, stuff->dest, XRT_WINDOW, SecurityWriteAccess))) client, stuff->dest, XRT_WINDOW, SecurityWriteAccess)))
return BadWindow; return BadWindow;
@ -1066,28 +1066,28 @@ ProcShapeDispatch (client)
return ProcShapeQueryVersion (client); return ProcShapeQueryVersion (client);
case X_ShapeRectangles: case X_ShapeRectangles:
#ifdef XINERAMA #ifdef XINERAMA
if ( !noXineramaExtension ) if ( !noPanoramiXExtension )
return ProcXineramaShapeRectangles (client); return ProcXineramaShapeRectangles (client);
else else
#endif #endif
return ProcShapeRectangles (client); return ProcShapeRectangles (client);
case X_ShapeMask: case X_ShapeMask:
#ifdef XINERAMA #ifdef XINERAMA
if ( !noXineramaExtension ) if ( !noPanoramiXExtension )
return ProcXineramaShapeMask (client); return ProcXineramaShapeMask (client);
else else
#endif #endif
return ProcShapeMask (client); return ProcShapeMask (client);
case X_ShapeCombine: case X_ShapeCombine:
#ifdef XINERAMA #ifdef XINERAMA
if ( !noXineramaExtension ) if ( !noPanoramiXExtension )
return ProcXineramaShapeCombine (client); return ProcXineramaShapeCombine (client);
else else
#endif #endif
return ProcShapeCombine (client); return ProcShapeCombine (client);
case X_ShapeOffset: case X_ShapeOffset:
#ifdef XINERAMA #ifdef XINERAMA
if ( !noXineramaExtension ) if ( !noPanoramiXExtension )
return ProcXineramaShapeOffset (client); return ProcXineramaShapeOffset (client);
else else
#endif #endif

46
Xext/shm.c
View File

@ -1,4 +1,4 @@
/* $XdotOrg: xc/programs/Xserver/Xext/shm.c,v 1.1.4.3 2003/12/18 19:29:12 kaleb Exp $ */ /* $XdotOrg: xc/programs/Xserver/Xext/shm.c,v 1.1.4.4 2003/12/20 00:28:24 kaleb Exp $ */
/* $XFree86: xc/programs/Xserver/Xext/shm.c,v 3.42 2003/12/18 10:15:24 alanh Exp $ * /* $XFree86: xc/programs/Xserver/Xext/shm.c,v 3.42 2003/12/18 10:15:24 alanh Exp $ *
/************************************************************ /************************************************************
@ -64,8 +64,8 @@ in this Software without prior written authorization from The Open Group.
#endif #endif
#ifdef XINERAMA #ifdef XINERAMA
#include "xinerama.h" #include "panoramiX.h"
#include "xineramaSrv.h" #include "panoramiXsrv.h"
#endif #endif
#include "modinit.h" #include "modinit.h"
@ -566,17 +566,17 @@ static int
ProcXineramaShmPutImage(register ClientPtr client) ProcXineramaShmPutImage(register ClientPtr client)
{ {
int j, result = 0, orig_x, orig_y; int j, result = 0, orig_x, orig_y;
XineramaRes *draw, *gc; PanoramiXRes *draw, *gc;
Bool sendEvent, isRoot; Bool sendEvent, isRoot;
REQUEST(xShmPutImageReq); REQUEST(xShmPutImageReq);
REQUEST_SIZE_MATCH(xShmPutImageReq); REQUEST_SIZE_MATCH(xShmPutImageReq);
if(!(draw = (XineramaRes *)SecurityLookupIDByClass( if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess))) client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
return BadDrawable; return BadDrawable;
if(!(gc = (XineramaRes *)SecurityLookupIDByType( if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
client, stuff->gc, XRT_GC, SecurityReadAccess))) client, stuff->gc, XRT_GC, SecurityReadAccess)))
return BadGC; return BadGC;
@ -592,8 +592,8 @@ ProcXineramaShmPutImage(register ClientPtr client)
stuff->drawable = draw->info[j].id; stuff->drawable = draw->info[j].id;
stuff->gc = gc->info[j].id; stuff->gc = gc->info[j].id;
if (isRoot) { if (isRoot) {
stuff->dstX = orig_x - xineramaDataPtr[j].x; stuff->dstX = orig_x - panoramiXdataPtr[j].x;
stuff->dstY = orig_y - xineramaDataPtr[j].y; stuff->dstY = orig_y - panoramiXdataPtr[j].y;
} }
result = ProcShmPutImage(client); result = ProcShmPutImage(client);
if(result != client->noClientException) break; if(result != client->noClientException) break;
@ -604,7 +604,7 @@ ProcXineramaShmPutImage(register ClientPtr client)
static int static int
ProcXineramaShmGetImage(ClientPtr client) ProcXineramaShmGetImage(ClientPtr client)
{ {
XineramaRes *draw; PanoramiXRes *draw;
DrawablePtr drawables[MAXSCREENS]; DrawablePtr drawables[MAXSCREENS];
DrawablePtr pDraw; DrawablePtr pDraw;
xShmGetImageReply xgi; xShmGetImageReply xgi;
@ -623,7 +623,7 @@ ProcXineramaShmGetImage(ClientPtr client)
return(BadValue); return(BadValue);
} }
if(!(draw = (XineramaRes *)SecurityLookupIDByClass( if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess))) client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
return BadDrawable; return BadDrawable;
@ -646,15 +646,15 @@ ProcXineramaShmGetImage(ClientPtr client)
if(isRoot) { if(isRoot) {
if( /* check for being onscreen */ if( /* check for being onscreen */
x < 0 || x + w > XineramaPixWidth || x < 0 || x + w > PanoramiXPixWidth ||
y < 0 || y + h > XineramaPixHeight ) y < 0 || y + h > PanoramiXPixHeight )
return(BadMatch); return(BadMatch);
} else { } else {
if( /* check for being onscreen */ if( /* check for being onscreen */
xineramaDataPtr[0].x + pDraw->x + x < 0 || panoramiXdataPtr[0].x + pDraw->x + x < 0 ||
xineramaDataPtr[0].x + pDraw->x + x + w > XineramaPixWidth || panoramiXdataPtr[0].x + pDraw->x + x + w > PanoramiXPixWidth ||
xineramaDataPtr[0].y + pDraw->y + y < 0 || panoramiXdataPtr[0].y + pDraw->y + y < 0 ||
xineramaDataPtr[0].y + pDraw->y + y + h > XineramaPixHeight || panoramiXdataPtr[0].y + pDraw->y + y + h > PanoramiXPixHeight ||
/* check for being inside of border */ /* check for being inside of border */
x < - wBorderWidth((WindowPtr)pDraw) || x < - wBorderWidth((WindowPtr)pDraw) ||
x + w > wBorderWidth((WindowPtr)pDraw) + (int)pDraw->width || x + w > wBorderWidth((WindowPtr)pDraw) + (int)pDraw->width ||
@ -664,7 +664,7 @@ ProcXineramaShmGetImage(ClientPtr client)
} }
drawables[0] = pDraw; drawables[0] = pDraw;
for(i = 1; i < XineramaNumScreens; i++) for(i = 1; i < PanoramiXNumScreens; i++)
VERIFY_DRAWABLE(drawables[i], draw->info[i].id, client); VERIFY_DRAWABLE(drawables[i], draw->info[i].id, client);
xgi.visual = wVisual(((WindowPtr)pDraw)); xgi.visual = wVisual(((WindowPtr)pDraw));
@ -727,7 +727,7 @@ ProcXineramaShmCreatePixmap(
int i, j, result; int i, j, result;
ShmDescPtr shmdesc; ShmDescPtr shmdesc;
REQUEST(xShmCreatePixmapReq); REQUEST(xShmCreatePixmapReq);
XineramaRes *newPix; PanoramiXRes *newPix;
REQUEST_SIZE_MATCH(xShmCreatePixmapReq); REQUEST_SIZE_MATCH(xShmCreatePixmapReq);
client->errorValue = stuff->pid; client->errorValue = stuff->pid;
@ -755,13 +755,13 @@ CreatePmap:
PixmapBytePad(stuff->width, stuff->depth) * stuff->height, PixmapBytePad(stuff->width, stuff->depth) * stuff->height,
client); client);
if(!(newPix = (XineramaRes *) xalloc(sizeof(XineramaRes)))) if(!(newPix = (PanoramiXRes *) xalloc(sizeof(PanoramiXRes))))
return BadAlloc; return BadAlloc;
newPix->type = XRT_PIXMAP; newPix->type = XRT_PIXMAP;
newPix->u.pix.shared = TRUE; newPix->u.pix.shared = TRUE;
newPix->info[0].id = stuff->pid; newPix->info[0].id = stuff->pid;
for(j = 1; j < XineramaNumScreens; j++) for(j = 1; j < PanoramiXNumScreens; j++)
newPix->info[j].id = FakeClientID(client->index); newPix->info[j].id = FakeClientID(client->index);
result = (client->noClientException); result = (client->noClientException);
@ -1114,19 +1114,19 @@ ProcShmDispatch (client)
return ProcShmDetach(client); return ProcShmDetach(client);
case X_ShmPutImage: case X_ShmPutImage:
#ifdef XINERAMA #ifdef XINERAMA
if ( !noXineramaExtension ) if ( !noPanoramiXExtension )
return ProcXineramaShmPutImage(client); return ProcXineramaShmPutImage(client);
#endif #endif
return ProcShmPutImage(client); return ProcShmPutImage(client);
case X_ShmGetImage: case X_ShmGetImage:
#ifdef XINERAMA #ifdef XINERAMA
if ( !noXineramaExtension ) if ( !noPanoramiXExtension )
return ProcXineramaShmGetImage(client); return ProcXineramaShmGetImage(client);
#endif #endif
return ProcShmGetImage(client); return ProcShmGetImage(client);
case X_ShmCreatePixmap: case X_ShmCreatePixmap:
#ifdef XINERAMA #ifdef XINERAMA
if ( !noXineramaExtension ) if ( !noPanoramiXExtension )
return ProcXineramaShmCreatePixmap(client); return ProcXineramaShmCreatePixmap(client);
#endif #endif
return ProcShmCreatePixmap(client); return ProcShmCreatePixmap(client);

20
Xext/xtest.c
View File

@ -1,4 +1,4 @@
/* $XdotOrg: xtest.c,v 1.4 2001/02/09 02:04:33 xorgcvs Exp $ */ /* $XdotOrg: xc/programs/Xserver/Xext/xtest.c,v 1.1.4.3 2003/12/18 19:29:12 kaleb Exp $ */
/* $Xorg: xtest.c,v 1.4 2001/02/09 02:04:33 xorgcvs Exp $ */ /* $Xorg: xtest.c,v 1.4 2001/02/09 02:04:33 xorgcvs Exp $ */
/* /*
@ -65,8 +65,8 @@ extern int DeviceValuator;
#endif /* XINPUT */ #endif /* XINPUT */
#ifdef XINERAMA #ifdef XINERAMA
#include "xinerama.h" #include "panoramiX.h"
#include "xineramaSrv.h" #include "panoramiXsrv.h"
#endif #endif
static void XTestResetProc( static void XTestResetProc(
@ -392,12 +392,12 @@ ProcXTestFakeInput(client)
} }
#ifdef XINERAMA #ifdef XINERAMA
if (!noXineramaExtension) { if (!noPanoramiXExtension) {
ScreenPtr pScreen = root->drawable.pScreen; ScreenPtr pScreen = root->drawable.pScreen;
BoxRec box; BoxRec box;
int i; int i;
int x = ev->u.keyButtonPointer.rootX + xineramaDataPtr[0].x; int x = ev->u.keyButtonPointer.rootX + panoramiXdataPtr[0].x;
int y = ev->u.keyButtonPointer.rootY + xineramaDataPtr[0].y; int y = ev->u.keyButtonPointer.rootY + panoramiXdataPtr[0].y;
if (!POINT_IN_REGION(pScreen, &XineramaScreenRegions[pScreen->myNum], if (!POINT_IN_REGION(pScreen, &XineramaScreenRegions[pScreen->myNum],
x, y, &box)) { x, y, &box)) {
FOR_NSCREENS(i) { FOR_NSCREENS(i) {
@ -406,8 +406,8 @@ ProcXTestFakeInput(client)
&XineramaScreenRegions[i], &XineramaScreenRegions[i],
x, y, &box)) { x, y, &box)) {
root = WindowTable[i]; root = WindowTable[i];
x -= xineramaDataPtr[i].x; x -= panoramiXdataPtr[i].x;
y -= xineramaDataPtr[i].y; y -= panoramiXdataPtr[i].y;
ev->u.keyButtonPointer.rootX = x; ev->u.keyButtonPointer.rootX = x;
ev->u.keyButtonPointer.rootY = y; ev->u.keyButtonPointer.rootY = y;
break; break;
@ -427,9 +427,9 @@ ProcXTestFakeInput(client)
ev->u.keyButtonPointer.rootY = root->drawable.height - 1; ev->u.keyButtonPointer.rootY = root->drawable.height - 1;
#ifdef XINERAMA #ifdef XINERAMA
if ((!noXineramaExtension if ((!noPanoramiXExtension
&& root->drawable.pScreen->myNum != XineramaGetCursorScreen()) && root->drawable.pScreen->myNum != XineramaGetCursorScreen())
|| (noXineramaExtension && root != GetCurrentRootWindow())) || (noPanoramiXExtension && root != GetCurrentRootWindow()))
#else #else
if (root != GetCurrentRootWindow()) if (root != GetCurrentRootWindow())

84
Xext/xvdisp.c
View File

@ -1,4 +1,4 @@
/* $XdotOrg$ */ /* $XdotOrg: xc/programs/Xserver/Xext/xvdisp.c,v 1.1.4.2 2003/12/18 19:29:12 kaleb Exp $ */
/*********************************************************** /***********************************************************
Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts, Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts,
and the Massachusetts Institute of Technology, Cambridge, Massachusetts. and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
@ -74,8 +74,8 @@ SOFTWARE.
#include "xvdisp.h" #include "xvdisp.h"
#ifdef XINERAMA #ifdef XINERAMA
#include "xinerama.h" #include "panoramiX.h"
#include "xineramaSrv.h" #include "panoramiXsrv.h"
unsigned long XvXRTPort; unsigned long XvXRTPort;
@ -234,14 +234,14 @@ ProcXvDispatch(ClientPtr client)
case xv_QueryEncodings: return(ProcXvQueryEncodings(client)); case xv_QueryEncodings: return(ProcXvQueryEncodings(client));
case xv_PutVideo: case xv_PutVideo:
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension) if(!noPanoramiXExtension)
return(XineramaXvPutVideo(client)); return(XineramaXvPutVideo(client));
else else
#endif #endif
return(ProcXvPutVideo(client)); return(ProcXvPutVideo(client));
case xv_PutStill: case xv_PutStill:
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension) if(!noPanoramiXExtension)
return(XineramaXvPutStill(client)); return(XineramaXvPutStill(client));
else else
#endif #endif
@ -254,14 +254,14 @@ ProcXvDispatch(ClientPtr client)
case xv_SelectPortNotify: return(ProcXvSelectPortNotify(client)); case xv_SelectPortNotify: return(ProcXvSelectPortNotify(client));
case xv_StopVideo: case xv_StopVideo:
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension) if(!noPanoramiXExtension)
return(XineramaXvStopVideo(client)); return(XineramaXvStopVideo(client));
else else
#endif #endif
return(ProcXvStopVideo(client)); return(ProcXvStopVideo(client));
case xv_SetPortAttribute: case xv_SetPortAttribute:
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension) if(!noPanoramiXExtension)
return(XineramaXvSetPortAttribute(client)); return(XineramaXvSetPortAttribute(client));
else else
#endif #endif
@ -271,7 +271,7 @@ ProcXvDispatch(ClientPtr client)
case xv_QueryPortAttributes: return(ProcXvQueryPortAttributes(client)); case xv_QueryPortAttributes: return(ProcXvQueryPortAttributes(client));
case xv_PutImage: case xv_PutImage:
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension) if(!noPanoramiXExtension)
return(XineramaXvPutImage(client)); return(XineramaXvPutImage(client));
else else
#endif #endif
@ -279,7 +279,7 @@ ProcXvDispatch(ClientPtr client)
#ifdef MITSHM #ifdef MITSHM
case xv_ShmPutImage: case xv_ShmPutImage:
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension) if(!noPanoramiXExtension)
return(XineramaXvShmPutImage(client)); return(XineramaXvShmPutImage(client));
else else
#endif #endif
@ -1872,15 +1872,15 @@ static int
XineramaXvStopVideo(ClientPtr client) XineramaXvStopVideo(ClientPtr client)
{ {
int result = Success, i; int result = Success, i;
XineramaRes *draw, *port; PanoramiXRes *draw, *port;
REQUEST(xvStopVideoReq); REQUEST(xvStopVideoReq);
REQUEST_SIZE_MATCH(xvStopVideoReq); REQUEST_SIZE_MATCH(xvStopVideoReq);
if(!(draw = (XineramaRes *)SecurityLookupIDByClass( if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess))) client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
return BadDrawable; return BadDrawable;
if(!(port = (XineramaRes *)SecurityLookupIDByType( if(!(port = (PanoramiXRes *)SecurityLookupIDByType(
client, stuff->port, XvXRTPort, SecurityReadAccess))) client, stuff->port, XvXRTPort, SecurityReadAccess)))
return _XvBadPort; return _XvBadPort;
@ -1899,12 +1899,12 @@ static int
XineramaXvSetPortAttribute(ClientPtr client) XineramaXvSetPortAttribute(ClientPtr client)
{ {
REQUEST(xvSetPortAttributeReq); REQUEST(xvSetPortAttributeReq);
XineramaRes *port; PanoramiXRes *port;
int result = Success, i; int result = Success, i;
REQUEST_SIZE_MATCH(xvSetPortAttributeReq); REQUEST_SIZE_MATCH(xvSetPortAttributeReq);
if(!(port = (XineramaRes *)SecurityLookupIDByType( if(!(port = (PanoramiXRes *)SecurityLookupIDByType(
client, stuff->port, XvXRTPort, SecurityReadAccess))) client, stuff->port, XvXRTPort, SecurityReadAccess)))
return _XvBadPort; return _XvBadPort;
@ -1923,22 +1923,22 @@ static int
XineramaXvShmPutImage(ClientPtr client) XineramaXvShmPutImage(ClientPtr client)
{ {
REQUEST(xvShmPutImageReq); REQUEST(xvShmPutImageReq);
XineramaRes *draw, *gc, *port; PanoramiXRes *draw, *gc, *port;
Bool send_event = stuff->send_event; Bool send_event = stuff->send_event;
Bool isRoot; Bool isRoot;
int result = Success, i, x, y; int result = Success, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq); REQUEST_SIZE_MATCH(xvShmPutImageReq);
if(!(draw = (XineramaRes *)SecurityLookupIDByClass( if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess))) client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
return BadDrawable; return BadDrawable;
if(!(gc = (XineramaRes *)SecurityLookupIDByType( if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
client, stuff->gc, XRT_GC, SecurityReadAccess))) client, stuff->gc, XRT_GC, SecurityReadAccess)))
return BadGC; return BadGC;
if(!(port = (XineramaRes *)SecurityLookupIDByType( if(!(port = (PanoramiXRes *)SecurityLookupIDByType(
client, stuff->port, XvXRTPort, SecurityReadAccess))) client, stuff->port, XvXRTPort, SecurityReadAccess)))
return _XvBadPort; return _XvBadPort;
@ -1956,8 +1956,8 @@ XineramaXvShmPutImage(ClientPtr client)
stuff->drw_x = x; stuff->drw_x = x;
stuff->drw_y = y; stuff->drw_y = y;
if(isRoot) { if(isRoot) {
stuff->drw_x -= xineramaDataPtr[i].x; stuff->drw_x -= panoramiXdataPtr[i].x;
stuff->drw_y -= xineramaDataPtr[i].y; stuff->drw_y -= panoramiXdataPtr[i].y;
} }
stuff->send_event = (send_event && !i) ? 1 : 0; stuff->send_event = (send_event && !i) ? 1 : 0;
@ -1972,21 +1972,21 @@ static int
XineramaXvPutImage(ClientPtr client) XineramaXvPutImage(ClientPtr client)
{ {
REQUEST(xvPutImageReq); REQUEST(xvPutImageReq);
XineramaRes *draw, *gc, *port; PanoramiXRes *draw, *gc, *port;
Bool isRoot; Bool isRoot;
int result = Success, i, x, y; int result = Success, i, x, y;
REQUEST_AT_LEAST_SIZE(xvPutImageReq); REQUEST_AT_LEAST_SIZE(xvPutImageReq);
if(!(draw = (XineramaRes *)SecurityLookupIDByClass( if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess))) client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
return BadDrawable; return BadDrawable;
if(!(gc = (XineramaRes *)SecurityLookupIDByType( if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
client, stuff->gc, XRT_GC, SecurityReadAccess))) client, stuff->gc, XRT_GC, SecurityReadAccess)))
return BadGC; return BadGC;
if(!(port = (XineramaRes *)SecurityLookupIDByType( if(!(port = (PanoramiXRes *)SecurityLookupIDByType(
client, stuff->port, XvXRTPort, SecurityReadAccess))) client, stuff->port, XvXRTPort, SecurityReadAccess)))
return _XvBadPort; return _XvBadPort;
@ -2004,8 +2004,8 @@ XineramaXvPutImage(ClientPtr client)
stuff->drw_x = x; stuff->drw_x = x;
stuff->drw_y = y; stuff->drw_y = y;
if(isRoot) { if(isRoot) {
stuff->drw_x -= xineramaDataPtr[i].x; stuff->drw_x -= panoramiXdataPtr[i].x;
stuff->drw_y -= xineramaDataPtr[i].y; stuff->drw_y -= panoramiXdataPtr[i].y;
} }
result = ProcXvPutImage(client); result = ProcXvPutImage(client);
@ -2018,21 +2018,21 @@ static int
XineramaXvPutVideo(ClientPtr client) XineramaXvPutVideo(ClientPtr client)
{ {
REQUEST(xvPutImageReq); REQUEST(xvPutImageReq);
XineramaRes *draw, *gc, *port; PanoramiXRes *draw, *gc, *port;
Bool isRoot; Bool isRoot;
int result = Success, i, x, y; int result = Success, i, x, y;
REQUEST_AT_LEAST_SIZE(xvPutVideoReq); REQUEST_AT_LEAST_SIZE(xvPutVideoReq);
if(!(draw = (XineramaRes *)SecurityLookupIDByClass( if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess))) client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
return BadDrawable; return BadDrawable;
if(!(gc = (XineramaRes *)SecurityLookupIDByType( if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
client, stuff->gc, XRT_GC, SecurityReadAccess))) client, stuff->gc, XRT_GC, SecurityReadAccess)))
return BadGC; return BadGC;
if(!(port = (XineramaRes *)SecurityLookupIDByType( if(!(port = (PanoramiXRes *)SecurityLookupIDByType(
client, stuff->port, XvXRTPort, SecurityReadAccess))) client, stuff->port, XvXRTPort, SecurityReadAccess)))
return _XvBadPort; return _XvBadPort;
@ -2050,8 +2050,8 @@ XineramaXvPutVideo(ClientPtr client)
stuff->drw_x = x; stuff->drw_x = x;
stuff->drw_y = y; stuff->drw_y = y;
if(isRoot) { if(isRoot) {
stuff->drw_x -= xineramaDataPtr[i].x; stuff->drw_x -= panoramiXdataPtr[i].x;
stuff->drw_y -= xineramaDataPtr[i].y; stuff->drw_y -= panoramiXdataPtr[i].y;
} }
result = ProcXvPutVideo(client); result = ProcXvPutVideo(client);
@ -2064,21 +2064,21 @@ static int
XineramaXvPutStill(ClientPtr client) XineramaXvPutStill(ClientPtr client)
{ {
REQUEST(xvPutImageReq); REQUEST(xvPutImageReq);
XineramaRes *draw, *gc, *port; PanoramiXRes *draw, *gc, *port;
Bool isRoot; Bool isRoot;
int result = Success, i, x, y; int result = Success, i, x, y;
REQUEST_AT_LEAST_SIZE(xvPutImageReq); REQUEST_AT_LEAST_SIZE(xvPutImageReq);
if(!(draw = (XineramaRes *)SecurityLookupIDByClass( if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess))) client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
return BadDrawable; return BadDrawable;
if(!(gc = (XineramaRes *)SecurityLookupIDByType( if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
client, stuff->gc, XRT_GC, SecurityReadAccess))) client, stuff->gc, XRT_GC, SecurityReadAccess)))
return BadGC; return BadGC;
if(!(port = (XineramaRes *)SecurityLookupIDByType( if(!(port = (PanoramiXRes *)SecurityLookupIDByType(
client, stuff->port, XvXRTPort, SecurityReadAccess))) client, stuff->port, XvXRTPort, SecurityReadAccess)))
return _XvBadPort; return _XvBadPort;
@ -2096,8 +2096,8 @@ XineramaXvPutStill(ClientPtr client)
stuff->drw_x = x; stuff->drw_x = x;
stuff->drw_y = y; stuff->drw_y = y;
if(isRoot) { if(isRoot) {
stuff->drw_x -= xineramaDataPtr[i].x; stuff->drw_x -= panoramiXdataPtr[i].x;
stuff->drw_y -= xineramaDataPtr[i].y; stuff->drw_y -= panoramiXdataPtr[i].y;
} }
result = ProcXvPutStill(client); result = ProcXvPutStill(client);
@ -2115,7 +2115,7 @@ void XineramifyXv(void)
XvAttributePtr pAttr; XvAttributePtr pAttr;
XvScreenPtr xvsp; XvScreenPtr xvsp;
Bool isOverlay, hasOverlay; Bool isOverlay, hasOverlay;
XineramaRes *port; PanoramiXRes *port;
XvAdaptorPtr MatchingAdaptors[MAXSCREENS]; XvAdaptorPtr MatchingAdaptors[MAXSCREENS];
int i, j, k, l; int i, j, k, l;
@ -2141,7 +2141,7 @@ void XineramifyXv(void)
} }
} }
for(j = 1; j < XineramaNumScreens; j++) { for(j = 1; j < PanoramiXNumScreens; j++) {
pScreen = screenInfo.screens[j]; pScreen = screenInfo.screens[j];
xvsp = (XvScreenPtr)pScreen->devPrivates[XvScreenIndex].ptr; xvsp = (XvScreenPtr)pScreen->devPrivates[XvScreenIndex].ptr;
@ -2199,12 +2199,12 @@ void XineramifyXv(void)
/* now create a resource for each port */ /* now create a resource for each port */
for(j = 0; j < refAdapt->nPorts; j++) { for(j = 0; j < refAdapt->nPorts; j++) {
if(!(port = xalloc(sizeof(XineramaRes)))) if(!(port = xalloc(sizeof(PanoramiXRes))))
break; break;
port->info[0].id = MatchingAdaptors[0]->base_id + j; port->info[0].id = MatchingAdaptors[0]->base_id + j;
AddResource(port->info[0].id, XvXRTPort, port); AddResource(port->info[0].id, XvXRTPort, port);
for(k = 1; k < XineramaNumScreens; k++) { for(k = 1; k < PanoramiXNumScreens; k++) {
if(MatchingAdaptors[k] && (MatchingAdaptors[k]->nPorts > j)) if(MatchingAdaptors[k] && (MatchingAdaptors[k]->nPorts > j))
port->info[k].id = MatchingAdaptors[k]->base_id + j; port->info[k].id = MatchingAdaptors[k]->base_id + j;
else else

6
Xext/xvmain.c
View File

@ -1,4 +1,4 @@
/* $XdotOrg$ */ /* $XdotOrg: xc/programs/Xserver/Xext/xvmain.c,v 1.1.4.2 2003/12/18 19:29:12 kaleb Exp $ */
/*********************************************************** /***********************************************************
Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts, Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts,
and the Massachusetts Institute of Technology, Cambridge, Massachusetts. and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
@ -100,8 +100,8 @@ SOFTWARE.
#endif #endif
#ifdef XINERAMA #ifdef XINERAMA
#include "xinerama.h" #include "panoramiX.h"
#include "xineramaSrv.h" #include "panoramiXsrv.h"
#include "xvdisp.h" #include "xvdisp.h"
#endif #endif

20
cfb/cfbpntwin.c
View File

@ -1,4 +1,4 @@
/* $XdotOrg: cfbpntwin.c,v 1.4 2001/02/09 02:04:38 xorgcvs Exp $ */ /* $XdotOrg: xc/programs/Xserver/cfb/cfbpntwin.c,v 1.1.4.3 2003/12/18 19:29:12 kaleb Exp $ */
/* $Xorg: cfbpntwin.c,v 1.4 2001/02/09 02:04:38 xorgcvs Exp $ */ /* $Xorg: cfbpntwin.c,v 1.4 2001/02/09 02:04:38 xorgcvs Exp $ */
/*********************************************************** /***********************************************************
@ -60,9 +60,9 @@ SOFTWARE.
#include "mi.h" #include "mi.h"
#ifdef XINERAMA #ifdef XINERAMA
#include "xinerama.h" #include "panoramiX.h"
#include "xineramaSrv.h" #include "panoramiXsrv.h"
extern Bool noXineramaExtension; extern Bool noPanoramiXExtension;
extern WindowPtr *WindowTable; extern WindowPtr *WindowTable;
#endif #endif
@ -105,11 +105,11 @@ cfbPaintWindow(pWin, pRegion, what)
int yorg = pWin->drawable.y; int yorg = pWin->drawable.y;
#endif #endif
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension) { if(!noPanoramiXExtension) {
int index = pWin->drawable.pScreen->myNum; int index = pWin->drawable.pScreen->myNum;
if(WindowTable[index] == pWin) { if(WindowTable[index] == pWin) {
xorg -= xineramaDataPtr[index].x; xorg -= panoramiXdataPtr[index].x;
yorg -= xineramaDataPtr[index].y; yorg -= panoramiXdataPtr[index].y;
} }
} }
#endif #endif
@ -163,11 +163,11 @@ cfbPaintWindow(pWin, pRegion, what)
#endif #endif
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension) { if(!noPanoramiXExtension) {
int index = pWin->drawable.pScreen->myNum; int index = pWin->drawable.pScreen->myNum;
if(WindowTable[index] == pBgWin) { if(WindowTable[index] == pBgWin) {
xorg -= xineramaDataPtr[index].x; xorg -= panoramiXdataPtr[index].x;
yorg -= xineramaDataPtr[index].y; yorg -= panoramiXdataPtr[index].y;
} }
} }
#endif #endif

6
dbe/dbe.c
View File

@ -1,4 +1,4 @@
/* $XdotOrg: dbe.c,v 1.3 2000/08/17 19:48:16 cpqbld Exp $ */ /* $XdotOrg: xc/programs/Xserver/dbe/dbe.c,v 1.1.4.2 2003/12/18 19:29:12 kaleb Exp $ */
/* $Xorg: dbe.c,v 1.3 2000/08/17 19:48:16 cpqbld Exp $ */ /* $Xorg: dbe.c,v 1.3 2000/08/17 19:48:16 cpqbld Exp $ */
/****************************************************************************** /******************************************************************************
* *
@ -1822,8 +1822,8 @@ DbeExtensionInit()
Bool ddxInitSuccess; Bool ddxInitSuccess;
#ifdef XINERAMA #ifdef XINERAMA
extern Bool noXineramaExtension; extern Bool noPanoramiXExtension;
if(!noXineramaExtension) return; if(!noPanoramiXExtension) return;
#endif #endif
/* Allocate private pointers in windows and screens. */ /* Allocate private pointers in windows and screens. */

20
dix/colormap.c
View File

@ -1,4 +1,4 @@
/* $XdotOrg$ */ /* $XdotOrg: xc/programs/Xserver/dix/colormap.c,v 1.1.4.3 2003/12/18 19:29:12 kaleb Exp $ */
/* $XFree86: xc/programs/Xserver/dix/colormap.c,v 3.12 2003/11/17 22:20:33 dawes Exp $ */ /* $XFree86: xc/programs/Xserver/dix/colormap.c,v 3.12 2003/11/17 22:20:33 dawes Exp $ */
/*********************************************************** /***********************************************************
@ -63,9 +63,9 @@ SOFTWARE.
#include "lbxserve.h" #include "lbxserve.h"
#endif #endif
#ifdef XINERAMA #ifdef XINERAMA
#include "xinerama.h" #include "panoramiX.h"
#include "xineramaSrv.h" #include "panoramiXsrv.h"
extern Bool noXineramaExtension; extern Bool noPanoramiXExtension;
#endif #endif
extern XID clientErrorValue; extern XID clientErrorValue;
@ -484,8 +484,8 @@ TellNoMap (pwin, pmid)
/* /*
* Only deliver event for Screen 0 when Xinerama enabled * Only deliver event for Screen 0 when Xinerama enabled
*/ */
if (noXineramaExtension || if (noPanoramiXExtension ||
(!noXineramaExtension && !(pwin->drawable.pScreen->myNum))) { (!noPanoramiXExtension && !(pwin->drawable.pScreen->myNum))) {
#endif #endif
/* This should be call to DeliverEvent */ /* This should be call to DeliverEvent */
xE.u.u.type = ColormapNotify; xE.u.u.type = ColormapNotify;
@ -519,8 +519,8 @@ TellLostMap (pwin, value)
/* /*
* Only deliver event for Screen 0 when Xinerama enabled * Only deliver event for Screen 0 when Xinerama enabled
*/ */
if (noXineramaExtension || if (noPanoramiXExtension ||
(!noXineramaExtension && !(pwin->drawable.pScreen->myNum))) (!noPanoramiXExtension && !(pwin->drawable.pScreen->myNum)))
#endif #endif
if (wColormap(pwin) == *pmid) if (wColormap(pwin) == *pmid)
{ {
@ -549,8 +549,8 @@ TellGainedMap (pwin, value)
/* /*
* Only deliver event for Screen 0 when Xinerama enabled * Only deliver event for Screen 0 when Xinerama enabled
*/ */
if (noXineramaExtension || if (noPanoramiXExtension ||
(!noXineramaExtension && !(pwin->drawable.pScreen->myNum))) (!noPanoramiXExtension && !(pwin->drawable.pScreen->myNum)))
#endif #endif
if (wColormap (pwin) == *pmid) if (wColormap (pwin) == *pmid)
{ {

16
dix/dispatch.c
View File

@ -1,4 +1,4 @@
/* $XdotOrg: dispatch.c,v 1.5 2001/02/09 02:04:40 xorgcvs Exp $ */ /* $XdotOrg: xc/programs/Xserver/dix/dispatch.c,v 1.1.4.3 2003/12/18 19:29:12 kaleb Exp $ */
/* $Xorg: dispatch.c,v 1.5 2001/02/09 02:04:40 xorgcvs Exp $ */ /* $Xorg: dispatch.c,v 1.5 2001/02/09 02:04:40 xorgcvs Exp $ */
/************************************************************ /************************************************************
@ -93,8 +93,8 @@ int ProcInitialConnection();
#include "swaprep.h" #include "swaprep.h"
#include "swapreq.h" #include "swapreq.h"
#ifdef XINERAMA #ifdef XINERAMA
#include "xinerama.h" #include "panoramiX.h"
#include "xineramaSrv.h" #include "panoramiXsrv.h"
#endif #endif
#ifdef XCSECURITY #ifdef XCSECURITY
#define _SECURITY_SERVER #define _SECURITY_SERVER
@ -2643,7 +2643,7 @@ ProcAllocColor(client)
return (retval); return (retval);
} }
#ifdef XINERAMA #ifdef XINERAMA
if (noXineramaExtension || !pmap->pScreen->myNum) if (noPanoramiXExtension || !pmap->pScreen->myNum)
#endif #endif
WriteReplyToClient(client, sizeof(xAllocColorReply), &acr); WriteReplyToClient(client, sizeof(xAllocColorReply), &acr);
return (client->noClientException); return (client->noClientException);
@ -2702,7 +2702,7 @@ ProcAllocNamedColor (client)
return(retval); return(retval);
} }
#ifdef XINERAMA #ifdef XINERAMA
if (noXineramaExtension || !pcmp->pScreen->myNum) if (noPanoramiXExtension || !pcmp->pScreen->myNum)
#endif #endif
WriteReplyToClient(client, sizeof (xAllocNamedColorReply), &ancr); WriteReplyToClient(client, sizeof (xAllocNamedColorReply), &ancr);
return (client->noClientException); return (client->noClientException);
@ -2772,7 +2772,7 @@ ProcAllocColorCells (client)
return(retval); return(retval);
} }
#ifdef XINERAMA #ifdef XINERAMA
if (noXineramaExtension || !pcmp->pScreen->myNum) if (noPanoramiXExtension || !pcmp->pScreen->myNum)
#endif #endif
{ {
accr.type = X_Reply; accr.type = X_Reply;
@ -2851,7 +2851,7 @@ ProcAllocColorPlanes(client)
} }
acpr.length = length >> 2; acpr.length = length >> 2;
#ifdef XINERAMA #ifdef XINERAMA
if (noXineramaExtension || !pcmp->pScreen->myNum) if (noPanoramiXExtension || !pcmp->pScreen->myNum)
#endif #endif
{ {
WriteReplyToClient(client, sizeof(xAllocColorPlanesReply), &acpr); WriteReplyToClient(client, sizeof(xAllocColorPlanesReply), &acpr);
@ -3934,7 +3934,7 @@ SendConnSetup(client, reason)
/* fill in the "currentInputMask" */ /* fill in the "currentInputMask" */
root = (xWindowRoot *)(lConnectionInfo + connBlockScreenStart); root = (xWindowRoot *)(lConnectionInfo + connBlockScreenStart);
#ifdef XINERAMA #ifdef XINERAMA
if (noXineramaExtension) if (noPanoramiXExtension)
numScreens = screenInfo.numScreens; numScreens = screenInfo.numScreens;
else else
numScreens = ((xConnSetup *)ConnectionInfo)->numRoots; numScreens = ((xConnSetup *)ConnectionInfo)->numRoots;

7
dix/dixfonts.c
View File

@ -1,4 +1,4 @@
/* $XdotOrg: xc/programs/Xserver/dix/dixfonts.c,v 3.29 2003/11/17 22:20:34 dawes Exp $ */ /* $XdotOrg: xc/programs/Xserver/dix/dixfonts.c,v 1.1.4.3 2003/12/18 19:29:12 kaleb Exp $ */
/* $XFree86: xc/programs/Xserver/dix/dixfonts.c,v 3.29 2003/11/17 22:20:34 dawes Exp $ */ /* $XFree86: xc/programs/Xserver/dix/dixfonts.c,v 3.29 2003/11/17 22:20:34 dawes Exp $ */
/************************************************************************ /************************************************************************
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts. Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
@ -43,8 +43,7 @@ SOFTWARE.
#endif #endif
#ifdef XINERAMA #ifdef XINERAMA
#include "xinerama.h" #include "panoramiX.h"
extern Bool noXineramaExtension;
#endif #endif
#ifdef LBX #ifdef LBX
@ -1401,7 +1400,7 @@ bail:
if (c->err != Success) err = c->err; if (c->err != Success) err = c->err;
if (err != Success && c->client != serverClient) { if (err != Success && c->client != serverClient) {
#ifdef XINERAMA #ifdef XINERAMA
if (noXineramaExtension || !c->pGC->pScreen->myNum) if (noPanoramiXExtension || !c->pGC->pScreen->myNum)
#endif #endif
SendErrorToClient(c->client, c->reqType, 0, 0, err); SendErrorToClient(c->client, c->reqType, 0, 0, err);
} }

202
dix/events.c
View File

@ -83,8 +83,8 @@ SOFTWARE.
#include "dixstruct.h" #include "dixstruct.h"
#ifdef XINERAMA #ifdef XINERAMA
#include "xinerama.h" #include "panoramiX.h"
#include "xineramaSrv.h" #include "panoramiXsrv.h"
#endif #endif
#include "globals.h" #include "globals.h"
@ -282,8 +282,8 @@ XineramaSetCursorPosition(
that screen are. */ that screen are. */
pScreen = sprite.screen; pScreen = sprite.screen;
x += xineramaDataPtr[0].x; x += panoramiXdataPtr[0].x;
y += xineramaDataPtr[0].y; y += panoramiXdataPtr[0].y;
if(!POINT_IN_REGION(pScreen, &XineramaScreenRegions[pScreen->myNum], if(!POINT_IN_REGION(pScreen, &XineramaScreenRegions[pScreen->myNum],
x, y, &box)) x, y, &box))
@ -301,10 +301,10 @@ XineramaSetCursorPosition(
} }
sprite.screen = pScreen; sprite.screen = pScreen;
sprite.hotPhys.x = x - xineramaDataPtr[0].x; sprite.hotPhys.x = x - panoramiXdataPtr[0].x;
sprite.hotPhys.y = y - xineramaDataPtr[0].y; sprite.hotPhys.y = y - panoramiXdataPtr[0].y;
x -= xineramaDataPtr[pScreen->myNum].x; x -= panoramiXdataPtr[pScreen->myNum].x;
y -= xineramaDataPtr[pScreen->myNum].y; y -= panoramiXdataPtr[pScreen->myNum].y;
return (*pScreen->SetCursorPosition)(pScreen, x, y, generateEvent); return (*pScreen->SetCursorPosition)(pScreen, x, y, generateEvent);
} }
@ -318,10 +318,10 @@ XineramaConstrainCursor(void)
/* Translate the constraining box to the screen /* Translate the constraining box to the screen
the sprite is actually on */ the sprite is actually on */
newBox.x1 += xineramaDataPtr[0].x - xineramaDataPtr[pScreen->myNum].x; newBox.x1 += panoramiXdataPtr[0].x - panoramiXdataPtr[pScreen->myNum].x;
newBox.x2 += xineramaDataPtr[0].x - xineramaDataPtr[pScreen->myNum].x; newBox.x2 += panoramiXdataPtr[0].x - panoramiXdataPtr[pScreen->myNum].x;
newBox.y1 += xineramaDataPtr[0].y - xineramaDataPtr[pScreen->myNum].y; newBox.y1 += panoramiXdataPtr[0].y - panoramiXdataPtr[pScreen->myNum].y;
newBox.y2 += xineramaDataPtr[0].y - xineramaDataPtr[pScreen->myNum].y; newBox.y2 += panoramiXdataPtr[0].y - panoramiXdataPtr[pScreen->myNum].y;
(* pScreen->ConstrainCursor)(pScreen, &newBox); (* pScreen->ConstrainCursor)(pScreen, &newBox);
} }
@ -378,17 +378,17 @@ XineramaSetWindowPntrs(WindowPtr pWin)
{ {
if(pWin == WindowTable[0]) { if(pWin == WindowTable[0]) {
memcpy(sprite.windows, WindowTable, memcpy(sprite.windows, WindowTable,
XineramaNumScreens*sizeof(WindowPtr)); PanoramiXNumScreens*sizeof(WindowPtr));
} else { } else {
XineramaRes *win; PanoramiXRes *win;
int i; int i;
win = (XineramaRes*)LookupIDByType(pWin->drawable.id, XRT_WINDOW); win = (PanoramiXRes*)LookupIDByType(pWin->drawable.id, XRT_WINDOW);
if(!win) if(!win)
return FALSE; return FALSE;
for(i = 0; i < XineramaNumScreens; i++) { for(i = 0; i < PanoramiXNumScreens; i++) {
sprite.windows[i] = LookupIDByType(win->info[i].id, RT_WINDOW); sprite.windows[i] = LookupIDByType(win->info[i].id, RT_WINDOW);
if(!sprite.windows[i]) /* window is being unmapped */ if(!sprite.windows[i]) /* window is being unmapped */
return FALSE; return FALSE;
@ -419,16 +419,16 @@ XineramaCheckVirtualMotion(
if(!XineramaSetWindowPntrs(pWin)) if(!XineramaSetWindowPntrs(pWin))
return; return;
i = XineramaNumScreens - 1; i = PanoramiXNumScreens - 1;
REGION_COPY(sprite.screen, &sprite.Reg2, REGION_COPY(sprite.screen, &sprite.Reg2,
&sprite.windows[i]->borderSize); &sprite.windows[i]->borderSize);
off_x = xineramaDataPtr[i].x; off_x = panoramiXdataPtr[i].x;
off_y = xineramaDataPtr[i].y; off_y = panoramiXdataPtr[i].y;
while(i--) { while(i--) {
x = off_x - xineramaDataPtr[i].x; x = off_x - panoramiXdataPtr[i].x;
y = off_y - xineramaDataPtr[i].y; y = off_y - panoramiXdataPtr[i].y;
if(x || y) if(x || y)
REGION_TRANSLATE(sprite.screen, &sprite.Reg2, x, y); REGION_TRANSLATE(sprite.screen, &sprite.Reg2, x, y);
@ -436,8 +436,8 @@ XineramaCheckVirtualMotion(
REGION_UNION(sprite.screen, &sprite.Reg2, &sprite.Reg2, REGION_UNION(sprite.screen, &sprite.Reg2, &sprite.Reg2,
&sprite.windows[i]->borderSize); &sprite.windows[i]->borderSize);
off_x = xineramaDataPtr[i].x; off_x = panoramiXdataPtr[i].x;
off_y = xineramaDataPtr[i].y; off_y = panoramiXdataPtr[i].y;
} }
lims = *REGION_EXTENTS(sprite.screen, &sprite.Reg2); lims = *REGION_EXTENTS(sprite.screen, &sprite.Reg2);
@ -474,10 +474,10 @@ XineramaCheckMotion(xEvent *xE)
/* Motion events entering DIX get translated to Screen 0 /* Motion events entering DIX get translated to Screen 0
coordinates. Replayed events have already been coordinates. Replayed events have already been
translated since they've entered DIX before */ translated since they've entered DIX before */
XE_KBPTR.rootX += xineramaDataPtr[sprite.screen->myNum].x - XE_KBPTR.rootX += panoramiXdataPtr[sprite.screen->myNum].x -
xineramaDataPtr[0].x; panoramiXdataPtr[0].x;
XE_KBPTR.rootY += xineramaDataPtr[sprite.screen->myNum].y - XE_KBPTR.rootY += panoramiXdataPtr[sprite.screen->myNum].y -
xineramaDataPtr[0].y; panoramiXdataPtr[0].y;
sprite.hot.x = XE_KBPTR.rootX; sprite.hot.x = XE_KBPTR.rootX;
sprite.hot.y = XE_KBPTR.rootY; sprite.hot.y = XE_KBPTR.rootY;
@ -536,16 +536,16 @@ XineramaConfineCursorToWindow(WindowPtr pWin, Bool generateEvents)
if(!XineramaSetWindowPntrs(pWin)) if(!XineramaSetWindowPntrs(pWin))
return; return;
i = XineramaNumScreens - 1; i = PanoramiXNumScreens - 1;
REGION_COPY(sprite.screen, &sprite.Reg1, REGION_COPY(sprite.screen, &sprite.Reg1,
&sprite.windows[i]->borderSize); &sprite.windows[i]->borderSize);
off_x = xineramaDataPtr[i].x; off_x = panoramiXdataPtr[i].x;
off_y = xineramaDataPtr[i].y; off_y = panoramiXdataPtr[i].y;
while(i--) { while(i--) {
x = off_x - xineramaDataPtr[i].x; x = off_x - panoramiXdataPtr[i].x;
y = off_y - xineramaDataPtr[i].y; y = off_y - panoramiXdataPtr[i].y;
if(x || y) if(x || y)
REGION_TRANSLATE(sprite.screen, &sprite.Reg1, x, y); REGION_TRANSLATE(sprite.screen, &sprite.Reg1, x, y);
@ -553,8 +553,8 @@ XineramaConfineCursorToWindow(WindowPtr pWin, Bool generateEvents)
REGION_UNION(sprite.screen, &sprite.Reg1, &sprite.Reg1, REGION_UNION(sprite.screen, &sprite.Reg1, &sprite.Reg1,
&sprite.windows[i]->borderSize); &sprite.windows[i]->borderSize);
off_x = xineramaDataPtr[i].x; off_x = panoramiXdataPtr[i].x;
off_y = xineramaDataPtr[i].y; off_y = panoramiXdataPtr[i].y;
} }
sprite.hotLimits = *REGION_EXTENTS(sprite.screen, &sprite.Reg1); sprite.hotLimits = *REGION_EXTENTS(sprite.screen, &sprite.Reg1);
@ -616,9 +616,9 @@ SyntheticMotion(int x, int y)
/* Translate back to the sprite screen since processInputProc /* Translate back to the sprite screen since processInputProc
will translate from sprite screen to screen 0 upon reentry will translate from sprite screen to screen 0 upon reentry
to the DIX layer */ to the DIX layer */
if(!noXineramaExtension) { if(!noPanoramiXExtension) {
x += xineramaDataPtr[0].x - xineramaDataPtr[sprite.screen->myNum].x; x += panoramiXdataPtr[0].x - panoramiXdataPtr[sprite.screen->myNum].x;
y += xineramaDataPtr[0].y - xineramaDataPtr[sprite.screen->myNum].y; y += panoramiXdataPtr[0].y - panoramiXdataPtr[sprite.screen->myNum].y;
} }
#endif #endif
xE.u.keyButtonPointer.rootX = x; xE.u.keyButtonPointer.rootX = x;
@ -721,7 +721,7 @@ CheckVirtualMotion(
{ {
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension) { if(!noPanoramiXExtension) {
XineramaCheckVirtualMotion(qe, pWin); XineramaCheckVirtualMotion(qe, pWin);
return; return;
} }
@ -772,7 +772,7 @@ ConfineCursorToWindow(WindowPtr pWin, Bool generateEvents, Bool confineToScreen)
ScreenPtr pScreen = pWin->drawable.pScreen; ScreenPtr pScreen = pWin->drawable.pScreen;
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension) { if(!noPanoramiXExtension) {
XineramaConfineCursorToWindow(pWin, generateEvents); XineramaConfineCursorToWindow(pWin, generateEvents);
return; return;
} }
@ -805,7 +805,7 @@ static void
ChangeToCursor(CursorPtr cursor) ChangeToCursor(CursorPtr cursor)
{ {
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension) { if(!noPanoramiXExtension) {
XineramaChangeToCursor(cursor); XineramaChangeToCursor(cursor);
return; return;
} }
@ -893,7 +893,7 @@ GetSpritePosition(px, py)
int int
XineramaGetCursorScreen() XineramaGetCursorScreen()
{ {
if(!noXineramaExtension) { if(!noPanoramiXExtension) {
return sprite.screen->myNum; return sprite.screen->myNum;
} else { } else {
return 0; return 0;
@ -975,11 +975,11 @@ EnqueueEvent(xE, device, count)
if (xE->u.u.type == MotionNotify) if (xE->u.u.type == MotionNotify)
{ {
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension) { if(!noPanoramiXExtension) {
XE_KBPTR.rootX += xineramaDataPtr[sprite.screen->myNum].x - XE_KBPTR.rootX += panoramiXdataPtr[sprite.screen->myNum].x -
xineramaDataPtr[0].x; panoramiXdataPtr[0].x;
XE_KBPTR.rootY += xineramaDataPtr[sprite.screen->myNum].y - XE_KBPTR.rootY += panoramiXdataPtr[sprite.screen->myNum].y -
xineramaDataPtr[0].y; panoramiXdataPtr[0].y;
} }
#endif #endif
sprite.hotPhys.x = XE_KBPTR.rootX; sprite.hotPhys.x = XE_KBPTR.rootX;
@ -1034,13 +1034,13 @@ PlayReleasedEvents(void)
/* Translate back to the sprite screen since processInputProc /* Translate back to the sprite screen since processInputProc
will translate from sprite screen to screen 0 upon reentry will translate from sprite screen to screen 0 upon reentry
to the DIX layer */ to the DIX layer */
if(!noXineramaExtension) { if(!noPanoramiXExtension) {
qe->event->u.keyButtonPointer.rootX += qe->event->u.keyButtonPointer.rootX +=
xineramaDataPtr[0].x - panoramiXdataPtr[0].x -
xineramaDataPtr[sprite.screen->myNum].x; panoramiXdataPtr[sprite.screen->myNum].x;
qe->event->u.keyButtonPointer.rootY += qe->event->u.keyButtonPointer.rootY +=
xineramaDataPtr[0].y - panoramiXdataPtr[0].y -
xineramaDataPtr[sprite.screen->myNum].y; panoramiXdataPtr[sprite.screen->myNum].y;
} }
#endif #endif
(*qe->device->public.processInputProc)(qe->event, qe->device, (*qe->device->public.processInputProc)(qe->event, qe->device,
@ -1706,7 +1706,7 @@ MaybeDeliverEventsToClient(pWin, pEvents, count, filter, dontClient)
if (wClient(pWin) == dontClient) if (wClient(pWin) == dontClient)
return 0; return 0;
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension && pWin->drawable.pScreen->myNum) if(!noPanoramiXExtension && pWin->drawable.pScreen->myNum)
return XineramaTryClientEventsResult( return XineramaTryClientEventsResult(
wClient(pWin), NullGrab, pWin->eventMask, filter); wClient(pWin), NullGrab, pWin->eventMask, filter);
#endif #endif
@ -1720,7 +1720,7 @@ MaybeDeliverEventsToClient(pWin, pEvents, count, filter, dontClient)
if (SameClient(other, dontClient)) if (SameClient(other, dontClient))
return 0; return 0;
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension && pWin->drawable.pScreen->myNum) if(!noPanoramiXExtension && pWin->drawable.pScreen->myNum)
return XineramaTryClientEventsResult( return XineramaTryClientEventsResult(
rClient(other), NullGrab, other->mask, filter); rClient(other), NullGrab, other->mask, filter);
#endif #endif
@ -1863,7 +1863,7 @@ DeliverEvents(pWin, xE, count, otherParent)
int deliveries; int deliveries;
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension && pWin->drawable.pScreen->myNum) if(!noPanoramiXExtension && pWin->drawable.pScreen->myNum)
return count; return count;
#endif #endif
@ -1903,14 +1903,14 @@ PointInBorderSize(WindowPtr pWin, int x, int y)
return TRUE; return TRUE;
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension && XineramaSetWindowPntrs(pWin)) { if(!noPanoramiXExtension && XineramaSetWindowPntrs(pWin)) {
int i; int i;
for(i = 1; i < XineramaNumScreens; i++) { for(i = 1; i < PanoramiXNumScreens; i++) {
if(POINT_IN_REGION(sprite.screen, if(POINT_IN_REGION(sprite.screen,
&sprite.windows[i]->borderSize, &sprite.windows[i]->borderSize,
x + xineramaDataPtr[0].x - xineramaDataPtr[i].x, x + panoramiXdataPtr[0].x - panoramiXdataPtr[i].x,
y + xineramaDataPtr[0].y - xineramaDataPtr[i].y, y + panoramiXdataPtr[0].y - panoramiXdataPtr[i].y,
&box)) &box))
return TRUE; return TRUE;
} }
@ -1974,7 +1974,7 @@ CheckMotion(xEvent *xE)
WindowPtr prevSpriteWin = sprite.win; WindowPtr prevSpriteWin = sprite.win;
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension) if(!noPanoramiXExtension)
return XineramaCheckMotion(xE); return XineramaCheckMotion(xE);
#endif #endif
@ -2063,11 +2063,11 @@ DefineInitialRootWindow(win)
(*pScreen->DisplayCursor) (pScreen, sprite.current); (*pScreen->DisplayCursor) (pScreen, sprite.current);
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension) { if(!noPanoramiXExtension) {
sprite.hotLimits.x1 = -xineramaDataPtr[0].x; sprite.hotLimits.x1 = -panoramiXdataPtr[0].x;
sprite.hotLimits.y1 = -xineramaDataPtr[0].y; sprite.hotLimits.y1 = -panoramiXdataPtr[0].y;
sprite.hotLimits.x2 = XineramaPixWidth - xineramaDataPtr[0].x; sprite.hotLimits.x2 = PanoramiXPixWidth - panoramiXdataPtr[0].x;
sprite.hotLimits.y2 = XineramaPixHeight - xineramaDataPtr[0].y; sprite.hotLimits.y2 = PanoramiXPixHeight - panoramiXdataPtr[0].y;
sprite.physLimits = sprite.hotLimits; sprite.physLimits = sprite.hotLimits;
sprite.confineWin = NullWindow; sprite.confineWin = NullWindow;
#ifdef SHAPE #ifdef SHAPE
@ -2104,11 +2104,11 @@ NewCurrentScreen(newScreen, x, y)
sprite.hotPhys.x = x; sprite.hotPhys.x = x;
sprite.hotPhys.y = y; sprite.hotPhys.y = y;
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension) { if(!noPanoramiXExtension) {
sprite.hotPhys.x += xineramaDataPtr[newScreen->myNum].x - sprite.hotPhys.x += panoramiXdataPtr[newScreen->myNum].x -
xineramaDataPtr[0].x; panoramiXdataPtr[0].x;
sprite.hotPhys.y += xineramaDataPtr[newScreen->myNum].y - sprite.hotPhys.y += panoramiXdataPtr[newScreen->myNum].y -
xineramaDataPtr[0].y; panoramiXdataPtr[0].y;
if (newScreen != sprite.screen) { if (newScreen != sprite.screen) {
sprite.screen = newScreen; sprite.screen = newScreen;
/* Make sure we tell the DDX to update its copy of the screen */ /* Make sure we tell the DDX to update its copy of the screen */
@ -2120,10 +2120,10 @@ NewCurrentScreen(newScreen, x, y)
told of the pointer warp so we reposition it here */ told of the pointer warp so we reposition it here */
if(!syncEvents.playingEvents) if(!syncEvents.playingEvents)
(*sprite.screen->SetCursorPosition)(sprite.screen, (*sprite.screen->SetCursorPosition)(sprite.screen,
sprite.hotPhys.x + xineramaDataPtr[0].x - sprite.hotPhys.x + panoramiXdataPtr[0].x -
xineramaDataPtr[sprite.screen->myNum].x, panoramiXdataPtr[sprite.screen->myNum].x,
sprite.hotPhys.y + xineramaDataPtr[0].y - sprite.hotPhys.y + panoramiXdataPtr[0].y -
xineramaDataPtr[sprite.screen->myNum].y, FALSE); panoramiXdataPtr[sprite.screen->myNum].y, FALSE);
} }
} else } else
#endif #endif
@ -2151,14 +2151,14 @@ XineramaPointInWindowIsVisible(
if(!XineramaSetWindowPntrs(pWin)) return FALSE; if(!XineramaSetWindowPntrs(pWin)) return FALSE;
xoff = x + xineramaDataPtr[0].x; xoff = x + panoramiXdataPtr[0].x;
yoff = y + xineramaDataPtr[0].y; yoff = y + panoramiXdataPtr[0].y;
for(i = 1; i < XineramaNumScreens; i++) { for(i = 1; i < PanoramiXNumScreens; i++) {
pWin = sprite.windows[i]; pWin = sprite.windows[i];
pScreen = pWin->drawable.pScreen; pScreen = pWin->drawable.pScreen;
x = xoff - xineramaDataPtr[i].x; x = xoff - panoramiXdataPtr[i].x;
y = yoff - xineramaDataPtr[i].y; y = yoff - panoramiXdataPtr[i].y;
if(POINT_IN_REGION(pScreen, &pWin->borderClip, x, y, &box)) if(POINT_IN_REGION(pScreen, &pWin->borderClip, x, y, &box))
return TRUE; return TRUE;
@ -2198,8 +2198,8 @@ XineramaWarpPointer(ClientPtr client)
winX = source->drawable.x; winX = source->drawable.x;
winY = source->drawable.y; winY = source->drawable.y;
if(source == WindowTable[0]) { if(source == WindowTable[0]) {
winX -= xineramaDataPtr[0].x; winX -= panoramiXdataPtr[0].x;
winY -= xineramaDataPtr[0].y; winY -= panoramiXdataPtr[0].y;
} }
if (x < winX + stuff->srcX || if (x < winX + stuff->srcX ||
y < winY + stuff->srcY || y < winY + stuff->srcY ||
@ -2214,8 +2214,8 @@ XineramaWarpPointer(ClientPtr client)
x = dest->drawable.x; x = dest->drawable.x;
y = dest->drawable.y; y = dest->drawable.y;
if(dest == WindowTable[0]) { if(dest == WindowTable[0]) {
x -= xineramaDataPtr[0].x; x -= panoramiXdataPtr[0].x;
y -= xineramaDataPtr[0].y; y -= panoramiXdataPtr[0].y;
} }
} }
@ -2254,7 +2254,7 @@ ProcWarpPointer(client)
REQUEST_SIZE_MATCH(xWarpPointerReq); REQUEST_SIZE_MATCH(xWarpPointerReq);
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension) if(!noPanoramiXExtension)
return XineramaWarpPointer(client); return XineramaWarpPointer(client);
#endif #endif
@ -2339,10 +2339,10 @@ BorderSizeNotEmpty(WindowPtr pWin)
return TRUE; return TRUE;
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension && XineramaSetWindowPntrs(pWin)) { if(!noPanoramiXExtension && XineramaSetWindowPntrs(pWin)) {
int i; int i;
for(i = 1; i < XineramaNumScreens; i++) { for(i = 1; i < PanoramiXNumScreens; i++) {
if(REGION_NOTEMPTY(sprite.screen, &sprite.windows[i]->borderSize)) if(REGION_NOTEMPTY(sprite.screen, &sprite.windows[i]->borderSize))
return TRUE; return TRUE;
} }
@ -3354,7 +3354,7 @@ DoFocusEvents(dev, fromWin, toWin, mode)
TRUE); TRUE);
/* Notify all the roots */ /* Notify all the roots */
#ifdef XINERAMA #ifdef XINERAMA
if ( !noXineramaExtension ) if ( !noPanoramiXExtension )
FocusEvent(dev, FocusOut, mode, out, WindowTable[0]); FocusEvent(dev, FocusOut, mode, out, WindowTable[0]);
else else
#endif #endif
@ -3373,7 +3373,7 @@ DoFocusEvents(dev, fromWin, toWin, mode)
} }
/* Notify all the roots */ /* Notify all the roots */
#ifdef XINERAMA #ifdef XINERAMA
if ( !noXineramaExtension ) if ( !noPanoramiXExtension )
FocusEvent(dev, FocusIn, mode, in, WindowTable[0]); FocusEvent(dev, FocusIn, mode, in, WindowTable[0]);
else else
#endif #endif
@ -3391,7 +3391,7 @@ DoFocusEvents(dev, fromWin, toWin, mode)
FocusOutEvents(dev, sprite.win, ROOT, mode, NotifyPointer, FocusOutEvents(dev, sprite.win, ROOT, mode, NotifyPointer,
TRUE); TRUE);
#ifdef XINERAMA #ifdef XINERAMA
if ( !noXineramaExtension ) if ( !noPanoramiXExtension )
FocusEvent(dev, FocusOut, mode, out, WindowTable[0]); FocusEvent(dev, FocusOut, mode, out, WindowTable[0]);
else else
#endif #endif
@ -3905,12 +3905,12 @@ ProcQueryPointer(client)
} }
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension) { if(!noPanoramiXExtension) {
rep.rootX += xineramaDataPtr[0].x; rep.rootX += panoramiXdataPtr[0].x;
rep.rootY += xineramaDataPtr[0].y; rep.rootY += panoramiXdataPtr[0].y;
if(stuff->id == rep.root) { if(stuff->id == rep.root) {
rep.winX += xineramaDataPtr[0].x; rep.winX += panoramiXdataPtr[0].x;
rep.winY += xineramaDataPtr[0].y; rep.winY += panoramiXdataPtr[0].y;
} }
} }
#endif #endif
@ -4373,7 +4373,7 @@ CheckCursorConfinement(pWin)
WindowPtr confineTo; WindowPtr confineTo;
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension && pWin->drawable.pScreen->myNum) return; if(!noPanoramiXExtension && pWin->drawable.pScreen->myNum) return;
#endif #endif
if (grab && (confineTo = grab->confineTo)) if (grab && (confineTo = grab->confineTo))
@ -4433,7 +4433,7 @@ ProcRecolorCursor(client)
{ {
pscr = screenInfo.screens[nscr]; pscr = screenInfo.screens[nscr];
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension) if(!noPanoramiXExtension)
displayed = (pscr == sprite.screen); displayed = (pscr == sprite.screen);
else else
#endif #endif
@ -4462,8 +4462,8 @@ WriteEventsToClient(pClient, count, events)
#endif #endif
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension && if(!noPanoramiXExtension &&
(xineramaDataPtr[0].x || xineramaDataPtr[0].y)) (panoramiXdataPtr[0].x || panoramiXdataPtr[0].y))
{ {
switch(events->u.u.type) { switch(events->u.u.type) {
case MotionNotify: case MotionNotify:
@ -4480,13 +4480,13 @@ WriteEventsToClient(pClient, count, events)
*/ */
count = 1; /* should always be 1 */ count = 1; /* should always be 1 */
memcpy(&eventCopy, events, sizeof(xEvent)); memcpy(&eventCopy, events, sizeof(xEvent));
eventCopy.u.keyButtonPointer.rootX += xineramaDataPtr[0].x; eventCopy.u.keyButtonPointer.rootX += panoramiXdataPtr[0].x;
eventCopy.u.keyButtonPointer.rootY += xineramaDataPtr[0].y; eventCopy.u.keyButtonPointer.rootY += panoramiXdataPtr[0].y;
if(eventCopy.u.keyButtonPointer.event == if(eventCopy.u.keyButtonPointer.event ==
eventCopy.u.keyButtonPointer.root) eventCopy.u.keyButtonPointer.root)
{ {
eventCopy.u.keyButtonPointer.eventX += xineramaDataPtr[0].x; eventCopy.u.keyButtonPointer.eventX += panoramiXdataPtr[0].x;
eventCopy.u.keyButtonPointer.eventY += xineramaDataPtr[0].y; eventCopy.u.keyButtonPointer.eventY += panoramiXdataPtr[0].y;
} }
events = &eventCopy; events = &eventCopy;
break; break;

18
dix/main.c
View File

@ -1,4 +1,4 @@
/* $XdotOrg: xc/programs/Xserver/dix/main.c,v 3.44 2003/11/17 22:20:34 dawes Exp $ */ /* $XdotOrg: xc/programs/Xserver/dix/main.c,v 1.1.4.4 2003/12/18 19:29:12 kaleb Exp $ */
/* $XFree86: xc/programs/Xserver/dix/main.c,v 3.44 2003/11/17 22:20:34 dawes Exp $ */ /* $XFree86: xc/programs/Xserver/dix/main.c,v 3.44 2003/11/17 22:20:34 dawes Exp $ */
/*********************************************************** /***********************************************************
@ -94,7 +94,7 @@ SOFTWARE.
#include "dixfont.h" #include "dixfont.h"
#include "extnsionst.h" #include "extnsionst.h"
#ifdef XINERAMA #ifdef XINERAMA
extern Bool noXineramaExtension; extern Bool noPanoramiXExtension;
#else #else
#include "dixevents.h" /* InitEvents() */ #include "dixevents.h" /* InitEvents() */
#include "dispatch.h" /* InitProcVectors() */ #include "dispatch.h" /* InitProcVectors() */
@ -407,8 +407,8 @@ main(int argc, char *argv[], char *envp[])
/* /*
* Consolidate window and colourmap information for each screen * Consolidate window and colourmap information for each screen
*/ */
if (!noXineramaExtension) if (!noPanoramiXExtension)
XineramaConsolidate(); PanoramiXConsolidate();
#endif #endif
for (i = 0; i < screenInfo.numScreens; i++) for (i = 0; i < screenInfo.numScreens; i++)
@ -420,8 +420,8 @@ main(int argc, char *argv[], char *envp[])
#endif #endif
#ifdef XINERAMA #ifdef XINERAMA
if (!noXineramaExtension) { if (!noPanoramiXExtension) {
if (!XineramaCreateConnectionBlock()) if (!PanoramiXCreateConnectionBlock())
FatalError("could not create connection block info"); FatalError("could not create connection block info");
} else } else
#endif #endif
@ -440,10 +440,10 @@ main(int argc, char *argv[], char *envp[])
#ifdef XINERAMA #ifdef XINERAMA
{ {
Bool remember_it = noXineramaExtension; Bool remember_it = noPanoramiXExtension;
noXineramaExtension = TRUE; noPanoramiXExtension = TRUE;
FreeAllResources(); FreeAllResources();
noXineramaExtension = remember_it; noPanoramiXExtension = remember_it;
} }
#else #else
FreeAllResources(); FreeAllResources();

7
dix/resource.c
View File

@ -1,4 +1,3 @@
/* $XdotOrg$ */
/************************************************************ /************************************************************
Copyright 1987, 1998 The Open Group Copyright 1987, 1998 The Open Group
@ -90,8 +89,8 @@ SOFTWARE.
#include "dixgrabs.h" #include "dixgrabs.h"
#include "cursor.h" #include "cursor.h"
#ifdef XINERAMA #ifdef XINERAMA
#include "xinerama.h" #include "panoramiX.h"
#include "xineramaSrv.h" #include "panoramiXsrv.h"
#endif #endif
#include <assert.h> #include <assert.h>
@ -801,7 +800,7 @@ LegalNewID(id, client)
#ifdef XINERAMA #ifdef XINERAMA
XID minid, maxid; XID minid, maxid;
if (!noXineramaExtension) { if (!noPanoramiXExtension) {
minid = client->clientAsMask | (client->index ? minid = client->clientAsMask | (client->index ?
SERVER_BIT : SERVER_MINID); SERVER_BIT : SERVER_MINID);
maxid = (clientTable[client->index].fakeID | RESOURCE_ID_MASK) + 1; maxid = (clientTable[client->index].fakeID | RESOURCE_ID_MASK) + 1;

40
dix/window.c
View File

@ -1,4 +1,4 @@
/* $XdotOrg: window.c,v 1.4 2001/02/09 02:04:41 xorgcvs Exp $ */ /* $XdotOrg: xc/programs/Xserver/dix/window.c,v 1.1.4.3 2003/12/18 19:29:12 kaleb Exp $ */
/* $Xorg: window.c,v 1.4 2001/02/09 02:04:41 xorgcvs Exp $ */ /* $Xorg: window.c,v 1.4 2001/02/09 02:04:41 xorgcvs Exp $ */
/* /*
@ -87,8 +87,8 @@ SOFTWARE.
#include "gcstruct.h" #include "gcstruct.h"
#include "servermd.h" #include "servermd.h"
#ifdef XINERAMA #ifdef XINERAMA
#include "xinerama.h" #include "panoramiX.h"
#include "xineramaSrv.h" #include "panoramiXsrv.h"
#endif #endif
#include "dixevents.h" #include "dixevents.h"
#include "globals.h" #include "globals.h"
@ -2322,9 +2322,9 @@ ConfigureWindow(pWin, mask, vlist, client)
event.u.configureRequest.x = x; event.u.configureRequest.x = x;
event.u.configureRequest.y = y; event.u.configureRequest.y = y;
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension && (!pParent || !pParent->parent)) { if(!noPanoramiXExtension && (!pParent || !pParent->parent)) {
event.u.configureRequest.x += xineramaDataPtr[0].x; event.u.configureRequest.x += panoramiXdataPtr[0].x;
event.u.configureRequest.y += xineramaDataPtr[0].y; event.u.configureRequest.y += panoramiXdataPtr[0].y;
} }
#endif #endif
event.u.configureRequest.width = w; event.u.configureRequest.width = w;
@ -2408,9 +2408,9 @@ ActuallyDoSomething:
event.u.configureNotify.x = x; event.u.configureNotify.x = x;
event.u.configureNotify.y = y; event.u.configureNotify.y = y;
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension && (!pParent || !pParent->parent)) { if(!noPanoramiXExtension && (!pParent || !pParent->parent)) {
event.u.configureNotify.x += xineramaDataPtr[0].x; event.u.configureNotify.x += panoramiXdataPtr[0].x;
event.u.configureNotify.y += xineramaDataPtr[0].y; event.u.configureNotify.y += panoramiXdataPtr[0].y;
} }
#endif #endif
event.u.configureNotify.width = w; event.u.configureNotify.width = w;
@ -2566,9 +2566,9 @@ ReparentWindow(pWin, pParent, x, y, client)
event.u.reparent.x = x; event.u.reparent.x = x;
event.u.reparent.y = y; event.u.reparent.y = y;
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension && !pParent->parent) { if(!noPanoramiXExtension && !pParent->parent) {
event.u.reparent.x += xineramaDataPtr[0].x; event.u.reparent.x += panoramiXdataPtr[0].x;
event.u.reparent.y += xineramaDataPtr[0].y; event.u.reparent.y += panoramiXdataPtr[0].y;
} }
#endif #endif
event.u.reparent.override = pWin->overrideRedirect; event.u.reparent.override = pWin->overrideRedirect;
@ -2939,9 +2939,9 @@ UnrealizeTree(
pChild->realized = FALSE; pChild->realized = FALSE;
pChild->visibility = VisibilityNotViewable; pChild->visibility = VisibilityNotViewable;
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension && !pChild->drawable.pScreen->myNum) { if(!noPanoramiXExtension && !pChild->drawable.pScreen->myNum) {
XineramaRes *win; PanoramiXRes *win;
win = (XineramaRes*)LookupIDByType(pChild->drawable.id, win = (PanoramiXRes*)LookupIDByType(pChild->drawable.id,
XRT_WINDOW); XRT_WINDOW);
if(win) if(win)
win->u.win.visibility = VisibilityNotViewable; win->u.win.visibility = VisibilityNotViewable;
@ -3225,21 +3225,21 @@ SendVisibilityNotify(pWin)
#endif #endif
#ifdef XINERAMA #ifdef XINERAMA
/* This is not quite correct yet, but it's close */ /* This is not quite correct yet, but it's close */
if(!noXineramaExtension) { if(!noPanoramiXExtension) {
XineramaRes *win; PanoramiXRes *win;
WindowPtr pWin2; WindowPtr pWin2;
int i, Scrnum; int i, Scrnum;
Scrnum = pWin->drawable.pScreen->myNum; Scrnum = pWin->drawable.pScreen->myNum;
win = XineramaFindIDByScrnum(XRT_WINDOW, pWin->drawable.id, Scrnum); win = PanoramiXFindIDByScrnum(XRT_WINDOW, pWin->drawable.id, Scrnum);
if(!win || (win->u.win.visibility == visibility)) if(!win || (win->u.win.visibility == visibility))
return; return;
switch(visibility) { switch(visibility) {
case VisibilityUnobscured: case VisibilityUnobscured:
for(i = 0; i < XineramaNumScreens; i++) { for(i = 0; i < PanoramiXNumScreens; i++) {
if(i == Scrnum) continue; if(i == Scrnum) continue;
pWin2 = (WindowPtr)LookupIDByType(win->info[i].id, RT_WINDOW); pWin2 = (WindowPtr)LookupIDByType(win->info[i].id, RT_WINDOW);
@ -3259,7 +3259,7 @@ SendVisibilityNotify(pWin)
} }
break; break;
case VisibilityFullyObscured: case VisibilityFullyObscured:
for(i = 0; i < XineramaNumScreens; i++) { for(i = 0; i < PanoramiXNumScreens; i++) {
if(i == Scrnum) continue; if(i == Scrnum) continue;
pWin2 = (WindowPtr)LookupIDByType(win->info[i].id, RT_WINDOW); pWin2 = (WindowPtr)LookupIDByType(win->info[i].id, RT_WINDOW);

18
dix/xpstubs.c
View File

@ -31,24 +31,24 @@ from The Open Group.
#include "font.h" #include "font.h"
Bool Bool
XpClientIsBitmapClient(client) XpClientIsBitmapClient(
ClientPtr client; ClientPtr client)
{ {
return TRUE; return TRUE;
} }
Bool Bool
XpClientIsPrintClient(client, fpe) XpClientIsPrintClient(
ClientPtr client; ClientPtr client,
FontPathElementPtr fpe; FontPathElementPtr fpe)
{ {
return FALSE; return FALSE;
} }
int int
XprintOptions(argc, argv, i) XprintOptions(
int argc; int argc,
char **argv; char **argv,
int i; int i)
{ {
return i; return i;
} }

12
fb/fbwindow.c
View File

@ -1,4 +1,4 @@
/* $XdotOrg$ */ /* $XdotOrg: xc/programs/Xserver/fb/fbwindow.c,v 1.1.4.2 2003/12/18 19:29:12 kaleb Exp $ */
/* /*
* Id: fbwindow.c,v 1.1 1999/11/02 03:54:45 keithp Exp $ * Id: fbwindow.c,v 1.1 1999/11/02 03:54:45 keithp Exp $
* *
@ -225,8 +225,8 @@ fbFillRegionSolid (DrawablePtr pDrawable,
} }
#ifdef XINERAMA #ifdef XINERAMA
#include "xinerama.h" #include "panoramiX.h"
#include "xineramaSrv.h" #include "panoramiXsrv.h"
#endif #endif
void void
@ -249,13 +249,13 @@ fbFillRegionTiled (DrawablePtr pDrawable,
int yRot = pDrawable->y; int yRot = pDrawable->y;
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension) if(!noPanoramiXExtension)
{ {
int index = pDrawable->pScreen->myNum; int index = pDrawable->pScreen->myNum;
if(&WindowTable[index]->drawable == pDrawable) if(&WindowTable[index]->drawable == pDrawable)
{ {
xRot -= xineramaDataPtr[index].x; xRot -= panoramiXdataPtr[index].x;
yRot -= xineramaDataPtr[index].y; yRot -= panoramiXdataPtr[index].y;
} }
} }
#endif #endif

8
hw/darwin/quartz/quartzCocoa.m
View File

@ -1,4 +1,4 @@
/* $XdotOrg$ */ /* $XdotOrg: xc/programs/Xserver/hw/darwin/quartz/quartzCocoa.m,v 1.1.4.2 2003/12/18 19:29:12 kaleb Exp $ */
/************************************************************** /**************************************************************
* *
* Quartz-specific support for the Darwin X Server * Quartz-specific support for the Darwin X Server
@ -49,7 +49,7 @@
extern void FatalError(const char *, ...); extern void FatalError(const char *, ...);
extern char *display; extern char *display;
extern int noXineramaExtension; extern int noPanoramiXExtension;
/* /*
@ -69,12 +69,12 @@ void QuartzReadPreferences(void)
// quartzRootless has already been set // quartzRootless has already been set
if (quartzRootless) { if (quartzRootless) {
// Use Pseudorama instead of Xinerama // Use Pseudorama instead of Xinerama
noXineramaExtension = TRUE; noPanoramiXExtension = TRUE;
noPseudoramaExtension = ![Preferences xinerama]; noPseudoramaExtension = ![Preferences xinerama];
quartzUseAGL = [Preferences useAGL]; quartzUseAGL = [Preferences useAGL];
} else { } else {
noXineramaExtension = ![Preferences xinerama]; noPanoramiXExtension = ![Preferences xinerama];
noPseudoramaExtension = TRUE; noPseudoramaExtension = TRUE;
// Full screen can't use AGL for GLX // Full screen can't use AGL for GLX

8
hw/xfree86/common/xf86Config.c
View File

@ -1,4 +1,4 @@
/* $XdotOrg: xc/programs/Xserver/hw/xfree86/common/xf86Config.c,v 3.277 2003/10/15 22:51:48 dawes Exp $ */ /* $XdotOrg: xc/programs/Xserver/hw/xfree86/common/xf86Config.c,v 1.1.4.3 2003/12/18 19:29:13 kaleb Exp $ */
/* $XFree86: xc/programs/Xserver/hw/xfree86/common/xf86Config.c,v 3.277 2003/10/15 22:51:48 dawes Exp $ */ /* $XFree86: xc/programs/Xserver/hw/xfree86/common/xf86Config.c,v 3.277 2003/10/15 22:51:48 dawes Exp $ */
@ -1060,13 +1060,13 @@ configServerFlags(XF86ConfFlagsPtr flagsconf, XF86OptionPtr layoutopts)
#ifdef XINERAMA #ifdef XINERAMA
from = X_DEFAULT; from = X_DEFAULT;
if (!noXineramaExtension) if (!noPanoramiXExtension)
from = X_CMDLINE; from = X_CMDLINE;
else if (xf86GetOptValBool(FlagOptions, FLAG_XINERAMA, &value)) { else if (xf86GetOptValBool(FlagOptions, FLAG_XINERAMA, &value)) {
noXineramaExtension = !value; noPanoramiXExtension = !value;
from = X_CONFIG; from = X_CONFIG;
} }
if (!noXineramaExtension) if (!noPanoramiXExtension)
xf86Msg(from, "Xinerama: enabled\n"); xf86Msg(from, "Xinerama: enabled\n");
#endif #endif

4
hw/xfree86/common/xf86DGA.c
View File

@ -1,4 +1,4 @@
/* $XdotOrg: xc/programs/Xserver/hw/xfree86/common/xf86DGA.c,v 1.47 2003/08/24 17:36:51 dawes Exp $ */ /* $XdotOrg: xc/programs/Xserver/hw/xfree86/common/xf86DGA.c,v 1.1.4.2 2003/12/18 19:29:13 kaleb Exp $ */
/* $XFree86: xc/programs/Xserver/hw/xfree86/common/xf86DGA.c,v 1.47 2003/08/24 17:36:51 dawes Exp $ */ /* $XFree86: xc/programs/Xserver/hw/xfree86/common/xf86DGA.c,v 1.47 2003/08/24 17:36:51 dawes Exp $ */
/* /*
* Copyright (c) 1998-2002 by The XFree86 Project, Inc. * Copyright (c) 1998-2002 by The XFree86 Project, Inc.
@ -141,7 +141,7 @@ DGAInit(
modes[i].num = i + 1; modes[i].num = i + 1;
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension) if(!noPanoramiXExtension)
for(i = 0; i < num; i++) for(i = 0; i < num; i++)
modes[i].flags &= ~DGA_PIXMAP_AVAILABLE; modes[i].flags &= ~DGA_PIXMAP_AVAILABLE;
#endif #endif

4
hw/xfree86/common/xf86Mode.c
View File

@ -1,4 +1,4 @@
/* $XdotOrg$ */ /* $XdotOrg: xc/programs/Xserver/hw/xfree86/common/xf86Mode.c,v 1.1.4.2 2003/12/18 19:29:13 kaleb Exp $ */
/* $XFree86: xc/programs/Xserver/hw/xfree86/common/xf86Mode.c,v 1.69 2003/10/08 14:58:28 dawes Exp $ */ /* $XFree86: xc/programs/Xserver/hw/xfree86/common/xf86Mode.c,v 1.69 2003/10/08 14:58:28 dawes Exp $ */
/* /*
* Copyright (c) 1997-2003 by The XFree86 Project, Inc. * Copyright (c) 1997-2003 by The XFree86 Project, Inc.
@ -1683,7 +1683,7 @@ xf86ValidateModes(ScrnInfoPtr scrp, DisplayModePtr availModes,
#ifdef RANDR #ifdef RANDR
if (!xf86Info.disableRandR if (!xf86Info.disableRandR
#ifdef XINERAMA #ifdef XINERAMA
&& noXineramaExtension && noPanoramiXExtension
#endif #endif
) )
validateAllDefaultModes = TRUE; validateAllDefaultModes = TRUE;

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

@ -1,4 +1,4 @@
/* $XdotOrg$ */ /* $XdotOrg: xc/programs/Xserver/hw/xfree86/common/xf86RandR.c,v 1.1.4.2 2003/12/18 19:29:14 kaleb Exp $ */
/* /*
* $XFree86: xc/programs/Xserver/hw/xfree86/common/xf86RandR.c,v 1.8 2003/11/10 16:42:13 tsi Exp $ * $XFree86: xc/programs/Xserver/hw/xfree86/common/xf86RandR.c,v 1.8 2003/11/10 16:42:13 tsi Exp $
* *
@ -246,7 +246,7 @@ xf86RandRInit (ScreenPtr pScreen)
#ifdef XINERAMA #ifdef XINERAMA
/* XXX disable RandR when using Xinerama */ /* XXX disable RandR when using Xinerama */
if (!noXineramaExtension) if (!noPanoramiXExtension)
return TRUE; return TRUE;
#endif #endif
if (xf86RandRGeneration != serverGeneration) if (xf86RandRGeneration != serverGeneration)

4
hw/xfree86/dixmods/extmod/modinit.h
View File

@ -1,4 +1,4 @@
/* $XdotOrg$ */ /* $XdotOrg: xc/programs/Xserver/Xext/extmod/modinit.h,v 1.1.4.1 2003/12/18 19:29:12 kaleb Exp $ */
/* $XFree86: xc/programs/Xserver/Xext/extmod/modinit.h,v 1.2 2003/09/13 21:33:04 dawes Exp $ */ /* $XFree86: xc/programs/Xserver/Xext/extmod/modinit.h,v 1.2 2003/09/13 21:33:04 dawes Exp $ */
#ifndef INITARGS #ifndef INITARGS
@ -137,7 +137,7 @@ extern void XpExtensionInit(INITARGS);
#endif #endif
#if 1 #if 1
extern void XineramaExtensionInit(int argc, char *argv[]); extern void PanoramiXExtensionInit(int argc, char *argv[]);
#endif #endif
#if 1 #if 1

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

@ -67,7 +67,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#include "mipointer.h" #include "mipointer.h"
#if defined(XFree86LOADER) && !defined(XINERAMA) #if defined(XFree86LOADER) && !defined(XINERAMA)
extern Bool noXineramaExtension; extern Bool noPanoramiXExtension;
#endif #endif
static int DRIScreenPrivIndex = -1; static int DRIScreenPrivIndex = -1;
@ -132,13 +132,13 @@ DRIScreenInit(ScreenPtr pScreen, DRIInfoPtr pDRIInfo, int *pDRMFD)
#if defined(XINERAMA) && !defined(XFree86LOADER) #if defined(XINERAMA) && !defined(XFree86LOADER)
xineramaInCore = TRUE; xineramaInCore = TRUE;
#elif defined(XFree86LOADER) #elif defined(XFree86LOADER)
if (xf86LoaderCheckSymbol("noXineramaExtension")) if (xf86LoaderCheckSymbol("noPanoramiXExtension"))
xineramaInCore = TRUE; xineramaInCore = TRUE;
#endif #endif
#if defined(XINERAMA) || defined(XFree86LOADER) #if defined(XINERAMA) || defined(XFree86LOADER)
if (xineramaInCore) { if (xineramaInCore) {
if (!noXineramaExtension) { if (!noPanoramiXExtension) {
DRIDrvMsg(pScreen->myNum, X_WARNING, DRIDrvMsg(pScreen->myNum, X_WARNING,
"Direct rendering is not supported when Xinerama is enabled\n"); "Direct rendering is not supported when Xinerama is enabled\n");
return FALSE; return FALSE;

20
hw/xfree86/loader/extsym.c
View File

@ -1,4 +1,4 @@
/* $XdotOrg$ */ /* $XdotOrg: xc/programs/Xserver/hw/xfree86/loader/extsym.c,v 1.1.4.2 2003/12/18 19:29:14 kaleb Exp $ */
/* $XFree86: xc/programs/Xserver/hw/xfree86/loader/extsym.c,v 1.9 2003/10/15 16:29:03 dawes Exp $ */ /* $XFree86: xc/programs/Xserver/hw/xfree86/loader/extsym.c,v 1.9 2003/10/15 16:29:03 dawes Exp $ */
/* /*
@ -29,7 +29,7 @@
#include "sym.h" #include "sym.h"
#include "misc.h" #include "misc.h"
#ifdef XINERAMA #ifdef XINERAMA
#include "xinerama.h" #include "panoramiX.h"
#endif #endif
#include "sleepuntil.h" #include "sleepuntil.h"
@ -40,10 +40,10 @@ extern RESTYPE ShmSegType, ShmPixType;
#endif #endif
#ifdef XINERAMA #ifdef XINERAMA
extern Bool noXineramaExtension; extern Bool noPanoramiXExtension;
extern int XineramaNumScreens; extern int PanoramiXNumScreens;
extern XineramaData *xineramaDataPtr; extern PanoramiXData *panoramiXdataPtr;
extern XID *XineramaVisualTable; extern XID *PanoramiXVisualTable;
extern unsigned long XRT_WINDOW; extern unsigned long XRT_WINDOW;
extern unsigned long XRT_PIXMAP; extern unsigned long XRT_PIXMAP;
extern unsigned long XRT_GC; extern unsigned long XRT_GC;
@ -66,10 +66,10 @@ LOOKUP extLookupTab[] = {
#ifdef XINERAMA #ifdef XINERAMA
SYMFUNC(XineramaRegisterConnectionBlockCallback) SYMFUNC(XineramaRegisterConnectionBlockCallback)
SYMFUNC(XineramaDeleteResource) SYMFUNC(XineramaDeleteResource)
SYMVAR(noXineramaExtension) SYMVAR(noPanoramiXExtension)
SYMVAR(XineramaNumScreens) SYMVAR(PanoramiXNumScreens)
SYMVAR(xineramaDataPtr) SYMVAR(panoramiXdataPtr)
SYMVAR(XineramaVisualTable) SYMVAR(PanoramiXVisualTable)
SYMVAR(XRT_WINDOW) SYMVAR(XRT_WINDOW)
SYMVAR(XRT_PIXMAP) SYMVAR(XRT_PIXMAP)
SYMVAR(XRT_GC) SYMVAR(XRT_GC)

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

@ -1,4 +1,4 @@
/* $XdotOrg$ */ /* $XdotOrg: xc/programs/Xserver/hw/xfree86/xaa/xaaOverlay.c,v 1.1.4.2 2003/12/18 19:29:15 kaleb Exp $ */
/* $XFree86: xc/programs/Xserver/hw/xfree86/xaa/xaaOverlay.c,v 1.15 2003/11/10 18:22:41 tsi Exp $ */ /* $XFree86: xc/programs/Xserver/hw/xfree86/xaa/xaaOverlay.c,v 1.15 2003/11/10 18:22:41 tsi Exp $ */
#include "misc.h" #include "misc.h"
@ -18,8 +18,8 @@
#include "mioverlay.h" #include "mioverlay.h"
#ifdef XINERAMA #ifdef XINERAMA
#include "xinerama.h" #include "panoramiX.h"
#include "xineramaSrv.h" #include "panoramiXsrv.h"
#endif #endif
static void static void
@ -168,11 +168,11 @@ XAAPaintWindow8_32(
yorg = pBgWin->drawable.y; yorg = pBgWin->drawable.y;
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension) { if(!noPanoramiXExtension) {
int index = pScreen->myNum; int index = pScreen->myNum;
if(WindowTable[index] == pBgWin) { if(WindowTable[index] == pBgWin) {
xorg -= xineramaDataPtr[index].x; xorg -= panoramiXdataPtr[index].x;
yorg -= xineramaDataPtr[index].y; yorg -= panoramiXdataPtr[index].y;
} }
} }
#endif #endif

12
hw/xfree86/xaa/xaaPaintWin.c
View File

@ -1,4 +1,4 @@
/* $XdotOrg$ */ /* $XdotOrg: xc/programs/Xserver/hw/xfree86/xaa/xaaPaintWin.c,v 1.1.4.1 2003/12/18 19:29:15 kaleb Exp $ */
/* $XFree86: xc/programs/Xserver/hw/xfree86/xaa/xaaPaintWin.c,v 1.11 2003/02/17 16:08:29 dawes Exp $ */ /* $XFree86: xc/programs/Xserver/hw/xfree86/xaa/xaaPaintWin.c,v 1.11 2003/02/17 16:08:29 dawes Exp $ */
#include "misc.h" #include "misc.h"
@ -17,8 +17,8 @@
#include "xaawrap.h" #include "xaawrap.h"
#ifdef XINERAMA #ifdef XINERAMA
#include "xinerama.h" #include "panoramiX.h"
#include "xineramaSrv.h" #include "panoramiXsrv.h"
#endif #endif
void void
@ -93,11 +93,11 @@ XAAPaintWindow(
yorg = pBgWin->drawable.y; yorg = pBgWin->drawable.y;
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension) { if(!noPanoramiXExtension) {
int index = pScreen->myNum; int index = pScreen->myNum;
if(WindowTable[index] == pBgWin) { if(WindowTable[index] == pBgWin) {
xorg -= xineramaDataPtr[index].x; xorg -= panoramiXdataPtr[index].x;
yorg -= xineramaDataPtr[index].y; yorg -= panoramiXdataPtr[index].y;
} }
} }
#endif #endif

18
hw/xfree86/xf8_32bpp/cfbpntwin.c
View File

@ -1,4 +1,4 @@
/* $XdotOrg$ */ /* $XdotOrg: xc/programs/Xserver/hw/xfree86/xf8_32bpp/cfbpntwin.c,v 1.1.4.1 2003/12/18 19:29:15 kaleb Exp $ */
/* $XFree86: xc/programs/Xserver/hw/xfree86/xf8_32bpp/cfbpntwin.c,v 1.5 2001/10/01 13:44:15 eich Exp $ */ /* $XFree86: xc/programs/Xserver/hw/xfree86/xf8_32bpp/cfbpntwin.c,v 1.5 2001/10/01 13:44:15 eich Exp $ */
#include "X.h" #include "X.h"
@ -16,8 +16,8 @@
#include "mi.h" #include "mi.h"
#ifdef XINERAMA #ifdef XINERAMA
#include "xinerama.h" #include "panoramiX.h"
#include "xineramaSrv.h" #include "panoramiXsrv.h"
#endif #endif
void void
@ -45,11 +45,11 @@ cfb8_32PaintWindow(
xorg = pWin->drawable.x; xorg = pWin->drawable.x;
yorg = pWin->drawable.y; yorg = pWin->drawable.y;
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension) { if(!noPanoramiXExtension) {
int index = pWin->drawable.pScreen->myNum; int index = pWin->drawable.pScreen->myNum;
if(WindowTable[index] == pWin) { if(WindowTable[index] == pWin) {
xorg -= xineramaDataPtr[index].x; xorg -= panoramiXdataPtr[index].x;
yorg -= xineramaDataPtr[index].y; yorg -= panoramiXdataPtr[index].y;
} }
} }
#endif #endif
@ -93,11 +93,11 @@ cfb8_32PaintWindow(
yorg = pBgWin->drawable.y; yorg = pBgWin->drawable.y;
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension) { if(!noPanoramiXExtension) {
int index = pWin->drawable.pScreen->myNum; int index = pWin->drawable.pScreen->myNum;
if(WindowTable[index] == pBgWin) { if(WindowTable[index] == pBgWin) {
xorg -= xineramaDataPtr[index].x; xorg -= panoramiXdataPtr[index].x;
yorg -= xineramaDataPtr[index].y; yorg -= panoramiXdataPtr[index].y;
} }
} }
#endif #endif

12
include/globals.h
View File

@ -1,4 +1,4 @@
/* $XdotOrg: xc/programs/Xserver/include/globals.h,v 1.4 2000/06/28 18:21:22 tsi Exp $ */ /* $XdotOrg: xc/programs/Xserver/include/globals.h,v 1.1.4.1 2003/12/18 19:29:15 kaleb Exp $ */
/* $XFree86: xc/programs/Xserver/include/globals.h,v 1.4 2000/06/28 18:21:22 tsi Exp $ */ /* $XFree86: xc/programs/Xserver/include/globals.h,v 1.4 2000/06/28 18:21:22 tsi Exp $ */
#ifndef _XSERV_GLOBAL_H_ #ifndef _XSERV_GLOBAL_H_
@ -42,11 +42,11 @@ extern Bool DPMSCapableFlag;
#endif #endif
#ifdef XINERAMA #ifdef XINERAMA
extern Bool noXineramaExtension; extern Bool noPanoramiXExtension;
extern Bool XineramaMapped; extern Bool PanoramiXMapped;
extern Bool XineramaVisibilityNotifySent; extern Bool PanoramiXVisibilityNotifySent;
extern Bool XineramaWindowExposureSent; extern Bool PanoramiXWindowExposureSent;
extern Bool XineramaOneExposeRequest; extern Bool PanoramiXOneExposeRequest;
#endif #endif

16
mi/miexpose.c
View File

@ -1,4 +1,4 @@
/* $XdotOrg$ */ /* $XdotOrg: xc/programs/Xserver/mi/miexpose.c,v 1.1.4.3 2003/12/18 19:29:15 kaleb Exp $ */
/* $XFree86: xc/programs/Xserver/mi/miexpose.c,v 3.10 2003/11/10 18:22:49 tsi Exp $ */ /* $XFree86: xc/programs/Xserver/mi/miexpose.c,v 3.10 2003/11/10 18:22:49 tsi Exp $ */
/*********************************************************** /***********************************************************
@ -69,8 +69,8 @@ SOFTWARE.
#include "globals.h" #include "globals.h"
#ifdef XINERAMA #ifdef XINERAMA
#include "xinerama.h" #include "panoramiX.h"
#include "xineramaSrv.h" #include "panoramiXsrv.h"
#endif #endif
/* /*
@ -427,19 +427,19 @@ miSendExposures(pWin, pRgn, dx, dy)
} }
#ifdef XINERAMA #ifdef XINERAMA
if(!noXineramaExtension) { if(!noPanoramiXExtension) {
int scrnum = pWin->drawable.pScreen->myNum; int scrnum = pWin->drawable.pScreen->myNum;
int x = 0, y = 0; int x = 0, y = 0;
XID realWin = 0; XID realWin = 0;
if(!pWin->parent) { if(!pWin->parent) {
x = xineramaDataPtr[scrnum].x; x = panoramiXdataPtr[scrnum].x;
y = xineramaDataPtr[scrnum].y; y = panoramiXdataPtr[scrnum].y;
pWin = WindowTable[0]; pWin = WindowTable[0];
realWin = pWin->drawable.id; realWin = pWin->drawable.id;
} else if (scrnum) { } else if (scrnum) {
XineramaRes *win; PanoramiXRes *win;
win = XineramaFindIDByScrnum(XRT_WINDOW, win = PanoramiXFindIDByScrnum(XRT_WINDOW,
pWin->drawable.id, scrnum); pWin->drawable.id, scrnum);
if(!win) { if(!win) {
DEALLOCATE_LOCAL(pEvent); DEALLOCATE_LOCAL(pEvent);

14
mi/miinitext.c
View File

@ -1,4 +1,4 @@
/* $XdotOrg$ */ /* $XdotOrg: xc/programs/Xserver/mi/miinitext.c,v 1.1.4.2 2003/12/18 19:29:15 kaleb Exp $ */
/* $XFree86: xc/programs/Xserver/mi/miinitext.c,v 3.68 2003/01/15 02:34:14 torrey Exp $ */ /* $XFree86: xc/programs/Xserver/mi/miinitext.c,v 3.68 2003/01/15 02:34:14 torrey Exp $ */
/*********************************************************** /***********************************************************
@ -63,7 +63,7 @@ SOFTWARE.
#endif #endif
#ifdef XINERAMA #ifdef XINERAMA
extern Bool noXineramaExtension; extern Bool noPanoramiXExtension;
#endif #endif
extern Bool noTestExtensions; extern Bool noTestExtensions;
#ifdef XKB #ifdef XKB
@ -104,7 +104,7 @@ typedef void (*InitExtension)(INITARGS);
#include "securstr.h" #include "securstr.h"
#endif #endif
#ifdef XINERAMA #ifdef XINERAMA
#include "xineramaProto.h" #include "panoramiXproto.h"
#endif #endif
#ifdef XF86BIGFONT #ifdef XF86BIGFONT
#include "xf86bigfstr.h" #include "xf86bigfstr.h"
@ -136,7 +136,7 @@ extern void PexExtensionInit(INITARGS);
extern void MultibufferExtensionInit(INITARGS); extern void MultibufferExtensionInit(INITARGS);
#endif #endif
#ifdef XINERAMA #ifdef XINERAMA
extern void XineramaExtensionInit(INITARGS); extern void PanoramiXExtensionInit(INITARGS);
#endif #endif
#ifdef XINPUT #ifdef XINPUT
extern void XInputExtensionInit(INITARGS); extern void XInputExtensionInit(INITARGS);
@ -249,7 +249,7 @@ InitExtensions(argc, argv)
{ {
#ifdef XINERAMA #ifdef XINERAMA
# if !defined(PRINT_ONLY_SERVER) && !defined(NO_XINERAMA) # if !defined(PRINT_ONLY_SERVER) && !defined(NO_XINERAMA)
if (!noXineramaExtension) XineramaExtensionInit(); if (!noPanoramiXExtension) PanoramiXExtensionInit();
# endif # endif
#endif #endif
#ifdef BEZIER #ifdef BEZIER
@ -438,7 +438,7 @@ ExtensionModule extension[] =
{ NULL, "TOG-CUP", NULL, NULL }, { NULL, "TOG-CUP", NULL, NULL },
{ NULL, "Extended-Visual-Information", NULL, NULL }, { NULL, "Extended-Visual-Information", NULL, NULL },
#ifdef XINERAMA #ifdef XINERAMA
{ NULL, "XINERAMA", &noXineramaExtension, NULL }, { NULL, "XINERAMA", &noPanoramiXExtension, NULL },
#else #else
{ NULL, "NOXINERAMA", NULL, NULL }, { NULL, "NOXINERAMA", NULL, NULL },
#endif #endif
@ -489,7 +489,7 @@ static ExtensionModule staticExtensions[] = {
{ XpExtensionInit, XP_PRINTNAME, NULL, NULL, NULL }, { XpExtensionInit, XP_PRINTNAME, NULL, NULL, NULL },
#endif #endif
#ifdef XINERAMA #ifdef XINERAMA
{ XineramaExtensionInit, XINERAMA_PROTOCOL_NAME, &noXineramaExtension, NULL, NULL }, { PanoramiXExtensionInit, PANORAMIX_PROTOCOL_NAME, &noPanoramiXExtension, NULL, NULL },
#endif #endif
#ifdef XF86BIGFONT #ifdef XF86BIGFONT
{ XFree86BigfontExtensionInit, XF86BIGFONTNAME, NULL, NULL, NULL }, { XFree86BigfontExtensionInit, XF86BIGFONTNAME, NULL, NULL, NULL },

16
os/utils.c
View File

@ -1,4 +1,4 @@
/* $XdotOrg: xc/programs/Xserver/os/utils.c,v 1.1.4.4 2003/12/18 19:29:15 kaleb Exp $ */ /* $XdotOrg: xc/programs/Xserver/os/utils.c,v 1.1.4.5 2004/02/23 21:37:27 kaleb Exp $ */
/* $Xorg: utils.c,v 1.5 2001/02/09 02:05:24 xorgcvs Exp $ */ /* $Xorg: utils.c,v 1.5 2001/02/09 02:05:24 xorgcvs Exp $ */
/* /*
@ -129,12 +129,12 @@ OR PERFORMANCE OF THIS SOFTWARE.
Bool CoreDump; Bool CoreDump;
Bool noTestExtensions; Bool noTestExtensions;
Bool noXineramaExtension = TRUE; Bool noPanoramiXExtension = TRUE;
#ifdef XINERAMA #ifdef XINERAMA
Bool XineramaVisibilityNotifySent = FALSE; Bool PanoramiXVisibilityNotifySent = FALSE;
Bool XineramaMapped = FALSE; Bool PanoramiXMapped = FALSE;
Bool XineramaWindowExposureSent = FALSE; Bool PanoramiXWindowExposureSent = FALSE;
Bool XineramaOneExposeRequest = FALSE; Bool PanoramiXOneExposeRequest = FALSE;
#endif #endif
int auditTrailLevel = 1; int auditTrailLevel = 1;
@ -886,10 +886,10 @@ ProcessCommandLine(int argc, char *argv[])
} }
#ifdef XINERAMA #ifdef XINERAMA
else if ( strcmp( argv[i], "+xinerama") == 0){ else if ( strcmp( argv[i], "+xinerama") == 0){
noXineramaExtension = FALSE; noPanoramiXExtension = FALSE;
} }
else if ( strcmp( argv[i], "-xinerama") == 0){ else if ( strcmp( argv[i], "-xinerama") == 0){
noXineramaExtension = TRUE; noPanoramiXExtension = TRUE;
} }
#endif #endif
else if ( strcmp( argv[i], "-x") == 0) else if ( strcmp( argv[i], "-x") == 0)

16
record/record.c
View File

@ -1,4 +1,4 @@
/* $XdotOrg$ */ /* $XdotOrg: xc/programs/Xserver/record/record.c,v 1.1.4.3 2003/12/18 19:29:15 kaleb Exp $ */
/* $Xorg: record.c,v 1.4 2001/02/09 02:05:27 xorgcvs Exp $ */ /* $Xorg: record.c,v 1.4 2001/02/09 02:05:27 xorgcvs Exp $ */
/* /*
@ -51,8 +51,8 @@ and Jim Haggerty of Metheus.
#ifdef XINERAMA #ifdef XINERAMA
#include "globals.h" #include "globals.h"
#include "xinerama.h" #include "panoramiX.h"
#include "xineramaSrv.h" #include "panoramiXsrv.h"
#include "cursor.h" #include "cursor.h"
#endif #endif
@ -874,7 +874,7 @@ RecordADeviceEvent(pcbl, nulldata, calldata)
#ifdef XINERAMA #ifdef XINERAMA
xEvent shiftedEvent; xEvent shiftedEvent;
if (!noXineramaExtension && if (!noPanoramiXExtension &&
(pev->u.u.type == MotionNotify || (pev->u.u.type == MotionNotify ||
pev->u.u.type == ButtonPress || pev->u.u.type == ButtonPress ||
pev->u.u.type == ButtonRelease || pev->u.u.type == ButtonRelease ||
@ -883,11 +883,11 @@ RecordADeviceEvent(pcbl, nulldata, calldata)
int scr = XineramaGetCursorScreen(); int scr = XineramaGetCursorScreen();
memcpy(&shiftedEvent, pev, sizeof(xEvent)); memcpy(&shiftedEvent, pev, sizeof(xEvent));
shiftedEvent.u.keyButtonPointer.rootX += shiftedEvent.u.keyButtonPointer.rootX +=
xineramaDataPtr[scr].x - panoramiXdataPtr[scr].x -
xineramaDataPtr[0].x; panoramiXdataPtr[0].x;
shiftedEvent.u.keyButtonPointer.rootY += shiftedEvent.u.keyButtonPointer.rootY +=
xineramaDataPtr[scr].y - panoramiXdataPtr[scr].y -
xineramaDataPtr[0].y; panoramiXdataPtr[0].y;
pEvToRecord = &shiftedEvent; pEvToRecord = &shiftedEvent;
} }
#endif /* XINERAMA */ #endif /* XINERAMA */

6
render/picturestr.h
View File

@ -1,4 +1,4 @@
/* $XdotOrg$ */ /* $XdotOrg: xc/programs/Xserver/render/picturestr.h,v 1.1.4.1 2003/12/18 19:29:15 kaleb Exp $ */
/* /*
* $XFree86: xc/programs/Xserver/render/picturestr.h,v 1.22 2002/11/23 02:38:15 keithp Exp $ * $XFree86: xc/programs/Xserver/render/picturestr.h,v 1.22 2002/11/23 02:38:15 keithp Exp $
* *
@ -495,8 +495,8 @@ int
AnimCursorCreate (CursorPtr *cursors, CARD32 *deltas, int ncursor, CursorPtr *ppCursor); AnimCursorCreate (CursorPtr *cursors, CARD32 *deltas, int ncursor, CursorPtr *ppCursor);
#ifdef XINERAMA #ifdef XINERAMA
void XineramaRenderInit (void); void PanoramiXRenderInit (void);
void XineramaRenderReset (void); void PanoramiXRenderReset (void);
#endif #endif
#endif /* _PICTURESTR_H_ */ #endif /* _PICTURESTR_H_ */

96
render/render.c
View File

@ -1,4 +1,4 @@
/* $XdotOrg$ */ /* $XdotOrg: xc/programs/Xserver/render/render.c,v 1.1.4.2 2003/12/18 19:29:15 kaleb Exp $ */
/* /*
* $XFree86: xc/programs/Xserver/render/render.c,v 1.28 2003/11/03 05:12:02 tsi Exp $ * $XFree86: xc/programs/Xserver/render/render.c,v 1.28 2003/11/03 05:12:02 tsi Exp $
* *
@ -338,7 +338,7 @@ ProcRenderQueryPictFormats (ClientPtr client)
REQUEST_SIZE_MATCH(xRenderQueryPictFormatsReq); REQUEST_SIZE_MATCH(xRenderQueryPictFormatsReq);
#ifdef XINERAMA #ifdef XINERAMA
if (noXineramaExtension) if (noPanoramiXExtension)
numScreens = screenInfo.numScreens; numScreens = screenInfo.numScreens;
else else
numScreens = ((xConnSetup *)ConnectionInfo)->numRoots; numScreens = ((xConnSetup *)ConnectionInfo)->numRoots;
@ -2285,8 +2285,8 @@ SProcRenderDispatch (ClientPtr client)
} }
#ifdef XINERAMA #ifdef XINERAMA
#include "xinerama.h" #include "panoramiX.h"
#include "xineramaSrv.h" #include "panoramiXsrv.h"
#define VERIFY_XIN_PICTURE(pPicture, pid, client, mode, err) {\ #define VERIFY_XIN_PICTURE(pPicture, pid, client, mode, err) {\
pPicture = SecurityLookupIDByType(client, pid, XRT_PICTURE, mode);\ pPicture = SecurityLookupIDByType(client, pid, XRT_PICTURE, mode);\
@ -2312,14 +2312,14 @@ static int
XineramaRenderCreatePicture (ClientPtr client) XineramaRenderCreatePicture (ClientPtr client)
{ {
REQUEST(xRenderCreatePictureReq); REQUEST(xRenderCreatePictureReq);
XineramaRes *refDraw, *newPict; PanoramiXRes *refDraw, *newPict;
int result = Success, j; int result = Success, j;
REQUEST_AT_LEAST_SIZE(xRenderCreatePictureReq); REQUEST_AT_LEAST_SIZE(xRenderCreatePictureReq);
if(!(refDraw = (XineramaRes *)SecurityLookupIDByClass( if(!(refDraw = (PanoramiXRes *)SecurityLookupIDByClass(
client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess))) client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
return BadDrawable; return BadDrawable;
if(!(newPict = (XineramaRes *) xalloc(sizeof(XineramaRes)))) if(!(newPict = (PanoramiXRes *) xalloc(sizeof(PanoramiXRes))))
return BadAlloc; return BadAlloc;
newPict->type = XRT_PICTURE; newPict->type = XRT_PICTURE;
newPict->info[0].id = stuff->pid; newPict->info[0].id = stuff->pid;
@ -2332,7 +2332,7 @@ XineramaRenderCreatePicture (ClientPtr client)
else else
newPict->u.pict.root = FALSE; newPict->u.pict.root = FALSE;
for(j = 1; j < XineramaNumScreens; j++) for(j = 1; j < PanoramiXNumScreens; j++)
newPict->info[j].id = FakeClientID(client->index); newPict->info[j].id = FakeClientID(client->index);
FOR_NSCREENS_BACKWARD(j) { FOR_NSCREENS_BACKWARD(j) {
@ -2353,7 +2353,7 @@ XineramaRenderCreatePicture (ClientPtr client)
static int static int
XineramaRenderChangePicture (ClientPtr client) XineramaRenderChangePicture (ClientPtr client)
{ {
XineramaRes *pict; PanoramiXRes *pict;
int result = Success, j; int result = Success, j;
REQUEST(xRenderChangePictureReq); REQUEST(xRenderChangePictureReq);
@ -2376,7 +2376,7 @@ XineramaRenderSetPictureClipRectangles (ClientPtr client)
{ {
REQUEST(xRenderSetPictureClipRectanglesReq); REQUEST(xRenderSetPictureClipRectanglesReq);
int result = Success, j; int result = Success, j;
XineramaRes *pict; PanoramiXRes *pict;
REQUEST_AT_LEAST_SIZE(xRenderSetPictureClipRectanglesReq); REQUEST_AT_LEAST_SIZE(xRenderSetPictureClipRectanglesReq);
@ -2397,7 +2397,7 @@ XineramaRenderSetPictureTransform (ClientPtr client)
{ {
REQUEST(xRenderSetPictureTransformReq); REQUEST(xRenderSetPictureTransformReq);
int result = Success, j; int result = Success, j;
XineramaRes *pict; PanoramiXRes *pict;
REQUEST_AT_LEAST_SIZE(xRenderSetPictureTransformReq); REQUEST_AT_LEAST_SIZE(xRenderSetPictureTransformReq);
@ -2418,7 +2418,7 @@ XineramaRenderSetPictureFilter (ClientPtr client)
{ {
REQUEST(xRenderSetPictureFilterReq); REQUEST(xRenderSetPictureFilterReq);
int result = Success, j; int result = Success, j;
XineramaRes *pict; PanoramiXRes *pict;
REQUEST_AT_LEAST_SIZE(xRenderSetPictureFilterReq); REQUEST_AT_LEAST_SIZE(xRenderSetPictureFilterReq);
@ -2437,7 +2437,7 @@ XineramaRenderSetPictureFilter (ClientPtr client)
static int static int
XineramaRenderFreePicture (ClientPtr client) XineramaRenderFreePicture (ClientPtr client)
{ {
XineramaRes *pict; PanoramiXRes *pict;
int result = Success, j; int result = Success, j;
REQUEST(xRenderFreePictureReq); REQUEST(xRenderFreePictureReq);
@ -2464,7 +2464,7 @@ XineramaRenderFreePicture (ClientPtr client)
static int static int
XineramaRenderComposite (ClientPtr client) XineramaRenderComposite (ClientPtr client)
{ {
XineramaRes *src, *msk, *dst; PanoramiXRes *src, *msk, *dst;
int result = Success, j; int result = Success, j;
xRenderCompositeReq orig; xRenderCompositeReq orig;
REQUEST(xRenderCompositeReq); REQUEST(xRenderCompositeReq);
@ -2484,22 +2484,22 @@ XineramaRenderComposite (ClientPtr client)
stuff->src = src->info[j].id; stuff->src = src->info[j].id;
if (src->u.pict.root) if (src->u.pict.root)
{ {
stuff->xSrc = orig.xSrc - xineramaDataPtr[j].x; stuff->xSrc = orig.xSrc - panoramiXdataPtr[j].x;
stuff->ySrc = orig.ySrc - xineramaDataPtr[j].y; stuff->ySrc = orig.ySrc - panoramiXdataPtr[j].y;
} }
stuff->dst = dst->info[j].id; stuff->dst = dst->info[j].id;
if (dst->u.pict.root) if (dst->u.pict.root)
{ {
stuff->xDst = orig.xDst - xineramaDataPtr[j].x; stuff->xDst = orig.xDst - panoramiXdataPtr[j].x;
stuff->yDst = orig.yDst - xineramaDataPtr[j].y; stuff->yDst = orig.yDst - panoramiXdataPtr[j].y;
} }
if (msk) if (msk)
{ {
stuff->mask = msk->info[j].id; stuff->mask = msk->info[j].id;
if (msk->u.pict.root) if (msk->u.pict.root)
{ {
stuff->xMask = orig.xMask - xineramaDataPtr[j].x; stuff->xMask = orig.xMask - panoramiXdataPtr[j].x;
stuff->yMask = orig.yMask - xineramaDataPtr[j].y; stuff->yMask = orig.yMask - panoramiXdataPtr[j].y;
} }
} }
result = (*XineramaSaveRenderVector[X_RenderComposite]) (client); result = (*XineramaSaveRenderVector[X_RenderComposite]) (client);
@ -2512,7 +2512,7 @@ XineramaRenderComposite (ClientPtr client)
static int static int
XineramaRenderCompositeGlyphs (ClientPtr client) XineramaRenderCompositeGlyphs (ClientPtr client)
{ {
XineramaRes *src, *dst; PanoramiXRes *src, *dst;
int result = Success, j; int result = Success, j;
REQUEST(xRenderCompositeGlyphsReq); REQUEST(xRenderCompositeGlyphsReq);
xGlyphElt origElt, *elt; xGlyphElt origElt, *elt;
@ -2535,14 +2535,14 @@ XineramaRenderCompositeGlyphs (ClientPtr client)
stuff->src = src->info[j].id; stuff->src = src->info[j].id;
if (src->u.pict.root) if (src->u.pict.root)
{ {
stuff->xSrc = xSrc - xineramaDataPtr[j].x; stuff->xSrc = xSrc - panoramiXdataPtr[j].x;
stuff->ySrc = ySrc - xineramaDataPtr[j].y; stuff->ySrc = ySrc - panoramiXdataPtr[j].y;
} }
stuff->dst = dst->info[j].id; stuff->dst = dst->info[j].id;
if (dst->u.pict.root) if (dst->u.pict.root)
{ {
elt->deltax = origElt.deltax - xineramaDataPtr[j].x; elt->deltax = origElt.deltax - panoramiXdataPtr[j].x;
elt->deltay = origElt.deltay - xineramaDataPtr[j].y; elt->deltay = origElt.deltay - panoramiXdataPtr[j].y;
} }
result = (*XineramaSaveRenderVector[stuff->renderReqType]) (client); result = (*XineramaSaveRenderVector[stuff->renderReqType]) (client);
if(result != Success) break; if(result != Success) break;
@ -2555,7 +2555,7 @@ XineramaRenderCompositeGlyphs (ClientPtr client)
static int static int
XineramaRenderFillRectangles (ClientPtr client) XineramaRenderFillRectangles (ClientPtr client)
{ {
XineramaRes *dst; PanoramiXRes *dst;
int result = Success, j; int result = Success, j;
REQUEST(xRenderFillRectanglesReq); REQUEST(xRenderFillRectanglesReq);
char *extra; char *extra;
@ -2573,8 +2573,8 @@ XineramaRenderFillRectangles (ClientPtr client)
if (j) memcpy (stuff + 1, extra, extra_len); if (j) memcpy (stuff + 1, extra, extra_len);
if (dst->u.pict.root) if (dst->u.pict.root)
{ {
int x_off = xineramaDataPtr[j].x; int x_off = panoramiXdataPtr[j].x;
int y_off = xineramaDataPtr[j].y; int y_off = panoramiXdataPtr[j].y;
if(x_off || y_off) { if(x_off || y_off) {
xRectangle *rects = (xRectangle *) (stuff + 1); xRectangle *rects = (xRectangle *) (stuff + 1);
@ -2601,7 +2601,7 @@ XineramaRenderFillRectangles (ClientPtr client)
static int static int
XineramaRenderTrapezoids(ClientPtr client) XineramaRenderTrapezoids(ClientPtr client)
{ {
XineramaRes *src, *dst; PanoramiXRes *src, *dst;
int result = Success, j; int result = Success, j;
REQUEST(xRenderTrapezoidsReq); REQUEST(xRenderTrapezoidsReq);
char *extra; char *extra;
@ -2623,8 +2623,8 @@ XineramaRenderTrapezoids(ClientPtr client)
FOR_NSCREENS_FORWARD(j) { FOR_NSCREENS_FORWARD(j) {
if (j) memcpy (stuff + 1, extra, extra_len); if (j) memcpy (stuff + 1, extra, extra_len);
if (dst->u.pict.root) { if (dst->u.pict.root) {
int x_off = xineramaDataPtr[j].x; int x_off = panoramiXdataPtr[j].x;
int y_off = xineramaDataPtr[j].y; int y_off = panoramiXdataPtr[j].y;
if(x_off || y_off) { if(x_off || y_off) {
xTrapezoid *trap = (xTrapezoid *) (stuff + 1); xTrapezoid *trap = (xTrapezoid *) (stuff + 1);
@ -2663,7 +2663,7 @@ XineramaRenderTrapezoids(ClientPtr client)
static int static int
XineramaRenderTriangles(ClientPtr client) XineramaRenderTriangles(ClientPtr client)
{ {
XineramaRes *src, *dst; PanoramiXRes *src, *dst;
int result = Success, j; int result = Success, j;
REQUEST(xRenderTrianglesReq); REQUEST(xRenderTrianglesReq);
char *extra; char *extra;
@ -2685,8 +2685,8 @@ XineramaRenderTriangles(ClientPtr client)
FOR_NSCREENS_FORWARD(j) { FOR_NSCREENS_FORWARD(j) {
if (j) memcpy (stuff + 1, extra, extra_len); if (j) memcpy (stuff + 1, extra, extra_len);
if (dst->u.pict.root) { if (dst->u.pict.root) {
int x_off = xineramaDataPtr[j].x; int x_off = panoramiXdataPtr[j].x;
int y_off = xineramaDataPtr[j].y; int y_off = panoramiXdataPtr[j].y;
if(x_off || y_off) { if(x_off || y_off) {
xTriangle *tri = (xTriangle *) (stuff + 1); xTriangle *tri = (xTriangle *) (stuff + 1);
@ -2721,7 +2721,7 @@ XineramaRenderTriangles(ClientPtr client)
static int static int
XineramaRenderTriStrip(ClientPtr client) XineramaRenderTriStrip(ClientPtr client)
{ {
XineramaRes *src, *dst; PanoramiXRes *src, *dst;
int result = Success, j; int result = Success, j;
REQUEST(xRenderTriStripReq); REQUEST(xRenderTriStripReq);
char *extra; char *extra;
@ -2743,8 +2743,8 @@ XineramaRenderTriStrip(ClientPtr client)
FOR_NSCREENS_FORWARD(j) { FOR_NSCREENS_FORWARD(j) {
if (j) memcpy (stuff + 1, extra, extra_len); if (j) memcpy (stuff + 1, extra, extra_len);
if (dst->u.pict.root) { if (dst->u.pict.root) {
int x_off = xineramaDataPtr[j].x; int x_off = panoramiXdataPtr[j].x;
int y_off = xineramaDataPtr[j].y; int y_off = panoramiXdataPtr[j].y;
if(x_off || y_off) { if(x_off || y_off) {
xPointFixed *fixed = (xPointFixed *) (stuff + 1); xPointFixed *fixed = (xPointFixed *) (stuff + 1);
@ -2775,7 +2775,7 @@ XineramaRenderTriStrip(ClientPtr client)
static int static int
XineramaRenderTriFan(ClientPtr client) XineramaRenderTriFan(ClientPtr client)
{ {
XineramaRes *src, *dst; PanoramiXRes *src, *dst;
int result = Success, j; int result = Success, j;
REQUEST(xRenderTriFanReq); REQUEST(xRenderTriFanReq);
char *extra; char *extra;
@ -2797,8 +2797,8 @@ XineramaRenderTriFan(ClientPtr client)
FOR_NSCREENS_FORWARD(j) { FOR_NSCREENS_FORWARD(j) {
if (j) memcpy (stuff + 1, extra, extra_len); if (j) memcpy (stuff + 1, extra, extra_len);
if (dst->u.pict.root) { if (dst->u.pict.root) {
int x_off = xineramaDataPtr[j].x; int x_off = panoramiXdataPtr[j].x;
int y_off = xineramaDataPtr[j].y; int y_off = panoramiXdataPtr[j].y;
if(x_off || y_off) { if(x_off || y_off) {
xPointFixed *fixed = (xPointFixed *) (stuff + 1); xPointFixed *fixed = (xPointFixed *) (stuff + 1);
@ -2831,7 +2831,7 @@ XineramaRenderTriFan(ClientPtr client)
static int static int
XineramaRenderColorTrapezoids(ClientPtr client) XineramaRenderColorTrapezoids(ClientPtr client)
{ {
XineramaRes *src, *dst; PanoramiXRes *src, *dst;
int result = Success, j; int result = Success, j;
REQUEST(xRenderColorTrapezoidsReq); REQUEST(xRenderColorTrapezoidsReq);
char *extra; char *extra;
@ -2851,8 +2851,8 @@ XineramaRenderColorTrapezoids(ClientPtr client)
FOR_NSCREENS_FORWARD(j) { FOR_NSCREENS_FORWARD(j) {
if (j) memcpy (stuff + 1, extra, extra_len); if (j) memcpy (stuff + 1, extra, extra_len);
if (dst->u.pict.root) { if (dst->u.pict.root) {
int x_off = xineramaDataPtr[j].x; int x_off = panoramiXdataPtr[j].x;
int y_off = xineramaDataPtr[j].y; int y_off = panoramiXdataPtr[j].y;
if(x_off || y_off) { if(x_off || y_off) {
....; ....;
@ -2875,7 +2875,7 @@ XineramaRenderColorTrapezoids(ClientPtr client)
static int static int
XineramaRenderColorTriangles(ClientPtr client) XineramaRenderColorTriangles(ClientPtr client)
{ {
XineramaRes *src, *dst; PanoramiXRes *src, *dst;
int result = Success, j; int result = Success, j;
REQUEST(xRenderColorTrianglesReq); REQUEST(xRenderColorTrianglesReq);
char *extra; char *extra;
@ -2895,8 +2895,8 @@ XineramaRenderColorTriangles(ClientPtr client)
FOR_NSCREENS_FORWARD(j) { FOR_NSCREENS_FORWARD(j) {
if (j) memcpy (stuff + 1, extra, extra_len); if (j) memcpy (stuff + 1, extra, extra_len);
if (dst->u.pict.root) { if (dst->u.pict.root) {
int x_off = xineramaDataPtr[j].x; int x_off = panoramiXdataPtr[j].x;
int y_off = xineramaDataPtr[j].y; int y_off = panoramiXdataPtr[j].y;
if(x_off || y_off) { if(x_off || y_off) {
....; ....;
@ -2919,7 +2919,7 @@ XineramaRenderColorTriangles(ClientPtr client)
#endif #endif
void void
XineramaRenderInit (void) PanoramiXRenderInit (void)
{ {
int i; int i;
@ -2948,7 +2948,7 @@ XineramaRenderInit (void)
} }
void void
XineramaRenderReset (void) PanoramiXRenderReset (void)
{ {
int i; int i;
for (i = 0; i < RenderNumberRequests; i++) for (i = 0; i < RenderNumberRequests; i++)

12
xkb/ddxFakeMtn.c
View File

@ -1,4 +1,4 @@
/* $XdotOrg$ */ /* $XdotOrg: xc/programs/Xserver/xkb/ddxFakeMtn.c,v 1.1.4.4 2003/12/18 19:29:15 kaleb Exp $ */
/* $Xorg: ddxFakeMtn.c,v 1.3 2000/08/17 19:53:45 cpqbld Exp $ */ /* $Xorg: ddxFakeMtn.c,v 1.3 2000/08/17 19:53:45 cpqbld Exp $ */
/************************************************************ /************************************************************
Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc. Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
@ -39,8 +39,8 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include "XI.h" #include "XI.h"
#ifdef XINERAMA #ifdef XINERAMA
#include "xinerama.h" #include "panoramiX.h"
#include "xineramaSrv.h" #include "panoramiXsrv.h"
#endif #endif
#include "mipointer.h" #include "mipointer.h"
@ -56,7 +56,7 @@ ScreenPtr pScreen, oldScreen;
pScreen = oldScreen = GetSpriteWindow()->drawable.pScreen; pScreen = oldScreen = GetSpriteWindow()->drawable.pScreen;
#ifdef XINERAMA #ifdef XINERAMA
if (!noXineramaExtension) { if (!noPanoramiXExtension) {
BoxRec box; BoxRec box;
int i; int i;
@ -93,8 +93,8 @@ ScreenPtr pScreen, oldScreen;
} }
} }
} }
oldX -= xineramaDataPtr[pScreen->myNum].x; oldX -= panoramiXdataPtr[pScreen->myNum].x;
oldY -= xineramaDataPtr[pScreen->myNum].y; oldY -= panoramiXdataPtr[pScreen->myNum].y;
} }
else else
#endif #endif