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

Enable event delivery for multiple heads. 

Requires moving the spriteTrace into the DeviceIntRec and adjusting a few
functions to take in device argument, most notably XYToWindow().

Cursor rendering on the second screen is busted.
This commit is contained in:
Paulo Ricardo Zanoni 2007-04-26 15:58:50 +09:30 committed by Peter Hutterer
parent d61ed6c8a2
commit 82f97e1c0c
16 changed files with 143 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
XTrap/xtrapdi.c
View File

@ -102,7 +102,7 @@ globalref int_function XETrapProcVector[256L]; /* The "shadowed" ProcVector */
#ifndef VECTORED_EVENTS #ifndef VECTORED_EVENTS
globalref int_function EventProcVector[XETrapCoreEvents]; globalref int_function EventProcVector[XETrapCoreEvents];
#else #else
extern WindowPtr GetCurrentRootWindow(); extern WindowPtr GetCurrentRootWindow(DeviceIntPtr);
globalref int_function EventProcVector[128L]; globalref int_function EventProcVector[128L];
#endif #endif
static int_function keybd_process_inp = NULL; /* Used for VECTORED_EVENTS */ static int_function keybd_process_inp = NULL; /* Used for VECTORED_EVENTS */
@ -1620,7 +1620,9 @@ int XETrapEventVector(ClientPtr client, xEvent *x_event)
(x_event->u.u.type <= MotionNotify) && (x_event->u.u.type <= MotionNotify) &&
(!x_event->u.keyButtonPointer.sameScreen))) (!x_event->u.keyButtonPointer.sameScreen)))
{ /* we've moved/warped to another screen */ { /* we've moved/warped to another screen */
WindowPtr root_win = GetCurrentRootWindow(); /* XXX: we're getting the client's pointer root window.
* is this correct? Should it be the client's keyboard? */
WindowPtr root_win = GetCurrentRootWindow(PickPointer(client));
current_screen = root_win->drawable.pScreen->myNum; current_screen = root_win->drawable.pScreen->myNum;
} }
data.hdr.screen = current_screen; data.hdr.screen = current_screen;

2
Xext/xevie.c
View File

@ -463,7 +463,7 @@ XevieKbdProcessInputProc(xEvent *xE, DeviceIntPtr dev, int count)
xevieModifiersOn = TRUE; xevieModifiersOn = TRUE;
xE->u.keyButtonPointer.event = xeviewin->drawable.id; xE->u.keyButtonPointer.event = xeviewin->drawable.id;
xE->u.keyButtonPointer.root = GetCurrentRootWindow()->drawable.id; xE->u.keyButtonPointer.root = GetCurrentRootWindow(dev)->drawable.id;
xE->u.keyButtonPointer.child = (xeviewin->firstChild) xE->u.keyButtonPointer.child = (xeviewin->firstChild)
? xeviewin->firstChild->drawable.id:0; ? xeviewin->firstChild->drawable.id:0;
xE->u.keyButtonPointer.rootX = xeviehot.x; xE->u.keyButtonPointer.rootX = xeviehot.x;

6
Xext/xtest.c
View File

@ -363,7 +363,7 @@ ProcXTestFakeInput(client)
if (!dev) if (!dev)
dev = PickPointer(client); dev = PickPointer(client);
if (ev->u.keyButtonPointer.root == None) if (ev->u.keyButtonPointer.root == None)
root = GetCurrentRootWindow(); root = GetCurrentRootWindow(dev);
else else
{ {
rc = dixLookupWindow(&root, ev->u.keyButtonPointer.root, client, rc = dixLookupWindow(&root, ev->u.keyButtonPointer.root, client,
@ -428,10 +428,10 @@ ProcXTestFakeInput(client)
if ((!noPanoramiXExtension if ((!noPanoramiXExtension
&& root->drawable.pScreen->myNum && root->drawable.pScreen->myNum
!= XineramaGetCursorScreen(dev)) != XineramaGetCursorScreen(dev))
|| (noPanoramiXExtension && root != GetCurrentRootWindow())) || (noPanoramiXExtension && root != GetCurrentRootWindow(dev)))
#else #else
if (root != GetCurrentRootWindow()) if (root != GetCurrentRootWindow(dev))
#endif #endif
{ {
NewCurrentScreen(dev, root->drawable.pScreen, NewCurrentScreen(dev, root->drawable.pScreen,

2
Xi/exevents.c
View File

@ -835,7 +835,7 @@ SendEvent(ClientPtr client, DeviceIntPtr d, Window dest, Bool propagate,
/* If the input focus is PointerRootWin, send the event to where /* If the input focus is PointerRootWin, send the event to where
* the pointer is if possible, then perhaps propogate up to root. */ * the pointer is if possible, then perhaps propogate up to root. */
if (inputFocus == PointerRootWin) if (inputFocus == PointerRootWin)
inputFocus = GetCurrentRootWindow(); inputFocus = GetCurrentRootWindow(d);
if (IsParent(inputFocus, spriteWin)) { if (IsParent(inputFocus, spriteWin)) {
effectiveFocus = inputFocus; effectiveFocus = inputFocus;

2
Xi/querydp.c
View File

@ -107,7 +107,7 @@ ProcXQueryDevicePointer(ClientPtr client)
rep.length = 0; rep.length = 0;
rep.sequenceNumber = client->sequence; rep.sequenceNumber = client->sequence;
rep.mask = pDev->button->state | inputInfo.keyboard->key->state; rep.mask = pDev->button->state | inputInfo.keyboard->key->state;
rep.root = (GetCurrentRootWindow())->drawable.id; rep.root = (GetCurrentRootWindow(pDev))->drawable.id;
rep.rootX = pSprite->hot.x; rep.rootX = pSprite->hot.x;
rep.rootY = pSprite->hot.y; rep.rootY = pSprite->hot.y;
rep.child = None; rep.child = None;

24
dix/devices.c
View File

@ -194,6 +194,14 @@ EnableDevice(DeviceIntPtr dev)
*prev && (*prev != dev); *prev && (*prev != dev);
prev = &(*prev)->next) prev = &(*prev)->next)
; ;
/* Sprites will be initialized with their 'windows' just when inside the
* DefineInitialRootWindow function! */
if (IsPointerDevice(dev) && dev->spriteInfo->spriteOwner)
InitializeSprite(dev, NullWindow);
else
PairDevices(NULL, inputInfo.pointer, dev);
if ((*prev != dev) || !dev->inited || if ((*prev != dev) || !dev->inited ||
((ret = (*dev->deviceProc)(dev, DEVICE_ON)) != Success)) { ((ret = (*dev->deviceProc)(dev, DEVICE_ON)) != Success)) {
ErrorF("couldn't enable device %d\n", dev->id); ErrorF("couldn't enable device %d\n", dev->id);
@ -202,11 +210,6 @@ EnableDevice(DeviceIntPtr dev)
dev->enabled = TRUE; dev->enabled = TRUE;
*prev = dev->next; *prev = dev->next;
if (IsPointerDevice(dev) && dev->spriteInfo->spriteOwner)
InitializeSprite(dev, GetCurrentRootWindow());
else
PairDevices(NULL, inputInfo.pointer, dev);
for (prev = &inputInfo.devices; *prev; prev = &(*prev)->next) for (prev = &inputInfo.devices; *prev; prev = &(*prev)->next)
; ;
*prev = dev; *prev = dev;
@ -272,6 +275,11 @@ ActivateDevice(DeviceIntPtr dev)
return ret; return ret;
} }
int
DeactivateDevice(DeviceIntPtr dev)
{
}
static void static void
CoreKeyboardBell(int volume, DeviceIntPtr pDev, pointer arg, int something) CoreKeyboardBell(int volume, DeviceIntPtr pDev, pointer arg, int something)
{ {
@ -614,8 +622,10 @@ CloseDevice(DeviceIntPtr dev)
XkbRemoveResourceClient((DevicePtr)dev,dev->xkb_interest->resource); XkbRemoveResourceClient((DevicePtr)dev,dev->xkb_interest->resource);
#endif #endif
if (DevHasCursor(dev)) if (DevHasCursor(dev)) {
xfree((pointer)dev->spriteInfo->sprite); xfree(dev->spriteInfo->sprite->spriteTrace);
xfree(dev->spriteInfo->sprite);
}
/* a client may have the device set as client pointer */ /* a client may have the device set as client pointer */
for (j = 0; j < currentMaxClients; j++) for (j = 0; j < currentMaxClients; j++)

137
dix/events.c
View File

@ -230,15 +230,7 @@ static struct {
TimeStamp time; TimeStamp time;
} syncEvents; } syncEvents;
/* #define RootWindow(dev) dev->spriteInfo->sprite->spriteTrace[0]
* The window trace information is used to avoid having to compute all the
* windows between the root and the current pointer window each time a button
* or key goes down. The grabs on each of those windows must be checked.
*/
static WindowPtr *spriteTrace = (WindowPtr *)NULL;
#define ROOT spriteTrace[0]
static int spriteTraceSize = 0;
static int spriteTraceGood;
/** /**
* True if device owns a cursor, false if device shares a cursor sprite with * True if device owns a cursor, false if device shares a cursor sprite with
@ -284,6 +276,7 @@ static void DoEnterLeaveEvents(
); );
static WindowPtr XYToWindow( static WindowPtr XYToWindow(
DeviceIntPtr pDev,
int x, int x,
int y int y
); );
@ -607,7 +600,7 @@ XineramaCheckMotion(xEvent *xE, DeviceIntPtr pDev)
xeviehot.y = pSprite->hot.y; xeviehot.y = pSprite->hot.y;
xeviewin = xeviewin =
#endif #endif
pSprite->win = XYToWindow(pSprite->hot.x, pSprite->hot.y); pSprite->win = XYToWindow(pDev, pSprite->hot.x, pSprite->hot.y);
if (pSprite->win != prevSpriteWin) if (pSprite->win != prevSpriteWin)
{ {
@ -858,7 +851,7 @@ CheckVirtualMotion(
xeviehot.x = pSprite->hot.x; xeviehot.x = pSprite->hot.x;
xeviehot.y = pSprite->hot.y; xeviehot.y = pSprite->hot.y;
#endif #endif
ROOT = WindowTable[pSprite->hot.pScreen->myNum]; RootWindow(pDev) = WindowTable[pSprite->hot.pScreen->myNum];
} }
static void static void
@ -973,10 +966,15 @@ PostNewCursor(DeviceIntPtr pDev)
} }
} }
/**
* @param dev device which you want to know its current root window
* @return root window where dev's sprite is located
*/
_X_EXPORT WindowPtr _X_EXPORT WindowPtr
GetCurrentRootWindow(void) GetCurrentRootWindow(DeviceIntPtr dev)
{ {
return ROOT; return RootWindow(dev);
} }
_X_EXPORT WindowPtr _X_EXPORT WindowPtr
@ -1201,10 +1199,11 @@ ComputeFreezes(void)
count = replayDev->coreGrab.sync.evcount; count = replayDev->coreGrab.sync.evcount;
syncEvents.replayDev = (DeviceIntPtr)NULL; syncEvents.replayDev = (DeviceIntPtr)NULL;
w = XYToWindow( XE_KBPTR.rootX, XE_KBPTR.rootY); w = XYToWindow(replayDev, XE_KBPTR.rootX, XE_KBPTR.rootY);
for (i = 0; i < spriteTraceGood; i++) for (i = 0; i < replayDev->spriteInfo->sprite->spriteTraceGood; i++)
{ {
if (syncEvents.replayWin == spriteTrace[i]) if (syncEvents.replayWin ==
replayDev->spriteInfo->sprite->spriteTrace[i])
{ {
if (!CheckDeviceGrabs(replayDev, xE, i+1, count)) { if (!CheckDeviceGrabs(replayDev, xE, i+1, count)) {
if (replayDev->focus) if (replayDev->focus)
@ -1365,7 +1364,7 @@ DeactivatePointerGrab(DeviceIntPtr mouse)
DoEnterLeaveEvents(mouse, grab->window, DoEnterLeaveEvents(mouse, grab->window,
mouse->spriteInfo->sprite->win, NotifyUngrab); mouse->spriteInfo->sprite->win, NotifyUngrab);
if (grab->confineTo) if (grab->confineTo)
ConfineCursorToWindow(mouse, ROOT, FALSE, FALSE); ConfineCursorToWindow(mouse, RootWindow(mouse), FALSE, FALSE);
PostNewCursor(mouse); PostNewCursor(mouse);
if (grab->cursor) if (grab->cursor)
FreeCursor(grab->cursor, (Cursor)0); FreeCursor(grab->cursor, (Cursor)0);
@ -1888,7 +1887,7 @@ FixUpEventFromWindow(
if (calcChild) if (calcChild)
{ {
WindowPtr w=spriteTrace[spriteTraceGood-1]; WindowPtr w= pSprite->spriteTrace[pSprite->spriteTraceGood-1];
/* If the search ends up past the root should the child field be /* If the search ends up past the root should the child field be
set to none or should the value in the argument be passed set to none or should the value in the argument be passed
through. It probably doesn't matter since everyone calls through. It probably doesn't matter since everyone calls
@ -1913,7 +1912,7 @@ FixUpEventFromWindow(
w = w->parent; w = w->parent;
} }
} }
XE_KBPTR.root = ROOT->drawable.id; XE_KBPTR.root = RootWindow(pDev)->drawable.id;
XE_KBPTR.event = pWin->drawable.id; XE_KBPTR.event = pWin->drawable.id;
if (pSprite->hot.pScreen == pWin->drawable.pScreen) if (pSprite->hot.pScreen == pWin->drawable.pScreen)
{ {
@ -2064,13 +2063,15 @@ PointInBorderSize(WindowPtr pWin, int x, int y)
} }
static WindowPtr static WindowPtr
XYToWindow(int x, int y) XYToWindow(DeviceIntPtr pDev, int x, int y)
{ {
WindowPtr pWin; WindowPtr pWin;
BoxRec box; BoxRec box;
SpritePtr pSprite;
spriteTraceGood = 1; /* root window still there */ pSprite = pDev->spriteInfo->sprite;
pWin = ROOT->firstChild; pSprite->spriteTraceGood = 1; /* root window still there */
pWin = RootWindow(pDev)->firstChild;
while (pWin) while (pWin)
{ {
if ((pWin->mapped) && if ((pWin->mapped) &&
@ -2094,21 +2095,22 @@ XYToWindow(int x, int y)
#endif #endif
) )
{ {
if (spriteTraceGood >= spriteTraceSize) if (pSprite->spriteTraceGood >= pSprite->spriteTraceSize)
{ {
spriteTraceSize += 10; pSprite->spriteTraceSize += 10;
Must_have_memory = TRUE; /* XXX */ Must_have_memory = TRUE; /* XXX */
spriteTrace = (WindowPtr *)xrealloc( pSprite->spriteTrace = (WindowPtr *)xrealloc(
spriteTrace, spriteTraceSize*sizeof(WindowPtr)); pSprite->spriteTrace,
pSprite->spriteTraceSize*sizeof(WindowPtr));
Must_have_memory = FALSE; /* XXX */ Must_have_memory = FALSE; /* XXX */
} }
spriteTrace[spriteTraceGood++] = pWin; pSprite->spriteTrace[pSprite->spriteTraceGood++] = pWin;
pWin = pWin->firstChild; pWin = pWin->firstChild;
} }
else else
pWin = pWin->nextSib; pWin = pWin->nextSib;
} }
return spriteTrace[spriteTraceGood-1]; return pSprite->spriteTrace[pSprite->spriteTraceGood-1];
} }
Bool Bool
@ -2129,7 +2131,7 @@ CheckMotion(xEvent *xE, DeviceIntPtr pDev)
if (pSprite->hot.pScreen != pSprite->hotPhys.pScreen) if (pSprite->hot.pScreen != pSprite->hotPhys.pScreen)
{ {
pSprite->hot.pScreen = pSprite->hotPhys.pScreen; pSprite->hot.pScreen = pSprite->hotPhys.pScreen;
ROOT = WindowTable[pSprite->hot.pScreen->myNum]; RootWindow(pDev) = WindowTable[pSprite->hot.pScreen->myNum];
} }
pSprite->hot.x = XE_KBPTR.rootX; pSprite->hot.x = XE_KBPTR.rootX;
pSprite->hot.y = XE_KBPTR.rootY; pSprite->hot.y = XE_KBPTR.rootY;
@ -2166,7 +2168,7 @@ CheckMotion(xEvent *xE, DeviceIntPtr pDev)
#ifdef XEVIE #ifdef XEVIE
xeviewin = xeviewin =
#endif #endif
pSprite->win = XYToWindow(pSprite->hot.x, pSprite->hot.y); pSprite->win = XYToWindow(pDev, pSprite->hot.x, pSprite->hot.y);
#ifdef notyet #ifdef notyet
if (!(pSprite->win->deliverableEvents & if (!(pSprite->win->deliverableEvents &
Motion_Filter(pDev->button)) Motion_Filter(pDev->button))
@ -2263,7 +2265,6 @@ DefineInitialRootWindow(WindowPtr win)
#ifdef XEVIE #ifdef XEVIE
xeviewin = win; xeviewin = win;
#endif #endif
ROOT = win;
InitializeSprite(inputInfo.pointer, win); InitializeSprite(inputInfo.pointer, win);
@ -2312,8 +2313,25 @@ InitializeSprite(DeviceIntPtr pDev, WindowPtr pWin)
{ {
pSprite->current = wCursor(pWin); pSprite->current = wCursor(pWin);
pSprite->current->refcnt++; pSprite->current->refcnt++;
} else pSprite->spriteTrace = (WindowPtr *)xcalloc(1, 32*sizeof(WindowPtr));
if (!pSprite->spriteTrace)
FatalError("Failed to allocate spriteTrace");
pSprite->spriteTraceSize = 32;
RootWindow(pDev) = pWin;
pSprite->spriteTraceGood = 1;
pSprite->pEnqueueScreen = pScreen;
pSprite->pDequeueScreen = pSprite->pEnqueueScreen;
} else {
pSprite->current = NullCursor; pSprite->current = NullCursor;
pSprite->spriteTrace = NULL;
pSprite->spriteTraceSize = 0;
pSprite->spriteTraceGood = 0;
pSprite->pEnqueueScreen = screenInfo.screens[0];
pSprite->pDequeueScreen = pSprite->pEnqueueScreen;
}
if (pScreen) if (pScreen)
{ {
@ -2768,14 +2786,15 @@ CheckDeviceGrabs(DeviceIntPtr device, xEvent *xE,
} }
if ((focus->win == NoneWin) || if ((focus->win == NoneWin) ||
(i >= spriteTraceGood) || (i >= device->spriteInfo->sprite->spriteTraceGood) ||
((i > checkFirst) && (pWin != spriteTrace[i-1]))) ((i > checkFirst) &&
(pWin != device->spriteInfo->sprite->spriteTrace[i-1])))
return FALSE; return FALSE;
} }
for (; i < spriteTraceGood; i++) for (; i < device->spriteInfo->sprite->spriteTraceGood; i++)
{ {
pWin = spriteTrace[i]; pWin = device->spriteInfo->sprite->spriteTrace[i];
if (pWin->optional && if (pWin->optional &&
CheckPassiveGrabsOnWindow(pWin, device, xE, count)) CheckPassiveGrabsOnWindow(pWin, device, xE, count))
return TRUE; return TRUE;
@ -2946,7 +2965,7 @@ ProcessKeyboardEvent (xEvent *xE, DeviceIntPtr keybd, int count)
{ {
xeviekb = keybd; xeviekb = keybd;
if(!rootWin) { if(!rootWin) {
rootWin = GetCurrentRootWindow()->drawable.id; rootWin = GetCurrentRootWindow(keybd)->drawable.id;
} }
xE->u.keyButtonPointer.event = xeviewin->drawable.id; xE->u.keyButtonPointer.event = xeviewin->drawable.id;
xE->u.keyButtonPointer.root = rootWin; xE->u.keyButtonPointer.root = rootWin;
@ -3806,8 +3825,8 @@ DoFocusEvents(DeviceIntPtr dev, WindowPtr fromWin, WindowPtr toWin, int mode)
if ((fromWin == NullWindow) || (fromWin == PointerRootWin)) if ((fromWin == NullWindow) || (fromWin == PointerRootWin))
{ {
if (fromWin == PointerRootWin) if (fromWin == PointerRootWin)
FocusOutEvents(dev, pSprite->win, ROOT, mode, FocusOutEvents(dev, pSprite->win, RootWindow(dev), mode,
NotifyPointer, TRUE); NotifyPointer, TRUE);
/* Notify all the roots */ /* Notify all the roots */
#ifdef PANORAMIX #ifdef PANORAMIX
if ( !noPanoramiXExtension ) if ( !noPanoramiXExtension )
@ -3836,16 +3855,16 @@ DoFocusEvents(DeviceIntPtr dev, WindowPtr fromWin, WindowPtr toWin, int mode)
for (i=0; i<screenInfo.numScreens; i++) for (i=0; i<screenInfo.numScreens; i++)
FocusEvent(dev, FocusIn, mode, in, WindowTable[i]); FocusEvent(dev, FocusIn, mode, in, WindowTable[i]);
if (toWin == PointerRootWin) if (toWin == PointerRootWin)
(void)FocusInEvents(dev, ROOT, pSprite->win, NullWindow, mode, (void)FocusInEvents(dev, RootWindow(dev), pSprite->win,
NotifyPointer, TRUE); NullWindow, mode, NotifyPointer, TRUE);
} }
else else
{ {
if ((fromWin == NullWindow) || (fromWin == PointerRootWin)) if ((fromWin == NullWindow) || (fromWin == PointerRootWin))
{ {
if (fromWin == PointerRootWin) if (fromWin == PointerRootWin)
FocusOutEvents(dev, pSprite->win, ROOT, mode, NotifyPointer, FocusOutEvents(dev, pSprite->win, RootWindow(dev), mode,
TRUE); NotifyPointer, TRUE);
#ifdef PANORAMIX #ifdef PANORAMIX
if ( !noPanoramiXExtension ) if ( !noPanoramiXExtension )
FocusEvent(dev, FocusOut, mode, out, WindowTable[0]); FocusEvent(dev, FocusOut, mode, out, WindowTable[0]);
@ -3854,7 +3873,7 @@ DoFocusEvents(DeviceIntPtr dev, WindowPtr fromWin, WindowPtr toWin, int mode)
for (i=0; i<screenInfo.numScreens; i++) for (i=0; i<screenInfo.numScreens; i++)
FocusEvent(dev, FocusOut, mode, out, WindowTable[i]); FocusEvent(dev, FocusOut, mode, out, WindowTable[i]);
if (toWin->parent != NullWindow) if (toWin->parent != NullWindow)
(void)FocusInEvents(dev, ROOT, toWin, toWin, mode, (void)FocusInEvents(dev, RootWindow(dev), toWin, toWin, mode,
NotifyNonlinearVirtual, TRUE); NotifyNonlinearVirtual, TRUE);
FocusEvent(dev, FocusIn, mode, NotifyNonlinear, toWin); FocusEvent(dev, FocusIn, mode, NotifyNonlinear, toWin);
if (IsParent(toWin, pSprite->win)) if (IsParent(toWin, pSprite->win))
@ -4130,7 +4149,7 @@ ProcGrabPointer(ClientPtr client)
if (grab) if (grab)
{ {
if (grab->confineTo && !confineTo) if (grab->confineTo && !confineTo)
ConfineCursorToWindow(device, ROOT, FALSE, FALSE); ConfineCursorToWindow(device, RootWindow(device), FALSE, FALSE);
oldCursor = grab->cursor; oldCursor = grab->cursor;
} }
tempGrab.cursor = cursor; tempGrab.cursor = cursor;
@ -4351,7 +4370,7 @@ ProcQueryPointer(ClientPtr client)
rep.sequenceNumber = client->sequence; rep.sequenceNumber = client->sequence;
rep.mask = mouse->button->state | inputInfo.keyboard->key->state; rep.mask = mouse->button->state | inputInfo.keyboard->key->state;
rep.length = 0; rep.length = 0;
rep.root = (ROOT)->drawable.id; rep.root = (RootWindow(mouse))->drawable.id;
rep.rootX = pSprite->hot.x; rep.rootX = pSprite->hot.x;
rep.rootY = pSprite->hot.y; rep.rootY = pSprite->hot.y;
rep.child = None; rep.child = None;
@ -4400,19 +4419,6 @@ InitEvents(void)
inputInfo.off_devices = (DeviceIntPtr)NULL; inputInfo.off_devices = (DeviceIntPtr)NULL;
inputInfo.keyboard = (DeviceIntPtr)NULL; inputInfo.keyboard = (DeviceIntPtr)NULL;
inputInfo.pointer = (DeviceIntPtr)NULL; inputInfo.pointer = (DeviceIntPtr)NULL;
if (spriteTraceSize == 0)
{
spriteTraceSize = 32;
spriteTrace = (WindowPtr *)xalloc(32*sizeof(WindowPtr));
/* FIXME: spriteTrace[0] needs to be NULL, otherwise
* GetCurrentRootWindow() in EnableDevice() may return a invalid
* value. (whot)
*/
memset(spriteTrace, 0, 32 * sizeof(WindowPtr));
if (!spriteTrace)
FatalError("failed to allocate spriteTrace");
}
spriteTraceGood = 0;
lastEventMask = OwnerGrabButtonMask; lastEventMask = OwnerGrabButtonMask;
filters[MotionNotify] = PointerMotionMask; filters[MotionNotify] = PointerMotionMask;
#ifdef XEVIE #ifdef XEVIE
@ -4441,13 +4447,14 @@ InitEvents(void)
} }
} }
/**
void * This function is deprecated! It shouldn't be used anymore. It used to free
* the spriteTraces, but now they are freed when the SpriteRec is freed.
*/
_X_DEPRECATED void
CloseDownEvents(void) CloseDownEvents(void)
{ {
xfree(spriteTrace);
spriteTrace = NULL;
spriteTraceSize = 0;
} }
int int
@ -4497,7 +4504,7 @@ ProcSendEvent(ClientPtr client)
/* If the input focus is PointerRootWin, send the event to where /* If the input focus is PointerRootWin, send the event to where
the pointer is if possible, then perhaps propogate up to root. */ the pointer is if possible, then perhaps propogate up to root. */
if (inputFocus == PointerRootWin) if (inputFocus == PointerRootWin)
inputFocus = ROOT; inputFocus = pSprite->spriteTrace[0]; /* Root window! */
if (IsParent(inputFocus, pSprite->win)) if (IsParent(inputFocus, pSprite->win))
{ {

1
dix/main.c
View File

@ -498,7 +498,6 @@ main(int argc, char *argv[], char *envp[])
FreeScreen(screenInfo.screens[i]); FreeScreen(screenInfo.screens[i]);
screenInfo.numScreens = i; screenInfo.numScreens = i;
} }
CloseDownEvents();
xfree(WindowTable); xfree(WindowTable);
WindowTable = NULL; WindowTable = NULL;
FreeFonts(); FreeFonts();

8
hw/xwin/winwin32rootlesswndproc.c
View File

@ -299,7 +299,9 @@ IsRaiseOnClick (WindowPtr pWin)
struct _Window *pwin; struct _Window *pwin;
struct _Property *prop; struct _Property *prop;
WindowPtr pRoot = GetCurrentRootWindow (); /* XXX We're getting inputInfo.poniter here, but this might be really wrong.
* Which pointer's current window do we want? */
WindowPtr pRoot = GetCurrentRootWindow (inputInfo.pointer);
if (!pWin) if (!pWin)
{ {
@ -352,7 +354,9 @@ IsMouseActive (WindowPtr pWin)
struct _Window *pwin; struct _Window *pwin;
struct _Property *prop; struct _Property *prop;
WindowPtr pRoot = GetCurrentRootWindow (); /* XXX We're getting inputInfo.poniter here, but this might be really wrong.
* Which pointer's current window do we want? */
WindowPtr pRoot = GetCurrentRootWindow (inputInfo.pointer);
if (!pWin) if (!pWin)
{ {

2
include/dix.h
View File

@ -357,7 +357,7 @@ extern Bool IsParent(
WindowPtr /* maybeparent */, WindowPtr /* maybeparent */,
WindowPtr /* child */); WindowPtr /* child */);
extern WindowPtr GetCurrentRootWindow(void); extern WindowPtr GetCurrentRootWindow(DeviceIntPtr pDev);
extern WindowPtr GetSpriteWindow(DeviceIntPtr pDev); extern WindowPtr GetSpriteWindow(DeviceIntPtr pDev);

12
include/inputstr.h
View File

@ -287,6 +287,18 @@ typedef struct {
WindowPtr windows[MAXSCREENS]; WindowPtr windows[MAXSCREENS];
WindowPtr confineWin; /* confine window */ WindowPtr confineWin; /* confine window */
#endif #endif
/* The window trace information is used at dix/events.c to avoid having
* to compute all the windows between the root and the current pointer
* window each time a button or key goes down. The grabs on each of those
* windows must be checked.
* spriteTraces should only be used at dix/events.c! */
WindowPtr *spriteTrace;
int spriteTraceSize;
int spriteTraceGood;
ScreenPtr pEnqueueScreen; /* screen events are being delivered to */
ScreenPtr pDequeueScreen; /* screen events are being dispatched to */
} SpriteRec, *SpritePtr; } SpriteRec, *SpritePtr;
/* states for devices */ /* states for devices */

1
mi/mi.h
View File

@ -158,6 +158,7 @@ extern void mieqEnqueue(
); );
extern void mieqSwitchScreen( extern void mieqSwitchScreen(
DeviceIntPtr /* pDev */,
ScreenPtr /*pScreen*/, ScreenPtr /*pScreen*/,
Bool /*fromDIX*/ Bool /*fromDIX*/
); );

24
mi/mieq.c
View File

@ -67,6 +67,9 @@ in this Software without prior written authorization from The Open Group.
#define QUEUE_SIZE 512 #define QUEUE_SIZE 512
#define EnqueueScreen(dev) dev->spriteInfo->sprite->pEnqueueScreen
#define DequeueScreen(dev) dev->spriteInfo->sprite->pDequeueScreen
typedef struct _Event { typedef struct _Event {
xEvent event[7]; xEvent event[7];
int nevents; int nevents;
@ -79,8 +82,6 @@ typedef struct _EventQueue {
CARD32 lastEventTime; /* to avoid time running backwards */ CARD32 lastEventTime; /* to avoid time running backwards */
int lastMotion; /* device ID if last event motion? */ int lastMotion; /* device ID if last event motion? */
EventRec events[QUEUE_SIZE]; /* static allocation for signals */ EventRec events[QUEUE_SIZE]; /* static allocation for signals */
ScreenPtr pEnqueueScreen; /* screen events are being delivered to */
ScreenPtr pDequeueScreen; /* screen events are being dispatched to */
mieqHandler handlers[128]; /* custom event handler */ mieqHandler handlers[128]; /* custom event handler */
} EventQueueRec, *EventQueuePtr; } EventQueueRec, *EventQueuePtr;
@ -94,8 +95,6 @@ mieqInit(void)
miEventQueue.head = miEventQueue.tail = 0; miEventQueue.head = miEventQueue.tail = 0;
miEventQueue.lastEventTime = GetTimeInMillis (); miEventQueue.lastEventTime = GetTimeInMillis ();
miEventQueue.lastMotion = FALSE; miEventQueue.lastMotion = FALSE;
miEventQueue.pEnqueueScreen = screenInfo.screens[0];
miEventQueue.pDequeueScreen = miEventQueue.pEnqueueScreen;
for (i = 0; i < 128; i++) for (i = 0; i < 128; i++)
miEventQueue.handlers[i] = NULL; miEventQueue.handlers[i] = NULL;
SetInputCheck(&miEventQueue.head, &miEventQueue.tail); SetInputCheck(&miEventQueue.head, &miEventQueue.tail);
@ -179,18 +178,18 @@ mieqEnqueue(DeviceIntPtr pDev, xEvent *e)
miEventQueue.lastEventTime = miEventQueue.lastEventTime =
miEventQueue.events[oldtail].event[0].u.keyButtonPointer.time; miEventQueue.events[oldtail].event[0].u.keyButtonPointer.time;
miEventQueue.events[oldtail].pScreen = miEventQueue.pEnqueueScreen; miEventQueue.events[oldtail].pScreen = EnqueueScreen(pDev);
miEventQueue.events[oldtail].pDev = pDev; miEventQueue.events[oldtail].pDev = pDev;
miEventQueue.lastMotion = isMotion; miEventQueue.lastMotion = isMotion;
} }
void void
mieqSwitchScreen(ScreenPtr pScreen, Bool fromDIX) mieqSwitchScreen(DeviceIntPtr pDev, ScreenPtr pScreen, Bool fromDIX)
{ {
miEventQueue.pEnqueueScreen = pScreen; EnqueueScreen(pDev) = pScreen;
if (fromDIX) if (fromDIX)
miEventQueue.pDequeueScreen = pScreen; DequeueScreen(pDev) = pScreen;
} }
void void
@ -224,15 +223,15 @@ mieqProcessInputEvents(void)
e = &miEventQueue.events[miEventQueue.head]; e = &miEventQueue.events[miEventQueue.head];
/* Assumption - screen switching can only occur on motion events. */ /* Assumption - screen switching can only occur on motion events. */
if (e->pScreen != miEventQueue.pDequeueScreen) { if (e->pScreen != DequeueScreen(e->pDev)) {
miEventQueue.pDequeueScreen = e->pScreen; DequeueScreen(e->pDev) = e->pScreen;
x = e->event[0].u.keyButtonPointer.rootX; x = e->event[0].u.keyButtonPointer.rootX;
y = e->event[0].u.keyButtonPointer.rootY; y = e->event[0].u.keyButtonPointer.rootY;
if (miEventQueue.head == QUEUE_SIZE - 1) if (miEventQueue.head == QUEUE_SIZE - 1)
miEventQueue.head = 0; miEventQueue.head = 0;
else else
++miEventQueue.head; ++miEventQueue.head;
NewCurrentScreen (e->pDev, miEventQueue.pDequeueScreen, x, y); NewCurrentScreen (e->pDev, DequeueScreen(e->pDev), x, y);
} }
else { else {
if (miEventQueue.head == QUEUE_SIZE - 1) if (miEventQueue.head == QUEUE_SIZE - 1)
@ -243,7 +242,8 @@ mieqProcessInputEvents(void)
/* If someone's registered a custom event handler, let them /* If someone's registered a custom event handler, let them
* steal it. */ * steal it. */
if (miEventQueue.handlers[e->event->u.u.type]) { if (miEventQueue.handlers[e->event->u.u.type]) {
miEventQueue.handlers[e->event->u.u.type](miEventQueue.pDequeueScreen->myNum, miEventQueue.handlers[e->event->u.u.type](
DequeueScreen(e->pDev)->myNum,
e->event, dev, e->event, dev,
e->nevents); e->nevents);
return; return;

7
mi/mipointer.c
View File

@ -351,7 +351,7 @@ miPointerWarpCursor (pDev, pScreen, x, y)
SetupScreen (pScreen); SetupScreen (pScreen);
if (pPointer->pScreen != pScreen) if (pPointer->pScreen != pScreen)
(*pScreenPriv->screenFuncs->NewEventScreen) (pScreen, TRUE); (*pScreenPriv->screenFuncs->NewEventScreen) (pDev, pScreen, TRUE);
if (GenerateEvent) if (GenerateEvent)
{ {
@ -492,7 +492,7 @@ miPointerSetScreen(DeviceIntPtr pDev, int screen_no, int x, int y)
pScreen = screenInfo.screens[screen_no]; pScreen = screenInfo.screens[screen_no];
pScreenPriv = GetScreenPrivate (pScreen); pScreenPriv = GetScreenPrivate (pScreen);
(*pScreenPriv->screenFuncs->NewEventScreen) (pScreen, FALSE); (*pScreenPriv->screenFuncs->NewEventScreen) (pDev, pScreen, FALSE);
NewCurrentScreen (pDev, pScreen, x, y); NewCurrentScreen (pDev, pScreen, x, y);
pPointer->limits.x2 = pScreen->width; pPointer->limits.x2 = pScreen->width;
@ -570,7 +570,8 @@ miPointerSetPosition(DeviceIntPtr pDev, int *x, int *y, unsigned long time)
if (newScreen != pScreen) if (newScreen != pScreen)
{ {
pScreen = newScreen; pScreen = newScreen;
(*pScreenPriv->screenFuncs->NewEventScreen) (pScreen, FALSE); (*pScreenPriv->screenFuncs->NewEventScreen) (pDev, pScreen,
FALSE);
pScreenPriv = GetScreenPrivate (pScreen); pScreenPriv = GetScreenPrivate (pScreen);
/* Smash the confine to the new screen */ /* Smash the confine to the new screen */
pPointer->limits.x2 = pScreen->width; pPointer->limits.x2 = pScreen->width;

1
mi/mipointer.h
View File

@ -88,6 +88,7 @@ typedef struct _miPointerScreenFuncRec {
xEventPtr /* event */ xEventPtr /* event */
); );
void (*NewEventScreen)( void (*NewEventScreen)(
DeviceIntPtr /* pDev */,
ScreenPtr /* pScr */, ScreenPtr /* pScr */,
Bool /* fromDIX */ Bool /* fromDIX */
); );

8
randr/rrpointer.c
View File

@ -135,10 +135,16 @@ RRPointerMoved (ScreenPtr pScreen, int x, int y)
void void
RRPointerScreenConfigured (ScreenPtr pScreen) RRPointerScreenConfigured (ScreenPtr pScreen)
{ {
WindowPtr pRoot = GetCurrentRootWindow (); WindowPtr pRoot = GetCurrentRootWindow (inputInfo.pointer);
ScreenPtr pCurrentScreen = pRoot ? pRoot->drawable.pScreen : NULL; ScreenPtr pCurrentScreen = pRoot ? pRoot->drawable.pScreen : NULL;
int x, y; int x, y;
/* XXX: GetCurrentRootWindow revices an argument, It is inputInfo.pointer,
* but I really think this is wrong... What do we do here? This was made so
* that it can compile, but I don't think randr should assume there is just
* one pointer. There might be more than one pointer on the screen! So, what
* to do? What happens? */
if (pScreen != pCurrentScreen) if (pScreen != pCurrentScreen)
return; return;
GetSpritePosition(inputInfo.pointer, &x, &y); GetSpritePosition(inputInfo.pointer, &x, &y);