/************************************************************
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts,
and the Massachusetts Institute of Technology, Cambridge, Massachusetts.

                        All Rights Reserved

Permission to use, copy, modify, and distribute this software and its 
documentation for any purpose and without fee is hereby granted, 
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in 
supporting documentation, and that the names of Digital or MIT not be
used in advertising or publicity pertaining to distribution of the
software without specific, written prior permission.  

DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.

********************************************************/


/* $Header: events.c,v 1.76 87/06/24 14:48:52 swick Exp $ */

#include "X.h"
#include "misc.h"
#include "resource.h"
#define NEED_EVENTS
#define NEED_REPLIES
#include "Xproto.h"
#include "windowstr.h"
#include "inputstr.h"
#include "scrnintstr.h"
#include "cursorstr.h"

#include "dixstruct.h"
#include "opaque.h"

extern WindowRec WindowTable[];
extern int swappedClients[];
extern Bool IsParent();

extern int (* EventSwapVector[128]) ();
extern int (* ReplySwapVector[256]) ();

#define NoSuchEvent 0x80000000	/* so doesn't match NoEventMask */
#define StructureAndSubMask ( StructureNotifyMask | SubstructureNotifyMask )
#define AllButtonsMask ( \
	Button1Mask | Button2Mask | Button3Mask | Button4Mask | Button5Mask )
#define MotionMask ( \
	PointerMotionMask | PointerMotionHintMask | Button1MotionMask | \
	Button2MotionMask | Button3MotionMask | Button4MotionMask | \
	Button5MotionMask | ButtonMotionMask )
#define PropagateMask ( \
	KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | \
	MotionMask )
#define AllModifiersMask ( \
	ShiftMask | LockMask | ControlMask | Mod1Mask | Mod2Mask | \
	Mod3Mask | Mod4Mask | Mod5Mask )
#define Motion_Filter(state) (PointerMotionMask | \
		(AllButtonsMask & state) | buttonMotionMask);


#define WID(w) ((w) ? ((w)->wid) : 0)

#define BitOn(ptr, bit) \
	((BYTE *) (ptr))[(bit)>>3] |= (1 << ((bit) & 7))
#define BitOff(ptr, bit) \
	((BYTE *) (ptr))[(bit)>>3] &= ~(1 << ((bit) & 7))
#define IsOn(ptr, bit) \
	(((BYTE *) (ptr))[(bit)>>3] & (1 << ((bit) & 7)))

debug_events = 0;
InputInfo inputInfo;

KeySymsRec curKeySyms;

GrabRec keybdGrab;	/* used for active grabs */
GrabRec ptrGrab;

#define MAX_QUEUED_EVENTS 100
struct {
    unsigned int	num;
    QdEventRec		pending, free;	/* only forw, back used */
    DeviceIntPtr	replayDev;	/* kludgy rock to put flag for */
    WindowPtr		replayWin;	/*   ComputeFreezes            */
    Bool		playingEvents;
} syncEvents;

/*
 * 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.
 */
WindowPtr *spriteTrace = (WindowPtr *)NULL;
#define ROOT spriteTrace[0]
int spriteTraceSize = 0;
int spriteTraceGood;

WindowPtr *focusTrace = (WindowPtr *)NULL;
int focusTraceSize = 0;
int focusTraceGood;

CARD16 keyButtonState = 0;
int buttonsDown = 0;		/* number of buttons currently down */
Mask buttonMotionMask = 0;

typedef struct {
    int		x, y;
} HotSpot;

struct {
    CursorPtr	current;
    BoxRec	hotLimits;	/* logical constraints */
    BoxRec	physLimits;	/* of hot spot due to hardware limits */
    WindowPtr	win;
    HotSpot	hot;
} sprite;			/* info about the cursor sprite */

Bool lastWasMotion;

extern void DoEnterLeaveEvents();	/* merely forward declarations */
extern WindowPtr XYToWindow();
extern Bool CheckKeyboardGrabs();
extern void NormalKeyboardEvent();
extern int DeliverDeviceEvents();

ScreenPtr currentScreen;

CARD16 stateMasks[MAP_LENGTH];	/* only for default keyboard ? XXX */

int lastEventMask;

#define CantBeFiltered NoEventMask
int filters[128] =
{
	NoSuchEvent,		       /* 0 */
	NoSuchEvent,		       /* 1 */
	KeyPressMask,		       /* KeyPress */
	KeyReleaseMask,		       /* KeyRelease */
	ButtonPressMask,	       /* ButtonPress */
	ButtonReleaseMask,	       /* ButtonRelease */
	MotionMask,		       /* MotionNotify - special cased */
	EnterWindowMask,	       /* EnterNotify */
	LeaveWindowMask,	       /* LeaveNotify */
	FocusChangeMask,	       /* FocusIn */
	FocusChangeMask,	       /* FocusOut */
	KeymapStateMask,	       /* KeymapNotify */
	ExposureMask,		       /* Expose */
	CantBeFiltered,		       /* GraphicsExpose */
	CantBeFiltered,		       /* NoExpose */
	VisibilityChangeMask,	       /* VisibilityNotify */
	SubstructureNotifyMask,	       /* CreateNotify */
	StructureAndSubMask,	       /* DestroyNotify */
	StructureAndSubMask,	       /* UnmapNotify */
	StructureAndSubMask,	       /* MapNotify */
	SubstructureRedirectMask,      /* MapRequest */
	SubstructureNotifyMask,	       /* ReparentNotify */
	StructureAndSubMask,	       /* ConfigureNotify */
	SubstructureRedirectMask,      /* ConfigureRequest */
	StructureAndSubMask,	       /* GravityNotify */
	ResizeRedirectMask,	       /* ResizeRequest */
	StructureAndSubMask,	       /* CirculateNotify */
	SubstructureRedirectMask,      /* CirculateRequest */
	PropertyChangeMask,	       /* PropertyNotify */
	CantBeFiltered,		       /* SelectionClear */
	CantBeFiltered,		       /* SelectionRequest */
	CantBeFiltered,		       /* SelectionNotify */
	ColormapChangeMask,	       /* ColormapNotify */
	CantBeFiltered		       /* InterpretNotify */
};

Mask
GetNextEventMask()
{
    lastEventMask <<= 1;
    return lastEventMask;
}

void
SetMaskForEvent(mask, event)
    Mask mask;
    int event;
{
    if ((event < LASTEvent) || (event >= 128))
	FatalError("MaskForEvent: bogus event number");
    filters[event] = mask;
}

static void
CheckPhysLimits(cursor)
    CursorPtr cursor;
{
    HotSpot old;

    if (!cursor)
	return;
    old = sprite.hot;
    (*currentScreen->CursorLimits) (
	currentScreen, cursor, &sprite.hotLimits, &sprite.physLimits);
/*
 * Notice that the following adjustments leave the hot spot not really where
 * it would be if you looked at the screen. This is probably the right thing
 * to do since the user does not want the hot spot to move just because the
 * hardware cannot display the physical sprite where we would like it. The
 * next time the pointer device moves, the hot spot will then "jump" to its
 * visual position.
 */
    if (sprite.hot.x < sprite.physLimits.x1)
	sprite.hot.x = sprite.physLimits.x1;
    else
	if (sprite.hot.x >= sprite.physLimits.x2)
	    sprite.hot.x = sprite.physLimits.x2 - 1;
    if (sprite.hot.y < sprite.physLimits.y1)
	sprite.hot.y = sprite.physLimits.y1;
    else
	if (sprite.hot.y >= sprite.physLimits.y2)
	    sprite.hot.y = sprite.physLimits.y2 - 1;
    if ((old.x != sprite.hot.x) || (old.y != sprite.hot.y))
	(*currentScreen->SetCursorPosition) (
	    currentScreen, sprite.hot.x, sprite.hot.y);
}

static void
NewCursorConfines(x1, x2, y1, y2)
    int x1, x2, y1, y2;
{
    sprite.hotLimits.x1 = x1;
    sprite.hotLimits.x2 = x2;
    sprite.hotLimits.y1 = y1;
    sprite.hotLimits.y2 = y2;
    CheckPhysLimits(sprite.current);
    (* currentScreen->ConstrainCursor)(currentScreen, &sprite.physLimits);
}

void
ChangeToCursor(cursor)
    CursorPtr cursor;
{
    if (!cursor)
	FatalError("Somebody is setting NullCursor");
    if (cursor != sprite.current)
    {
	if ((sprite.current->xhot != cursor->xhot) ||
		(sprite.current->yhot != cursor->yhot))
	    CheckPhysLimits(cursor);
	(*currentScreen->DisplayCursor) (
	   currentScreen, cursor, sprite.hot.x, sprite.hot.y);
	sprite.current = cursor;
    }
}

void
PostNewCursor()
{
    register    WindowPtr win;
    register    GrabPtr grab = inputInfo.pointer->grab;
    if (grab)
    {
	if (grab->u.ptr.cursor)
	{
	    ChangeToCursor(grab->u.ptr.cursor);
	    return;
	}
	if (IsParent(grab->window, sprite.win))
	    win = sprite.win;
	else
	    win = grab->window;
    }
    else
	win = sprite.win;
    for (; win; win = win->parent)
	if (win->cursor != NullCursor)
	{
	    ChangeToCursor(win->cursor);
	    return;
	}
}

/**************************************************************************
 *            The following procedures deal with synchronous events       *
 **************************************************************************/

void
EnqueueEvent(device, event)
    xEvent		*event;
    DeviceIntPtr	device;
{
    register QdEventPtr tail = syncEvents.pending.back;
    register QdEventPtr new;
/*
 * Collapsing of mouse events does not bother to test if qdEvents.num == 0,
 * since there will never be MotionNotify in the type of the head event which
 * is what last points at when num == 0.
 */
    if ((event->u.u.type == MotionNotify) && 
	(tail->event.u.u.type == MotionNotify))
    {
	tail->event = *event;
	return;
    }
    syncEvents.num++;
    if (syncEvents.free.forw == &syncEvents.free)
	new = (QdEventPtr)Xalloc(sizeof(QdEventRec));
    else
    {
	new = syncEvents.free.forw;
	remque(new);
    }
    new->device = device;
    new->event = *event;
    insque(new, tail);
    if (syncEvents.num > MAX_QUEUED_EVENTS)
    {
	/* XXX here we send all the pending events and break the locks */
	return;
    }
}

static void
PlayReleasedEvents()
{
    register QdEventPtr qe = syncEvents.pending.forw;
    QdEventPtr next;
    while (qe != &syncEvents.pending)
    {
	register DeviceIntPtr device = qe->device;
	if (!device->sync.frozen)
	{
	    next = qe->forw;;
	    remque(qe);
	    (*device->public.processInputProc)(&qe->event, device);
	    insque(qe, &syncEvents.free);
	    qe = next;
	}
	else
	    qe = qe->forw;
    } 
}

static void
ComputeFreezes(dev1, dev2)
    DeviceIntPtr dev1, dev2;
{
    register DeviceIntPtr replayDev = syncEvents.replayDev;
    int i;
    WindowPtr w;
    Bool isKbd ;
    register xEvent *xE ;

    dev1->sync.frozen =
	((dev1->sync.other != NullGrab) || (dev1->sync.state >= FROZEN));
    dev2->sync.frozen =
	((dev2->sync.other != NullGrab) || (dev2->sync.state >= FROZEN));
    if (syncEvents.playingEvents)
	return;
    syncEvents.playingEvents = TRUE;
    if (replayDev)
    {
	isKbd = (replayDev == inputInfo.keyboard);
	xE = &replayDev->sync.event;
	syncEvents.replayDev = (DeviceIntPtr)NULL;
	w = XYToWindow(
	    xE->u.keyButtonPointer.rootX, xE->u.keyButtonPointer.rootY);
	for (i = 0; i < spriteTraceGood; i++)
	    if (syncEvents.replayWin == spriteTrace[i])
	    {
		if (!CheckDeviceGrabs(replayDev, xE, i+1, isKbd))
		    if (isKbd)
			NormalKeyboardEvent(replayDev, xE, w);
		    else
			DeliverDeviceEvents(w, xE, NullGrab, NullWindow);
		goto playmore;
	    }
	/* must not still be in the same stack */
	if (isKbd)
	    NormalKeyboardEvent(replayDev, xE, w);
	else
	    DeliverDeviceEvents(w, xE, NullGrab, NullWindow);
    }
playmore:
    if (!dev1->sync.frozen || !dev2->sync.frozen)
	PlayReleasedEvents();
    syncEvents.playingEvents = FALSE;
}

CheckGrabForSyncs(grab, thisDev, thisMode, otherDev, otherMode)
    GrabPtr grab;
    DeviceIntPtr thisDev, otherDev;
    int thisMode, otherMode;
{
    if (thisMode == GrabModeSync)
	thisDev->sync.state = FROZEN_NO_EVENT;
    else
    {	/* free both if same client owns both */
	thisDev->sync.state = THAWED;
	if (thisDev->sync.other &&
	    (thisDev->sync.other->client == grab->client))
	    thisDev->sync.other = NullGrab;
    }
    if (otherMode == GrabModeSync)
	otherDev->sync.other = grab;
    else
    {	/* free both if same client owns both */
	if (otherDev->sync.other &&
	    (otherDev->sync.other->client == grab->client))
	    otherDev->sync.other = NullGrab;
	if ((otherDev->sync.state >= FROZEN) &&
	    (otherDev->grab->client == grab->client))
	    otherDev->sync.state = THAWED;
    }
    ComputeFreezes(thisDev, otherDev);
}

void
ActivatePointerGrab(mouse, grab, time, autoGrab)
    GrabPtr grab;
    register DeviceIntPtr mouse;
    TimeStamp time;
    Bool autoGrab;
{
    WindowPtr w;

    mouse->grabTime = time;
    ptrGrab = *grab;
    mouse->grab = &ptrGrab;
    mouse->u.ptr.autoReleaseGrab = autoGrab;
    CheckGrabForSyncs(
	mouse->grab, mouse, grab->pointerMode,
	inputInfo.keyboard, grab->keyboardMode);
    PostNewCursor();
    DoEnterLeaveEvents(sprite.win, grab->window, NotifyGrab);
    if (w = grab->u.ptr.confineTo)
    {
	NewCursorConfines(
	    w->absCorner.x, w->absCorner.x + w->clientWinSize.width,
	    w->absCorner.y, w->absCorner.y + w->clientWinSize.height);
    }
}

void
DeactivatePointerGrab(mouse)
    DeviceIntPtr mouse;
{
    GrabPtr grab = mouse->grab;
    DeviceIntPtr keybd = inputInfo.keyboard;

    DoEnterLeaveEvents(grab->window, sprite.win, NotifyUngrab);
    mouse->grab = NullGrab;
    mouse->sync.state = NOT_GRABBED;
    mouse->u.ptr.autoReleaseGrab = FALSE;
    if (keybd->sync.other == grab)
	keybd->sync.other = NullGrab;
    ComputeFreezes(keybd, mouse);
    if (grab->u.ptr.confineTo)
	NewCursorConfines(0, currentScreen->width, 0, currentScreen->height);
    PostNewCursor();
}

void
ActivateKeyboardGrab(keybd, grab, time, passive)
    GrabPtr grab;
    register DeviceIntPtr keybd;
    TimeStamp time;
    Bool passive;
{
    keybd->grabTime = time;
    keybdGrab = *grab;
    keybd->grab = &keybdGrab;
    keybd->u.keybd.passiveGrab = passive;
    CheckGrabForSyncs(
	keybd->grab, keybd, grab->keyboardMode,
	inputInfo.pointer, grab->pointerMode);
}

void
DeactivateKeyboardGrab(keybd)
    DeviceIntPtr keybd;
{
    DeviceIntPtr mouse = inputInfo.pointer;
    GrabPtr grab = keybd->grab;

    keybd->grab = NullGrab;
    keybd->sync.state = NOT_GRABBED;
    keybd->u.keybd.passiveGrab = FALSE;
    if (mouse->sync.other == grab)
	mouse->sync.other = NullGrab;
    ComputeFreezes(keybd, mouse);
}

static void
AllowSome(client, time, thisDev, otherDev, minFreeze)
    ClientPtr		client;
    TimeStamp		time;
    DeviceIntPtr	thisDev, otherDev;
    int			minFreeze;
{
    if (!thisDev->sync.frozen)
	return;
    if (CompareTimeStamps(time, thisDev->grabTime) == EARLIER)
	return;
    if (thisDev->sync.state < minFreeze)
	return;
    switch (minFreeze)
    {
	case NOT_GRABBED: 	       /* Async */
	    if (thisDev->grab && (thisDev->grab->client == client))
		thisDev->sync.state = THAWED;
	    if (thisDev->sync.other && (thisDev->sync.other->client == client))
		thisDev->sync.other = NullGrab;
	    ComputeFreezes(thisDev, otherDev);
	    break;
	case FROZEN_NO_EVENT:		/* Sync */
	    if (thisDev->grab->client == client)
		thisDev->sync.state = FREEZE_NEXT_EVENT;
	    ComputeFreezes(thisDev, otherDev);
	    break;
	case FROZEN_WITH_EVENT:		/* Replay */
	    if (thisDev->grab->client == client)
	    {
		syncEvents.replayDev = thisDev;
		syncEvents.replayWin = thisDev->grab->window;
		if (thisDev == inputInfo.pointer)
		    DeactivatePointerGrab(thisDev);
		else
		    DeactivateKeyboardGrab(thisDev);
		syncEvents.replayDev = (DeviceIntPtr)NULL;
	    }
	    break;
    }
}

int
ProcAllowEvents(client)
    register ClientPtr client;
{
    TimeStamp		time;
    DeviceIntPtr	mouse = inputInfo.pointer;
    DeviceIntPtr	keybd = inputInfo.keyboard;
    REQUEST(xAllowEventsReq);

    REQUEST_SIZE_MATCH(xAllowEventsReq);
    time = ClientTimeToServerTime(stuff->time);
    if (CompareTimeStamps(time, currentTime) == LATER)
	return Success;
    switch (stuff->mode)
    {
	case ReplayPointer:
	    AllowSome(client, time, mouse, keybd, FROZEN_WITH_EVENT);
	    break;
	case SyncPointer: 
	    AllowSome(client, time, mouse, keybd, FROZEN_NO_EVENT);
	    break;
	case AsyncPointer: 
	    AllowSome(client, time, mouse, keybd, NOT_GRABBED);
	    break;
	case ReplayKeyboard: 
	    AllowSome(client, time, keybd, mouse, FROZEN_WITH_EVENT);
	    break;
	case SyncKeyboard: 
	    AllowSome(client, time, keybd, mouse, FROZEN_NO_EVENT);
	    break;
	case AsyncKeyboard: 
	    AllowSome(client, time, keybd, mouse, NOT_GRABBED);
	    break;
	default: 
	    client->errorValue = stuff->mode;
	    return BadValue;
    }
    return Success;
}

void
ReleaseActiveGrabs(client)
    ClientPtr client;
{
    int i;
    register DeviceIntPtr d;
    for (i = 0; i < inputInfo.numDevices; i++)
    {
	d = inputInfo.devices[i];
	if (d->grab && (d->grab->client == client))
	{
	    if (d == inputInfo.keyboard)
		DeactivateKeyboardGrab(d);
	    else if (d == inputInfo.pointer)
		DeactivatePointerGrab(d);
	    else
		d->grab = NullGrab;
	}
    }
}

/**************************************************************************
 *            The following procedures deal with delivering events        *
 **************************************************************************/

int
TryClientEvents (client, pEvents, count, mask, filter, grab)
    ClientPtr client;
    GrabPtr grab;
    xEvent *pEvents;
    int count;
    Mask mask, filter;
{
    int i;

    if (debug_events) ErrorF(
	"Event([%d, %d], mask=0x%x), client=%d",
	pEvents->u.u.type, pEvents->u.u.detail, mask, client->index);
    if ((client) && (client != serverClient) && (!client->clientGone) &&
	((filter == CantBeFiltered) || (mask & filter)) &&
	((!grab) || (client == grab->client)))
    {
	for (i = 0; i < count; i++)
	    pEvents[i].u.u.sequenceNumber = client->sequence;
	WriteEventToClient(client, count, (pointer)pEvents);
	if (debug_events) ErrorF(  " delivered\n");
	return 1;
    }
    else
    {
	if (debug_events) ErrorF("\n");
	return 0;
    }
}

int
DeliverEventsToWindow(pWin, pEvents, count, filter, grab)
    WindowPtr pWin;
    GrabPtr grab;
    xEvent *pEvents;
    int count;
    Mask filter;
{
    int     deliveries = 0;
    OtherClients *other;
    ClientPtr client = NullClient;

/*
 * The following relies on the fact that the Button<n>MotionMasks are equal
 * to the corresponding Button<n>Masks from the current modifier/button state.
 * If the client only selected one of the Button<n>Motion events, then she
 * should only get those.
 */

    if (pEvents->u.u.type == MotionNotify)
    {
        if (pWin->allEventMasks & PointerMotionHintMask)
	{
    	    if (lastWasMotion)
                return 0;
            else 
    	        pEvents->u.u.detail = NotifyHint;
	}
        lastWasMotion = TRUE;
	filter = Motion_Filter(keyButtonState);
    }

/* if nobody ever wants to see this event, skip some work */
    if ((filter != CantBeFiltered) && !(pWin->allEventMasks & filter))
	return 0;
    if (TryClientEvents(
	pWin->client, pEvents, count, pWin->eventMask, filter, grab))
    {
	deliveries++;
	client = pWin->client;
    }
    if (filter) /* CantBeFiltered means only window owner gets the event */
	for (other = OTHERCLIENTS(pWin); other; other = other->next)
	{
	    if (TryClientEvents(
		  other->client, pEvents, count, (Mask) other->mask, filter, grab))
	    {
		deliveries++;
		client = other->client;
	    }
	}
    if ((pEvents->u.u.type == ButtonPress) && deliveries && (!grab))
    {
	ptrGrab.device = inputInfo.pointer;
	ptrGrab.client = client;
	ptrGrab.window = pWin;
	ptrGrab.ownerEvents = pWin->eventMask & OwnerGrabButtonMask;
	ptrGrab.eventMask =  pWin->eventMask;
	ptrGrab.keyboardMode = GrabModeAsync;
	ptrGrab.pointerMode = GrabModeAsync;
	ptrGrab.u.ptr.confineTo = NullWindow;
	ptrGrab.u.ptr.cursor = NullCursor;
	ActivatePointerGrab(inputInfo.pointer, &ptrGrab, currentTime, TRUE);
    }
    return deliveries;
}

/* If the event goes to dontDeliverToMe, don't send it and return 0.  if
   send works,  return 1 or if send didn't work, return 2.
*/

int
MaybeDeliverEventsToClient(pWin, pEvents, count, filter, dontDeliverToMe)
    WindowPtr pWin;
    xEvent *pEvents;
    int count;
    Mask filter;
    ClientPtr dontDeliverToMe;
{
    OtherClients * other;

    if (pWin->eventMask & filter)
    {
        if (pWin->client == dontDeliverToMe)
		return 0;
	return TryClientEvents(
	    pWin->client, pEvents, count, pWin->eventMask, filter, NullGrab);
    }
    for (other = OTHERCLIENTS(pWin); other; other = other->next)
	if (other->mask & filter)
	{
            if (other->client == dontDeliverToMe)
		return 0;
	    return TryClientEvents(
		other->client, pEvents, count, (Mask) other->mask, filter, NullGrab);
	}
    return 2;
}

WindowPtr
RootForWindow(pWin)
    WindowPtr pWin;
{
    return &WindowTable[pWin->drawable.pScreen->myNum];
}

void
FixUpEventFromWindow(xE, pWin, child, calcChild)
    xEvent *xE;
    WindowPtr pWin;
    Window child;
    Bool calcChild;
{
    if (calcChild)
    {
        WindowPtr w=spriteTrace[spriteTraceGood-1];

        while (w) 
        {
 	    if (w == pWin)
	    {
 		child = w->wid;
		break;
	    }
 	    w = w->parent;
        } 	    
    }
    xE->u.keyButtonPointer.root = ROOT->wid;
    xE->u.keyButtonPointer.child = child;
    xE->u.keyButtonPointer.event = pWin->wid;
    xE->u.keyButtonPointer.eventX =
	xE->u.keyButtonPointer.rootX - pWin->absCorner.x;
    xE->u.keyButtonPointer.eventY =
	xE->u.keyButtonPointer.rootY - pWin->absCorner.y;
}


int
DeliverDeviceEvents(pWin, xE, grab, stopAt)
    register WindowPtr pWin, stopAt;
    register xEvent *xE;
    GrabPtr grab;
{
    Mask filter;
    int     deliveries;
    Window child = None;

    filter = filters[xE->u.u.type];
    if ((filter != CantBeFiltered) && !(filter & pWin->deliverableEvents))
	return 0;
    while (pWin)
    {
	FixUpEventFromWindow(xE, pWin, child, FALSE);
	deliveries = DeliverEventsToWindow(pWin, xE, 1, filter, grab);
	if ((deliveries > 0) || (filter & pWin->dontPropagateMask))
	    return deliveries;
	if (pWin == stopAt)
	    return 0;
	child = pWin->wid;
	pWin = pWin->parent;
    }
/*
 * This point should never be reached. Either stopAt is NullWindow, in which
 * case, the procedure is exited from the middle of the loop above, or it is
 * a window that the caller is asserting is an ancestor of pWin.
 */
    return 0;
}

int
DeliverEvents(pWin, xE, count, otherParent)
/* not useful for events that propagate up the tree */
    register WindowPtr pWin, otherParent;
    register xEvent *xE;
    int count;
{
    Mask filter;
    int     deliveries;

    if (!count)
	return 0;
    filter = filters[xE->u.u.type];
    if ((filter & SubstructureNotifyMask) && (xE->u.u.type != CreateNotify))
	xE->u.destroyNotify.event = pWin->wid;
    if (filter != StructureAndSubMask)
	return DeliverEventsToWindow(pWin, xE, count, filter, NullGrab);
    deliveries = DeliverEventsToWindow(
	    pWin, xE, count, StructureNotifyMask, NullGrab);
    if (pWin->parent)
    {
	xE->u.destroyNotify.event = pWin->parent->wid;
	deliveries += DeliverEventsToWindow(
		pWin->parent, xE, count, SubstructureNotifyMask, NullGrab);
	if (xE->u.u.type == ReparentNotify)
	{
	    xE->u.destroyNotify.event = otherParent->wid;
	    deliveries += DeliverEventsToWindow(
		    otherParent, xE, count, SubstructureNotifyMask, NullGrab);
	}
    }
    return deliveries;
}

/* check root -- this fails in Zaphod mode XXX */
/* 
 * XYToWindow is only called by CheckMotion after it has determined that
 * the current cache is not accurate.
 */
static WindowPtr 
XYToWindow(x, y)
	int x, y;
{
    register WindowPtr  pWin;

    spriteTraceGood = 1;	/* root window still there */
    pWin = ROOT->firstChild;
    while (pWin)
    {
	if ((pWin->mapped) &&
		(x >= pWin->absCorner.x - pWin->borderWidth) &&
		(x < pWin->absCorner.x + pWin->clientWinSize.width +
		    pWin->borderWidth) &&
		(y >= pWin->absCorner.y - pWin->borderWidth) &&
		(y < pWin->absCorner.y + pWin->clientWinSize.height +
		    pWin->borderWidth))
	{
	    if (spriteTraceGood >= spriteTraceSize)
	    {
		spriteTraceSize += 10;
		spriteTrace = (WindowPtr *)Xrealloc(
		    spriteTrace, spriteTraceSize*sizeof(WindowPtr));
	    }
	    spriteTrace[spriteTraceGood] = pWin;
	    pWin = spriteTrace[spriteTraceGood++]->firstChild;
	}
	else
	    pWin = pWin->nextSib;
    }
    return spriteTrace[spriteTraceGood-1];
}

WindowPtr 
CheckMotion(x, y, ignoreCache)
    int x, y;
    Bool ignoreCache;
{
    WindowPtr prevSpriteWin = sprite.win;

    if ((x != sprite.hot.x) || (y != sprite.hot.y))
    {
	sprite.win = XYToWindow(x, y);
	sprite.hot.x = x;
	sprite.hot.y = y;
/* XXX Do PointerNonInterestBox here */
/*
	if (!(sprite.win->deliverableEvents & Motion_Filter(keyButtonState)))
        {
	    
	}
*/
    }
    else
    {
	if ((ignoreCache) || (!sprite.win))
	    sprite.win = XYToWindow(x, y);
    }
    if (sprite.win != prevSpriteWin)
    {
	if (prevSpriteWin != NullWindow)
	    DoEnterLeaveEvents(prevSpriteWin, sprite.win, NotifyNormal);
	lastWasMotion = FALSE;
	PostNewCursor();
        return NullWindow;
    }
    return sprite.win;
}

WindowsRestructured()
{
    CheckMotion((int)sprite.hot.x, (int)sprite.hot.y, (Bool)TRUE);
}

void
DefineInitialRootWindow(win)
    WindowPtr win;
{
    register CursorPtr c = win->cursor;

    sprite.hot.x = currentScreen->width / 2;
    sprite.hot.y = currentScreen->height / 2;
    sprite.win = win;
    sprite.current = c;
    ROOT = win;
    (*currentScreen->CursorLimits) (
	currentScreen, win->cursor, &sprite.hotLimits, &sprite.physLimits);
    (*currentScreen->SetCursorPosition) (
	currentScreen, sprite.hot.x, sprite.hot.y);
    (*currentScreen->ConstrainCursor) (
	currentScreen, &sprite.physLimits);
    (*currentScreen->DisplayCursor) (
	currentScreen, c, sprite.hot.x, sprite.hot.y);
}

/*
 * This does not take any shortcuts, and even ignores its argument, since
 * it does not happen very often, and one has to walk up the tree since
 * this might be a newly instantiated cursor for an intermediate window
 * between the one the pointer is in and the one that the last cursor was
 * instantiated from.
 */
void
WindowHasNewCursor(pWin)
    WindowPtr pWin;
{
    PostNewCursor();
}

void
NewCurrentScreen(newScreen, x, y)
    ScreenPtr newScreen;
    int x,y;
{
    if (newScreen == currentScreen)
        return;
    ROOT = &WindowTable[newScreen->myNum];
    (void) CheckMotion(x, y, TRUE);
}

ProcWarpPointer(client)
    ClientPtr client;
{
    WindowPtr  source, dest;
    REQUEST(xWarpPointerReq);

    REQUEST_SIZE_MATCH(xWarpPointerReq);
    dest = (WindowPtr) LookupID(stuff->dstWid, RT_WINDOW, RC_CORE);
    if (!dest)
    {
	client->errorValue = stuff->dstWid;
	return BadWindow;
    }
    if (stuff->srcWid != None)
    {
	int     winX, winY;
	source = (WindowPtr ) LookupID(stuff->srcWid, RT_WINDOW, RC_CORE);
	if (!source)
	{
	    client->errorValue = stuff->srcWid;
	    return BadWindow;
	}
	winX = source->absCorner.x;
	winY = source->absCorner.y;
	if (
		(sprite.hot.x < (winX + stuff->srcX)) ||
		(sprite.hot.y < (winY + stuff->srcY)) ||
		((stuff->srcWidth != 0) &&
		    (winX + stuff->srcX + stuff->srcWidth < sprite.hot.x)) ||
		((stuff->srcHeight != 0) &&
		    (winY + stuff->srcY + stuff->srcHeight < sprite.hot.y)) ||
		(!PointInWindowIsVisible(source, sprite.hot.x, sprite.hot.y)))
	    return Success;
    }
    if (currentScreen != dest->drawable.pScreen)
        NewCurrentScreen(dest->drawable.pScreen, 
	    	         dest->absCorner.x + stuff->dstX,
		         dest->absCorner.y + stuff->dstY);
    (*dest->drawable.pScreen->SetCursorPosition)( dest->drawable.pScreen,
	    dest->absCorner.x + stuff->dstX, dest->absCorner.y + stuff->dstY);
    return Success;
}

static Bool
IsGrabbed(key, modifiers, dev, grab, keybd)
    int key, modifiers;
    DeviceIntPtr dev;
    register GrabPtr grab;
    Bool keybd;
{
    if (grab->device != dev)
	return FALSE;
    if ((grab->modifiers != AnyModifier) && (grab->modifiers != modifiers))
	return FALSE;
    if (keybd)
    {
	if ((key != grab->u.keybd.key) &&
	    ((grab->u.keybd.key != AnyKey) || (stateMasks[key])))
	    return FALSE;
    }
    else
    {
	if ((key != grab->u.ptr.button) && (grab->u.ptr.button != AnyButton))
	    return FALSE;
    }
    return TRUE;
}

Bool
MatchingGrab(key, modifiers, dev, grab, keybd)
    int key, modifiers;
    DeviceIntPtr dev;
    register GrabPtr grab;
    Bool keybd;
{
    if (grab->device != dev)
	return FALSE;
    if ((grab->modifiers != modifiers) &&
	(grab->modifiers != AnyModifier) &&
	(modifiers != AnyModifier))
	return FALSE;
    if (keybd)
    {
	if ((key != grab->u.keybd.key) &&
	    ((grab->u.keybd.key != AnyKey) || (stateMasks[key])) &&
	    ((key != AnyKey) || (stateMasks[grab->u.keybd.key])))
	    return FALSE;
    }
    else
    {
	if ((key != grab->u.ptr.button) &&
	    (grab->u.ptr.button != AnyButton) &&
	    (key != AnyButton))
	    return FALSE;
    }
    return TRUE;
}

void
NoticeTimeAndState(xE)
    register xEvent *xE;
{
    if (xE->u.keyButtonPointer.time < currentTime.milliseconds)
	currentTime.months++;
    currentTime.milliseconds = xE->u.keyButtonPointer.time;
    xE->u.keyButtonPointer.pad1 = 0;
    xE->u.keyButtonPointer.state = keyButtonState;
    xE->u.keyButtonPointer.sameScreen = TRUE;		/* XXX */
}

Bool
CheckDeviceGrabs(device, xE, checkFirst, isKeyboard)
    register DeviceIntPtr device;
    register xEvent *xE;
    int checkFirst;
{
    int i;
    GrabPtr grab;
    Bool sawFocus = (focusTraceGood == 1);
    WindowPtr pWin;
    for (i = checkFirst; i < spriteTraceGood; i++)
    {
	pWin = spriteTrace[i];
        if (isKeyboard && !sawFocus)
	{
            if ((focusTraceGood > i) || (focusTrace[i] != pWin))
                return FALSE;
            if (pWin == inputInfo.keyboard->u.keybd.focus.win)
                sawFocus == TRUE;
        }
	for (grab = PASSIVEGRABS(pWin); grab; grab = grab->next)
	{
	    if (IsGrabbed(
		    (int)xE->u.u.detail, (int)keyButtonState & AllModifiersMask,
		    device, grab, isKeyboard))
	    {
		if (isKeyboard)
		    ActivateKeyboardGrab(device, grab, currentTime, TRUE);
		else
		    ActivatePointerGrab(device, grab, currentTime, TRUE);
 
		FixUpEventFromWindow(xE, grab->window, None, TRUE);
		TryClientEvents(
		     grab->client, xE, 1, grab->eventMask, 
				(Mask)filters[xE->u.u.type],  grab);
		if (device->sync.state == FROZEN_NO_EVENT)
		{
		    device->sync.event = *xE;
		    device->sync.state = FROZEN_WITH_EVENT;
		}
		return TRUE;
	    }
	}
    }
    return FALSE;
}

static void
NormalKeyboardEvent(keybd, xE, window)
    xEvent *xE;
    DeviceIntPtr keybd;
    WindowPtr window;
{
    WindowPtr focus = keybd->u.keybd.focus.win;
    if (focus == NullWindow)
	return;
    if (focus == PointerRootWin)
    {
	DeliverDeviceEvents(window, xE, NullGrab, NullWindow);
	return;
    }
    if ((focus == window) || IsParent(focus, window))
    {
	if (DeliverDeviceEvents(window, xE, NullGrab, focus))
	    return;
    }
 /* just deliver it to the focus window */
    FixUpEventFromWindow(xE, focus, None, FALSE);
    DeliverEventsToWindow(focus, xE, 1, (Mask)filters[xE->u.u.type], NullGrab);
}

void
ProcessKeyboardEvent (xE, keybd)
    register xEvent *xE;
    register DeviceIntPtr keybd;
{
    register int    key;
    GrabPtr         grab = keybd->grab;
    WindowPtr       pWin;
    Bool            deactiveGrab = FALSE;

    if (keybd->sync.frozen)
    {
	EnqueueEvent(keybd, xE);
	return;
    }
    NoticeTimeAndState(xE);
    key = xE->u.u.detail;
    pWin = sprite.win;
/*
    CheckMotion(
	xE->u.keyButtonPointer.rootX, xE->u.keyButtonPointer.rootY,
	FALSE);
    xE->u.keyButtonPointer.rootX = sprite.hot.x;  ignore x and y for keyboard?
    xE->u.keyButtonPointer.rootY = sprite.hot.y;
*/
    xE->u.u.detail = key;           
    lastWasMotion  = FALSE;
    switch (xE->u.u.type)
    {
	case KeyPress: 
	    BitOn(keybd->down, key);
	    if (!xE->u.u.detail)
		return;
	    BitOn(keybd->down, xE->u.u.detail);
	    keyButtonState |= stateMasks[xE->u.u.detail];
	    if (!grab)
		if (CheckDeviceGrabs(keybd, xE, 0, TRUE))
		    return;
	    break;
	case KeyRelease: 
	    BitOff(keybd->down, key);
	    if (!xE->u.u.detail)
		return;
	    BitOff(keybd->down, xE->u.u.detail);
	    keyButtonState &= ~stateMasks[xE->u.u.detail];
	    if ((keybd->u.keybd.passiveGrab) &&
			(xE->u.u.detail == grab->u.keybd.key))
		deactiveGrab = TRUE;
	    break;
	default: 
	    FatalError("Impossible keyboard event");
    }
    if (grab = keybd->grab)
    {
	Bool syncIt;
	if ((!grab->ownerEvents) ||
		(!(syncIt = DeliverDeviceEvents(pWin, xE, grab, NullWindow))))
	{
	    FixUpEventFromWindow(xE, grab->window, None, TRUE);
	    syncIt = TryClientEvents(
		grab->client, xE, 1, grab->eventMask, 
		(Mask)filters[xE->u.u.type], grab);
	}
	if (syncIt && (keybd->sync.state == FREEZE_NEXT_EVENT))
	{
	    keybd->sync.state = FROZEN_WITH_EVENT;
	    keybd->sync.frozen = TRUE;
	    keybd->sync.event = *xE;
	}
    }
    else
	NormalKeyboardEvent(keybd, xE, pWin);
    if (deactiveGrab)
        DeactivateKeyboardGrab(keybd);
}