/* $Xorg: xkbEvents.c,v 1.3 2000/08/17 19:53:47 cpqbld Exp $ */
/************************************************************
Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.

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 name of Silicon Graphics not be 
used in advertising or publicity pertaining to distribution 
of the software without specific prior written permission.
Silicon Graphics makes no representation about the suitability 
of this software for any purpose. It is provided "as is"
without any express or implied warranty.

SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS 
SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 
AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
GRAPHICS 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.

********************************************************/
/* $XFree86: xc/programs/Xserver/xkb/xkbEvents.c,v 3.10 2001/10/28 03:34:20 tsi Exp $ */

#include <stdio.h>
#define NEED_EVENTS 1
#include <X11/X.h>
#include <X11/Xproto.h>
#include <X11/keysym.h>
#include "XI.h"
#include "inputstr.h"
#include "windowstr.h"
#include "XKBsrv.h"

/***====================================================================***/

void
#if NeedFunctionPrototypes
XkbSendNewKeyboardNotify(DeviceIntPtr kbd,xkbNewKeyboardNotify *pNKN)
#else
XkbSendNewKeyboardNotify(kbd,pNKN)
    DeviceIntPtr	 	kbd;
    xkbNewKeyboardNotify *	pNKN;
#endif
{		
register int	i;
Time 		time;
CARD16		changed;

    pNKN->type = XkbEventCode + XkbEventBase;
    pNKN->xkbType = XkbNewKeyboardNotify;
    pNKN->time = time = GetTimeInMillis();
    changed = pNKN->changed;

    for (i=1; i<currentMaxClients; i++) {
        if ((!clients[i]) || clients[i]->clientGone ||
				(clients[i]->requestVector==InitialVector)) {
	    continue;
	}

	if (clients[i]->xkbClientFlags&_XkbClientInitialized)  {
	    if (clients[i]->newKeyboardNotifyMask&changed) {
		pNKN->sequenceNumber = clients[i]->sequence;
		pNKN->time = time;
		pNKN->changed = changed;
		if ( clients[i]->swapped ) {
		    register int n;
		    swaps(&pNKN->sequenceNumber,n);
		    swapl(&pNKN->time,n);
		    swaps(&pNKN->changed,n);
		}
		WriteToClient(clients[i],sizeof(xEvent),(char *)pNKN);
		if (changed&XkbNKN_KeycodesMask) {
		    clients[i]->minKC= pNKN->minKeyCode;
		    clients[i]->maxKC= pNKN->maxKeyCode;
		}
	    }
	}
	else if (changed&XkbNKN_KeycodesMask) {
	    xEvent	event;
	    event.u.u.type= MappingNotify;
	    event.u.mappingNotify.request= MappingKeyboard;
	    event.u.mappingNotify.firstKeyCode= clients[i]->minKC;
	    event.u.mappingNotify.count= clients[i]->maxKC-clients[i]->minKC+1;
	    event.u.u.sequenceNumber= clients[i]->sequence;
	    if (clients[i]->swapped) {
		int n;
		swaps(&event.u.u.sequenceNumber,n);
	    }
	    WriteToClient(clients[i],SIZEOF(xEvent), (char *)&event);
	    event.u.mappingNotify.request= MappingModifier;
	    WriteToClient(clients[i],SIZEOF(xEvent), (char *)&event);
	}
    }
    return;
}

/***====================================================================***/

void
#if NeedFunctionPrototypes
XkbSendStateNotify(DeviceIntPtr kbd,xkbStateNotify *pSN)
#else
XkbSendStateNotify(kbd,pSN)
    DeviceIntPtr	 kbd;
    xkbStateNotify	*pSN;
#endif
{
XkbSrvInfoPtr	xkbi;
XkbStatePtr	state;
XkbInterestPtr	interest;
Time 		time;
register CARD16	changed,bState;

    interest = kbd->xkb_interest;
    if (!interest)
	return;
    xkbi = kbd->key->xkbInfo;
    state= &xkbi->state;

    pSN->type = XkbEventCode + XkbEventBase;
    pSN->xkbType = XkbStateNotify;
    pSN->deviceID = kbd->id;
    pSN->time = time = GetTimeInMillis();
    pSN->mods = state->mods;
    pSN->baseMods = state->base_mods;
    pSN->latchedMods = state->latched_mods;
    pSN->lockedMods = state->locked_mods;
    pSN->group = state->group;
    pSN->baseGroup = state->base_group;
    pSN->latchedGroup = state->latched_group;
    pSN->lockedGroup = state->locked_group;
    pSN->compatState = state->compat_state;
    pSN->grabMods = state->grab_mods;
    pSN->compatGrabMods = state->compat_grab_mods;
    pSN->lookupMods = state->lookup_mods;
    pSN->compatLookupMods = state->compat_lookup_mods;
    pSN->ptrBtnState = state->ptr_buttons;
    changed = pSN->changed;
    bState= pSN->ptrBtnState;

    while (interest) {
	if ((!interest->client->clientGone) &&
	    (interest->client->requestVector != InitialVector) &&
	    (interest->client->xkbClientFlags&_XkbClientInitialized) &&
	    (interest->stateNotifyMask&changed)) {
	    pSN->sequenceNumber = interest->client->sequence;
	    pSN->time = time;
	    pSN->changed = changed;
	    pSN->ptrBtnState = bState;
	    if ( interest->client->swapped ) {
		register int n;
		swaps(&pSN->sequenceNumber,n);
		swapl(&pSN->time,n);
		swaps(&pSN->changed,n);
		swaps(&pSN->ptrBtnState,n);
	    }
	    WriteToClient(interest->client, sizeof(xEvent), (char *)pSN);
	}
	interest= interest->next;
    }
    return;
}

/***====================================================================***/

void
#if NeedFunctionPrototypes
XkbSendMapNotify(DeviceIntPtr kbd,xkbMapNotify *pMN)
#else
XkbSendMapNotify(kbd,pMN)
    DeviceIntPtr kbd;
    xkbMapNotify *pMN;
#endif
{
int 		i;
XkbSrvInfoPtr	xkbi;
unsigned	time = 0,initialized;
CARD16		changed;

    xkbi = kbd->key->xkbInfo;
    initialized= 0;

    changed = pMN->changed;
    pMN->minKeyCode= xkbi->desc->min_key_code;
    pMN->maxKeyCode= xkbi->desc->max_key_code;
    for (i=1; i<currentMaxClients; i++) {
        if (clients[i] && ! clients[i]->clientGone &&
	    (clients[i]->requestVector != InitialVector) &&
	    (clients[i]->xkbClientFlags&_XkbClientInitialized) &&
	    (clients[i]->mapNotifyMask&changed))
	{
	    if (!initialized) {
		pMN->type = XkbEventCode + XkbEventBase;
		pMN->xkbType = XkbMapNotify;
		pMN->deviceID = kbd->id;
		time = GetTimeInMillis();
		initialized= 1;
	    }
	    pMN->time= time;
	    pMN->sequenceNumber = clients[i]->sequence;
	    pMN->changed = changed;
	    if ( clients[i]->swapped ) {
		register int n;
		swaps(&pMN->sequenceNumber,n);
		swapl(&pMN->time,n);
		swaps(&pMN->changed,n);
	    }
	    WriteToClient(clients[i],sizeof(xEvent),(char *)pMN);
	}
    }
    return;
}

int
#if NeedFunctionPrototypes
XkbComputeControlsNotify(	DeviceIntPtr	 	kbd,
				XkbControlsPtr		old,
				XkbControlsPtr		new,
				xkbControlsNotify *	pCN,
				Bool			forceCtrlProc)
#else
XkbComputeControlsNotify(kbd,old,new,pCN,forceCtrlProc)
    DeviceIntPtr	 kbd;
    XkbControlsPtr	old;
    XkbControlsPtr	new;
    xkbControlsNotify	*pCN;
    Bool		forceCtrlProc;
#endif
{
int		i;
CARD32 		changedControls;

    changedControls= 0;
    if (old->enabled_ctrls!=new->enabled_ctrls)
	changedControls|= XkbControlsEnabledMask;
    if ((old->repeat_delay!=new->repeat_delay)||
	(old->repeat_interval!=new->repeat_interval))
	changedControls|= XkbRepeatKeysMask;
    for (i = 0; i < XkbPerKeyBitArraySize; i++)
	if (old->per_key_repeat[i] != new->per_key_repeat[i])
	    changedControls|= XkbPerKeyRepeatMask;
    if (old->slow_keys_delay!=new->slow_keys_delay)
	changedControls|= XkbSlowKeysMask;
    if (old->debounce_delay!=new->debounce_delay)
	changedControls|= XkbBounceKeysMask;
    if ((old->mk_delay!=new->mk_delay)||
	(old->mk_interval!=new->mk_interval)||
	(old->mk_dflt_btn!=new->mk_dflt_btn))
	changedControls|= XkbMouseKeysMask;
    if ((old->mk_time_to_max!=new->mk_time_to_max)||
	(old->mk_curve!=new->mk_curve)||
	(old->mk_max_speed!=new->mk_max_speed))
	changedControls|= XkbMouseKeysAccelMask;
    if (old->ax_options!=new->ax_options)
	changedControls|= XkbAccessXKeysMask;
    if ((old->ax_options^new->ax_options) & XkbAX_SKOptionsMask)
	changedControls|= XkbStickyKeysMask;
    if ((old->ax_options^new->ax_options) & XkbAX_FBOptionsMask)
	changedControls|= XkbAccessXFeedbackMask;
    if ((old->ax_timeout!=new->ax_timeout)||
	(old->axt_ctrls_mask!=new->axt_ctrls_mask)||
	(old->axt_ctrls_values!=new->axt_ctrls_values)||
	(old->axt_opts_mask!=new->axt_opts_mask)||
	(old->axt_opts_values!= new->axt_opts_values)) {
	changedControls|= XkbAccessXTimeoutMask;
    }
    if ((old->internal.mask!=new->internal.mask)||
	(old->internal.real_mods!=new->internal.real_mods)||
	(old->internal.vmods!=new->internal.vmods))
	changedControls|= XkbInternalModsMask;
    if ((old->ignore_lock.mask!=new->ignore_lock.mask)||
	(old->ignore_lock.real_mods!=new->ignore_lock.real_mods)||
	(old->ignore_lock.vmods!=new->ignore_lock.vmods))
	changedControls|= XkbIgnoreLockModsMask;

    if (new->enabled_ctrls&XkbRepeatKeysMask)
	 kbd->kbdfeed->ctrl.autoRepeat=TRUE;
    else kbd->kbdfeed->ctrl.autoRepeat=FALSE;

    if (kbd->kbdfeed && kbd->kbdfeed->CtrlProc &&
	(changedControls || forceCtrlProc))
	(*kbd->kbdfeed->CtrlProc)(kbd, &kbd->kbdfeed->ctrl);

    if ((!changedControls)&&(old->num_groups==new->num_groups))
	return 0;

    if (!kbd->xkb_interest)
	return 0;

    pCN->changedControls = changedControls;
    pCN->enabledControls = new->enabled_ctrls;
    pCN->enabledControlChanges = (new->enabled_ctrls^old->enabled_ctrls);
    pCN->numGroups = new->num_groups;

    return 1;
}

void
#if NeedFunctionPrototypes
XkbSendControlsNotify(DeviceIntPtr kbd,xkbControlsNotify *pCN)
#else
XkbSendControlsNotify(kbd,pCN)
    DeviceIntPtr	 kbd;
    xkbControlsNotify	*pCN;
#endif
{
int			initialized;
CARD32 		 	changedControls, enabledControls, enabledChanges = 0;
XkbSrvInfoPtr		xkbi;
XkbInterestPtr		interest;
Time 		 	time = 0;

    interest = kbd->xkb_interest;
    if (!interest)
	return;
    xkbi = kbd->key->xkbInfo;
 
    initialized = 0;
    enabledControls = xkbi->desc->ctrls->enabled_ctrls;
    changedControls = pCN->changedControls;
    pCN->numGroups= xkbi->desc->ctrls->num_groups;
    while (interest) {
	if ((!interest->client->clientGone) &&
	    (interest->client->requestVector != InitialVector) &&
	    (interest->client->xkbClientFlags&_XkbClientInitialized) &&
	    (interest->ctrlsNotifyMask&changedControls)) {
	    if (!initialized) {
		pCN->type = XkbEventCode + XkbEventBase;
		pCN->xkbType = XkbControlsNotify;
		pCN->deviceID = kbd->id;
		pCN->time = time = GetTimeInMillis();
		enabledChanges = pCN->enabledControlChanges;
		initialized= 1;
	    }
	    pCN->changedControls = changedControls;
	    pCN->enabledControls = enabledControls;
	    pCN->enabledControlChanges = enabledChanges;
	    pCN->sequenceNumber = interest->client->sequence;
	    pCN->time = time;
	    if ( interest->client->swapped ) {
		register int n;
		swaps(&pCN->sequenceNumber,n);
		swapl(&pCN->changedControls,n);
		swapl(&pCN->enabledControls,n);
		swapl(&pCN->enabledControlChanges,n);
		swapl(&pCN->time,n);
	    }
	    WriteToClient(interest->client, sizeof(xEvent), (char *)pCN);
	}
	interest= interest->next;
    }
    return;
}

void
#if NeedFunctionPrototypes
XkbSendIndicatorNotify(DeviceIntPtr kbd,int xkbType,xkbIndicatorNotify *pEv)
#else
XkbSendIndicatorNotify(kbd,xkbType,pEv)
    DeviceIntPtr	 kbd;
    int			 xkbType;
    xkbIndicatorNotify	*pEv;
#endif
{
int		initialized;
XkbInterestPtr	interest;
Time 		time = 0;
CARD32		state,changed;

    interest = kbd->xkb_interest;
    if (!interest)
	return;
 
    initialized = 0;
    state = pEv->state;
    changed = pEv->changed;
    while (interest) {
	if ((!interest->client->clientGone) &&
	    (interest->client->requestVector != InitialVector) &&
	    (interest->client->xkbClientFlags&_XkbClientInitialized) &&
	    (((xkbType==XkbIndicatorStateNotify)&&
				(interest->iStateNotifyMask&changed))||
	     ((xkbType==XkbIndicatorMapNotify)&&
	    			(interest->iMapNotifyMask&changed)))) {
	    if (!initialized) {
		pEv->type = XkbEventCode + XkbEventBase;
		pEv->xkbType = xkbType;
		pEv->deviceID = kbd->id;
		pEv->time = time = GetTimeInMillis();
		initialized= 1;
	    }
	    pEv->sequenceNumber = interest->client->sequence;
	    pEv->time = time;
	    pEv->changed = changed;
	    pEv->state = state;
	    if ( interest->client->swapped ) {
		register int n;
		swaps(&pEv->sequenceNumber,n);
		swapl(&pEv->time,n);
		swapl(&pEv->changed,n);
		swapl(&pEv->state,n);
	    }
	    WriteToClient(interest->client, sizeof(xEvent), (char *)pEv);
	}
	interest= interest->next;
    }
    return;
}


void
#if NeedFunctionPrototypes
XkbHandleBell(	BOOL		 force,
		BOOL		 eventOnly,
		DeviceIntPtr	 kbd,
		CARD8		 percent,
		pointer		 pCtrl,
		CARD8		 class,
		Atom		 name,
		WindowPtr	 pWin,
		ClientPtr	 pClient)
#else
XkbHandleBell(force,eventOnly,kbd,percent,pCtrl,class,name,pWin,pClient)
    BOOL		 force;
    BOOL		 eventOnly;
    DeviceIntPtr	 kbd;
    CARD8		 percent;
    pointer		*pCtrl;
    CARD8		 class;
    Atom		 name;
    WindowPtr		 pWin;
    ClientPtr		 pClient;
#endif
{
xkbBellNotify	bn;
int		initialized;
XkbSrvInfoPtr	xkbi;
XkbInterestPtr	interest;
CARD8		id;
CARD16		pitch,duration;
Time 		time = 0;
XID		winID = 0;

    xkbi = kbd->key->xkbInfo;

    if ((force||(xkbi->desc->ctrls->enabled_ctrls&XkbAudibleBellMask))&&
							(!eventOnly)) {
	(*kbd->kbdfeed->BellProc)(percent,kbd,(pointer)pCtrl,class);
    }
    interest = kbd->xkb_interest;
    if ((!interest)||(force))
	return;

    if ((class==0)||(class==KbdFeedbackClass)) {
	KeybdCtrl *pKeyCtrl= (KeybdCtrl *)pCtrl;
	id= pKeyCtrl->id;
	pitch= pKeyCtrl->bell_pitch;
	duration= pKeyCtrl->bell_duration;
    }
    else if (class==BellFeedbackClass) {
	BellCtrl *pBellCtrl= (BellCtrl *)pCtrl;
	id= pBellCtrl->id;
	pitch= pBellCtrl->pitch;
	duration= pBellCtrl->duration;
    }
    else return;
 
    initialized = 0;
    while (interest) {
	if ((!interest->client->clientGone) &&
	    (interest->client->requestVector != InitialVector) &&
	    (interest->client->xkbClientFlags&_XkbClientInitialized) &&
	    (interest->bellNotifyMask)) {
	    if (!initialized) {
		time = GetTimeInMillis();
		bn.type = XkbEventCode + XkbEventBase;
		bn.xkbType = XkbBellNotify;
		bn.deviceID = kbd->id;
		bn.bellClass = class;
		bn.bellID = id;
		bn.percent= percent;
		bn.eventOnly = (eventOnly!=0);
		winID= (pWin?pWin->drawable.id:None);
		initialized= 1;
	    }
	    bn.sequenceNumber = interest->client->sequence;
	    bn.time = time;
	    bn.pitch = pitch;
	    bn.duration = duration;
	    bn.name = name;
	    bn.window=  winID;
	    if ( interest->client->swapped ) {
		register int n;
		swaps(&bn.sequenceNumber,n);
		swapl(&bn.time,n);
		swaps(&bn.pitch,n);
		swaps(&bn.duration,n);
		swapl(&bn.name,n);
		swapl(&bn.window,n);
	    }
	    WriteToClient(interest->client, sizeof(xEvent), (char *)&bn);
	}
	interest= interest->next;
    }
    return;
}

void
#if NeedFunctionPrototypes
XkbSendAccessXNotify(DeviceIntPtr kbd,xkbAccessXNotify *pEv)
#else
XkbSendAccessXNotify(kbd,pEv)
    DeviceIntPtr	 kbd;
    xkbAccessXNotify	*pEv;
#endif
{
int		initialized;
XkbInterestPtr	interest;
Time 		time = 0;
CARD16		sk_delay,db_delay;

    interest = kbd->xkb_interest;
    if (!interest)
	return;
 
    initialized = 0;
    sk_delay= pEv->slowKeysDelay;
    db_delay= pEv->debounceDelay;
    while (interest) {
	if ((!interest->client->clientGone) &&
	    (interest->client->requestVector != InitialVector) &&
	    (interest->client->xkbClientFlags&_XkbClientInitialized) &&
	    (interest->accessXNotifyMask&(1<<pEv->detail))) {
	    if (!initialized) {
		pEv->type = XkbEventCode + XkbEventBase;
		pEv->xkbType = XkbAccessXNotify;
		pEv->deviceID = kbd->id;
		pEv->time = time = GetTimeInMillis();
		initialized= 1;
	    }
	    pEv->sequenceNumber = interest->client->sequence;
	    pEv->time = time;
	    pEv->slowKeysDelay = sk_delay;
	    pEv->debounceDelay = db_delay;
	    if ( interest->client->swapped ) {
		register int n;
		swaps(&pEv->sequenceNumber,n);
		swapl(&pEv->time,n);
		swaps(&pEv->slowKeysDelay,n);
		swaps(&pEv->debounceDelay,n);
	    }
	    WriteToClient(interest->client, sizeof(xEvent), (char *)pEv);
	}
	interest= interest->next;
    }
    return;
}

void
#if NeedFunctionPrototypes
XkbSendNamesNotify(DeviceIntPtr kbd,xkbNamesNotify *pEv)
#else
XkbSendNamesNotify(kbd,pEv)
    DeviceIntPtr	 kbd;
    xkbNamesNotify	*pEv;
#endif
{
int		initialized;
XkbInterestPtr	interest;
Time 		time = 0;
CARD16		changed,changedVirtualMods;
CARD32		changedIndicators;

    interest = kbd->xkb_interest;
    if (!interest)
	return;
 
    initialized = 0;
    changed= pEv->changed;
    changedIndicators= pEv->changedIndicators;
    changedVirtualMods= pEv->changedVirtualMods;
    while (interest) {
	if ((!interest->client->clientGone) &&
	    (interest->client->requestVector != InitialVector) &&
	    (interest->client->xkbClientFlags&_XkbClientInitialized) &&
	    (interest->namesNotifyMask&pEv->changed)) {
	    if (!initialized) {
		pEv->type = XkbEventCode + XkbEventBase;
		pEv->xkbType = XkbNamesNotify;
		pEv->deviceID = kbd->id;
		pEv->time = time = GetTimeInMillis();
		initialized= 1;
	    }
	    pEv->sequenceNumber = interest->client->sequence;
	    pEv->time = time;
	    pEv->changed = changed;
	    pEv->changedIndicators = changedIndicators;
	    pEv->changedVirtualMods= changedVirtualMods;
	    if ( interest->client->swapped ) {
		register int n;
		swaps(&pEv->sequenceNumber,n);
		swapl(&pEv->time,n);
		swaps(&pEv->changed,n);
		swapl(&pEv->changedIndicators,n);
		swaps(&pEv->changedVirtualMods,n);
	    }
	    WriteToClient(interest->client, sizeof(xEvent), (char *)pEv);
	}
	interest= interest->next;
    }
    return;
}

void
#if NeedFunctionPrototypes
XkbSendCompatMapNotify(DeviceIntPtr kbd,xkbCompatMapNotify *pEv)
#else
XkbSendCompatMapNotify(kbd,pEv)
    DeviceIntPtr	 kbd;
    xkbCompatMapNotify	*pEv;
#endif
{
int		initialized;
XkbInterestPtr	interest;
Time 		time = 0;
CARD16		firstSI = 0, nSI = 0, nTotalSI = 0;

    interest = kbd->xkb_interest;
    if (!interest)
	return;
 
    initialized = 0;
    while (interest) {
	if ((!interest->client->clientGone) &&
	    (interest->client->requestVector != InitialVector) &&
	    (interest->client->xkbClientFlags&_XkbClientInitialized) &&
	    (interest->compatNotifyMask)) {
	    if (!initialized) {
		pEv->type = XkbEventCode + XkbEventBase;
		pEv->xkbType = XkbCompatMapNotify;
		pEv->deviceID = kbd->id;
		pEv->time = time = GetTimeInMillis();
		firstSI= pEv->firstSI;
		nSI= pEv->nSI;
		nTotalSI= pEv->nTotalSI;
		initialized= 1;
	    }
	    pEv->sequenceNumber = interest->client->sequence;
	    pEv->time = time;
	    pEv->firstSI = firstSI;
	    pEv->nSI = nSI;
	    pEv->nTotalSI = nTotalSI;
	    if ( interest->client->swapped ) {
		register int n;
		swaps(&pEv->sequenceNumber,n);
		swapl(&pEv->time,n);
		swaps(&pEv->firstSI,n);
		swaps(&pEv->nSI,n);
		swaps(&pEv->nTotalSI,n);
	    }
	    WriteToClient(interest->client, sizeof(xEvent), (char *)pEv);
	}
	interest= interest->next;
    }
    return;
}

void
#if NeedFunctionPrototypes
XkbSendActionMessage(DeviceIntPtr kbd,xkbActionMessage *pEv)
#else
XkbSendActionMessage(kbd,pEv)
    DeviceIntPtr	 kbd;
    xkbActionMessage *	pEv;
#endif
{
int		 initialized;
XkbSrvInfoPtr	 xkbi;
XkbInterestPtr	 interest;
Time 		 time = 0;

    xkbi = kbd->key->xkbInfo;
    interest = kbd->xkb_interest;
    if (!interest)
	return;
 
    initialized = 0;
    pEv->mods= xkbi->state.mods;
    pEv->group= xkbi->state.group;
    while (interest) {
	if ((!interest->client->clientGone) &&
	    (interest->client->requestVector != InitialVector) &&
	    (interest->client->xkbClientFlags&_XkbClientInitialized) &&
	    (interest->actionMessageMask)) {
	    if (!initialized) {
		pEv->type = XkbEventCode + XkbEventBase;
		pEv->xkbType = XkbActionMessage;
		pEv->deviceID = kbd->id;
		pEv->sequenceNumber = interest->client->sequence;
		pEv->time = time = GetTimeInMillis();
		initialized= 1;
	    }
	    pEv->sequenceNumber = interest->client->sequence;
	    pEv->time = time;
	    if ( interest->client->swapped ) {
		register int n;
		swaps(&pEv->sequenceNumber,n);
		swapl(&pEv->time,n);
	    }
	    WriteToClient(interest->client, sizeof(xEvent), (char *)pEv);
	}
	interest= interest->next;
    }
    return;
}

void
#if NeedFunctionPrototypes
XkbSendExtensionDeviceNotify(	DeviceIntPtr 			dev,
				ClientPtr			client,
				xkbExtensionDeviceNotify *	pEv)
#else
XkbSendExtensionDeviceNotify(dev,client,pEv)
    DeviceIntPtr	 	dev;
    ClientPtr			client;
    xkbExtensionDeviceNotify *	pEv;
#endif
{
int		 initialized;
XkbInterestPtr	 interest;
Time 		 time = 0;
CARD32		 defined, state;
CARD16		 reason, supported = 0;

    interest = dev->xkb_interest;
    if (!interest)
	return;
 
    initialized = 0;
    reason= pEv->reason;
    defined= pEv->ledsDefined;
    state= pEv->ledState;
    while (interest) {
	if ((!interest->client->clientGone) &&
	    (interest->client->requestVector != InitialVector) &&
	    (interest->client->xkbClientFlags&_XkbClientInitialized) &&
	    (interest->extDevNotifyMask&reason)) {
	    if (!initialized) {
		pEv->type = XkbEventCode + XkbEventBase;
		pEv->xkbType = XkbExtensionDeviceNotify;
		pEv->deviceID = dev->id;
		pEv->sequenceNumber = interest->client->sequence;
		pEv->time = time = GetTimeInMillis();
		supported= pEv->supported;
		initialized= 1;
	    }
	    else {
		pEv->sequenceNumber = interest->client->sequence;
		pEv->time = time;
		pEv->ledsDefined= defined;
		pEv->ledState= state;
		pEv->reason= reason;
		pEv->supported= supported;
	    }
	    if (client!=interest->client) {
		/* only report UnsupportedFeature to the client that */
		/* issued the failing request */
		pEv->reason&= ~XkbXI_UnsupportedFeatureMask;
		if ((interest->extDevNotifyMask&reason)==0)
		    continue;
	    }
	    if ( interest->client->swapped ) {
		register int n;
		swaps(&pEv->sequenceNumber,n);
		swapl(&pEv->time,n);
		swapl(&pEv->ledsDefined,n);
		swapl(&pEv->ledState,n);
		swaps(&pEv->reason,n);
		swaps(&pEv->supported,n);
	    }
	    WriteToClient(interest->client, sizeof(xEvent), (char *)pEv);
	}
	interest= interest->next;
    }
    return;
}

void
#if NeedFunctionPrototypes
XkbSendNotification(	DeviceIntPtr		kbd,
			XkbChangesPtr		pChanges,
			XkbEventCausePtr	cause)
#else
XkbSendNotification(kbd,pChanges,cause)
    DeviceIntPtr	kbd;
    XkbChangesPtr	pChanges;
    XkbEventCausePtr	cause;
#endif
{
XkbSrvLedInfoPtr	sli;

    sli= NULL;
    if (pChanges->state_changes) {
	xkbStateNotify sn;
	sn.changed= pChanges->state_changes;
	sn.keycode= cause->kc;
	sn.eventType= cause->event;
	sn.requestMajor= cause->mjr;
	sn.requestMinor= cause->mnr;
	XkbSendStateNotify(kbd,&sn);
    }
    if (pChanges->map.changed) {
	xkbMapNotify mn;
	mn.changed= pChanges->map.changed;
	mn.firstType= pChanges->map.first_type;
	mn.nTypes= pChanges->map.num_types;
	mn.firstKeySym= pChanges->map.first_key_sym;
	mn.nKeySyms= pChanges->map.num_key_syms;
	mn.firstKeyAct= pChanges->map.first_key_act;
	mn.nKeyActs= pChanges->map.num_key_acts;
	mn.firstKeyBehavior= pChanges->map.first_key_behavior;
	mn.nKeyBehaviors= pChanges->map.num_key_behaviors;
	mn.virtualMods= pChanges->map.vmods;
	mn.firstKeyExplicit= pChanges->map.first_key_explicit;
	mn.nKeyExplicit= pChanges->map.num_key_explicit;
	mn.firstModMapKey= pChanges->map.first_modmap_key;
	mn.nModMapKeys= pChanges->map.num_modmap_keys;
	mn.firstVModMapKey= pChanges->map.first_vmodmap_key;
	mn.nVModMapKeys= pChanges->map.num_vmodmap_keys;
	XkbSendMapNotify(kbd,&mn);
    }
    if ((pChanges->ctrls.changed_ctrls)||
	(pChanges->ctrls.enabled_ctrls_changes)) {
	xkbControlsNotify cn;
	cn.changedControls= pChanges->ctrls.changed_ctrls;
	cn.enabledControlChanges= pChanges->ctrls.enabled_ctrls_changes;
	cn.keycode= cause->kc;
	cn.eventType= cause->event;
	cn.requestMajor= cause->mjr;
	cn.requestMinor= cause->mnr;
	XkbSendControlsNotify(kbd,&cn);
    }
    if (pChanges->indicators.map_changes) {
	xkbIndicatorNotify in;
	if (sli==NULL)
	    sli= XkbFindSrvLedInfo(kbd,XkbDfltXIClass,XkbDfltXIId,0);
	in.state= sli->effectiveState;
	in.changed= pChanges->indicators.map_changes;
	XkbSendIndicatorNotify(kbd,XkbIndicatorMapNotify,&in);
    }
    if (pChanges->indicators.state_changes) {
	xkbIndicatorNotify in;
	if (sli==NULL)
	    sli= XkbFindSrvLedInfo(kbd,XkbDfltXIClass,XkbDfltXIId,0);
	in.state= sli->effectiveState;
	in.changed= pChanges->indicators.state_changes;
	XkbSendIndicatorNotify(kbd,XkbIndicatorStateNotify,&in);
    }
    if (pChanges->names.changed) {
	xkbNamesNotify nn;
	nn.changed= pChanges->names.changed;
	nn.firstType= pChanges->names.first_type;
	nn.nTypes= pChanges->names.num_types;
	nn.firstLevelName= pChanges->names.first_lvl;
	nn.nLevelNames= pChanges->names.num_lvls;
	nn.nRadioGroups= pChanges->names.num_rg;
	nn.changedVirtualMods= pChanges->names.changed_vmods;
	nn.changedIndicators= pChanges->names.changed_indicators;
	XkbSendNamesNotify(kbd,&nn);
    }
    if ((pChanges->compat.changed_groups)||(pChanges->compat.num_si>0)) {
	xkbCompatMapNotify cmn;
	cmn.changedGroups= pChanges->compat.changed_groups;
	cmn.firstSI= pChanges->compat.first_si;
	cmn.nSI= pChanges->compat.num_si;
	cmn.nTotalSI= kbd->key->xkbInfo->desc->compat->num_si;
	XkbSendCompatMapNotify(kbd,&cmn);
    }
    return;
}

/***====================================================================***/

Bool
#if NeedFunctionPrototypes
XkbFilterEvents(ClientPtr pClient,int nEvents,xEvent *xE)
#else
XkbFilterEvents(pClient,nEvents,xE)
    ClientPtr	 pClient;
    int		 nEvents;
    xEvent	*xE;
#endif
{
int	i, button_mask;
DeviceIntPtr pXDev = (DeviceIntPtr)LookupKeyboardDevice();
XkbSrvInfoPtr	xkbi;

    xkbi= pXDev->key->xkbInfo;
    if ( pClient->xkbClientFlags & _XkbClientInitialized ) {
#ifdef DEBUG
	if ((xkbDebugFlags&0x10)&&
		((xE[0].u.u.type==KeyPress)||(xE[0].u.u.type==KeyRelease))) {
	    ErrorF("XKbFilterWriteEvents:\n");
	    ErrorF("   Event state= 0x%04x\n",xE[0].u.keyButtonPointer.state);
	    ErrorF("   XkbLastRepeatEvent!=xE (0x%x!=0x%x) %s\n",
			XkbLastRepeatEvent,xE,
			((XkbLastRepeatEvent!=(pointer)xE)?"True":"False"));
	    ErrorF("   (xkbClientEventsFlags&XWDA)==0 (0x%x) %s\n",
		pClient->xkbClientFlags,
		(_XkbWantsDetectableAutoRepeat(pClient)?"True":"False"));
	    ErrorF("   !IsRelease(%d) %s\n",xE[0].u.u.type,
			(!_XkbIsReleaseEvent(xE[0].u.u.type))?"True":"False");
	}
#endif /* DEBUG */
	if (	(XkbLastRepeatEvent==(pointer)xE) &&
	     	(_XkbWantsDetectableAutoRepeat(pClient)) &&
	     	(_XkbIsReleaseEvent(xE[0].u.u.type)) ) {
	    return False;
	}
	if ((pXDev->grab != NullGrab) && pXDev->fromPassiveGrab &&
	    ((xE[0].u.u.type==KeyPress)||(xE[0].u.u.type==KeyRelease))) {
	    register unsigned state,flags;

	    flags= pClient->xkbClientFlags;
	    state= xkbi->state.compat_grab_mods;
	    if (flags & XkbPCF_GrabsUseXKBStateMask) {
		int group;
		if (flags&XkbPCF_LookupStateWhenGrabbed) {
		     group= xkbi->state.group;
		     state= xkbi->state.lookup_mods;
		}
		else {
		    state= xkbi->state.grab_mods;
		    group= xkbi->state.base_group+xkbi->state.latched_group;
		    if ((group<0)||(group>=xkbi->desc->ctrls->num_groups)) {
			group= XkbAdjustGroup(group,xkbi->desc->ctrls);
		    }
		}
		state = XkbBuildCoreState(state, group);
	    }
	    else if (flags&XkbPCF_LookupStateWhenGrabbed)
		state= xkbi->state.compat_lookup_mods;
	    xE[0].u.keyButtonPointer.state= state;
	}
	button_mask = 1 << xE[0].u.u.detail;
	if (xE[0].u.u.type == ButtonPress &&
	    ((xE[0].u.keyButtonPointer.state >> 7) & button_mask) == button_mask &&
	    (xkbi->lockedPtrButtons & button_mask) == button_mask) {
#ifdef DEBUG
	    /* If the MouseKeys is pressed, and the "real" mouse is also pressed
	     * when the mouse is released, the server does not behave properly.
	     * Faking a release of the button here solves the problem.
	     */
	    ErrorF("Faking release of button %d\n", xE[0].u.u.detail);
#endif
	    XkbDDXFakePointerButton(ButtonRelease, xE[0].u.u.detail);
        }
    }
    else {
	register CARD8 	type;

	for (i=0;i<nEvents;i++) {
	    type= xE[i].u.u.type;
#ifdef DEBUG
	    if ((xkbDebugFlags&0x4)&&
		((xE[0].u.u.type==KeyPress)||(xE[0].u.u.type==KeyRelease))) {
		XkbStatePtr s= &xkbi->state;
		ErrorF("XKbFilterWriteEvents (non-XKB):\n");
		ErrorF("event= 0x%04x\n",xE[0].u.keyButtonPointer.state);
		ErrorF("lookup= 0x%02x, grab= 0x%02x\n",s->lookup_mods,
							s->grab_mods);
		ErrorF("compat lookup= 0x%02x, grab= 0x%02x\n",
							s->compat_lookup_mods,
							s->compat_grab_mods);
	    }
#endif
	    if ( (type>=KeyPress)&&(type<=MotionNotify) ) {
		CARD16	old,new;

		old= xE[i].u.keyButtonPointer.state&(~0x1f00);
		new= xE[i].u.keyButtonPointer.state&0x1F00;

		if (old==XkbStateFieldFromRec(&xkbi->state))
		     new|= xkbi->state.compat_lookup_mods;
		else new|= xkbi->state.compat_grab_mods;
		xE[i].u.keyButtonPointer.state= new;
	    }
	    else if ((type==EnterNotify)||(type==LeaveNotify)) {
		xE->u.enterLeave.state&= 0x1F00;
		xE->u.enterLeave.state|= xkbi->state.compat_grab_mods;
	    }
	    button_mask = 1 << xE[i].u.u.detail;
	    if (type == ButtonPress &&
		((xE[i].u.keyButtonPointer.state >> 7) & button_mask) == button_mask &&
		(xkbi->lockedPtrButtons & button_mask) == button_mask) {
#ifdef DEBUG
		ErrorF("Faking release of button %d\n", xE[i].u.u.detail);
#endif
		XkbDDXFakePointerButton(ButtonRelease, xE[i].u.u.detail);
	    }
	}
    }
    return True;
}

/***====================================================================***/

XkbInterestPtr	
#if NeedFunctionPrototypes
XkbFindClientResource(DevicePtr inDev,ClientPtr client)
#else
XkbFindClientResource(inDev,client)
    DevicePtr	 inDev;
    ClientPtr	client;
#endif
{
DeviceIntPtr	dev = (DeviceIntPtr)inDev;
XkbInterestPtr	interest;

    if ( dev->xkb_interest ) {
	interest = dev->xkb_interest;
	while (interest){
	    if (interest->client==client) {
		return interest;
	    }
	    interest = interest->next;
	}
    }
    return NULL;
}

XkbInterestPtr	
#if NeedFunctionPrototypes
XkbAddClientResource(DevicePtr inDev,ClientPtr client,XID id)
#else
XkbAddClientResource(inDev,client,id)
    DevicePtr	 inDev;
    ClientPtr	client;
    XID		 id;
#endif
{
DeviceIntPtr	dev = (DeviceIntPtr)inDev;
XkbInterestPtr	interest;

    interest = dev->xkb_interest;
    while (interest) {
	if (interest->client==client)
	    return ((interest->resource==id)?interest:NULL);
	interest = interest->next;
    }
    interest = _XkbTypedAlloc(XkbInterestRec);
    bzero(interest,sizeof(XkbInterestRec));
    if (interest) {
	interest->dev = dev;
	interest->client = client;
	interest->resource = id;
	interest->stateNotifyMask= 0;
	interest->ctrlsNotifyMask= 0;
	interest->namesNotifyMask= 0;
	interest->compatNotifyMask= 0;
	interest->bellNotifyMask= FALSE;
	interest->accessXNotifyMask= 0;
	interest->iStateNotifyMask= 0;
	interest->iMapNotifyMask= 0;
	interest->altSymsNotifyMask= 0;
	interest->next = dev->xkb_interest;
	dev->xkb_interest= interest;
	return interest;
    }
    return NULL;
}

int
#if NeedFunctionPrototypes
XkbRemoveClient(DevicePtr inDev,ClientPtr client)
#else
XkbRemoveClient(inDev,client)
DevicePtr	inDev;
ClientPtr	client;
#endif
{
XkbSrvInfoPtr	xkbi;
DeviceIntPtr	dev = (DeviceIntPtr)inDev;
XkbInterestPtr	interest;
unsigned long	autoCtrls,autoValues;
Bool		found;

    found= False;
    autoCtrls= autoValues= 0;
    if ( dev->xkb_interest ) {
	interest = dev->xkb_interest;
	if (interest && (interest->client==client)){
	    dev->xkb_interest = interest->next;
	    autoCtrls= interest->autoCtrls;
	    autoValues= interest->autoCtrlValues;
	    _XkbFree(interest);
	    found= True;
	}
	while ((!found)&&(interest->next)) {
	    if (interest->next->client==client) {
		XkbInterestPtr	victim = interest->next;
		interest->next = victim->next;
		autoCtrls= victim->autoCtrls;
		autoValues= victim->autoCtrlValues;
		_XkbFree(victim);
		found= True;
	    }
	    interest = interest->next;
	}
    }
    if (found && autoCtrls && dev->key && dev->key->xkbInfo ) {
	XkbEventCauseRec cause;

	xkbi= dev->key->xkbInfo;
	XkbSetCauseXkbReq(&cause,X_kbPerClientFlags,client);
	XkbEnableDisableControls(xkbi,autoCtrls,autoValues,NULL,&cause);
    }
    return found;
}

int
#if NeedFunctionPrototypes
XkbRemoveResourceClient(DevicePtr inDev,XID id) 
#else
XkbRemoveResourceClient(inDev,id) 
    DevicePtr	 inDev;
    XID		 id;
#endif
{
XkbSrvInfoPtr	xkbi;
DeviceIntPtr	dev = (DeviceIntPtr)inDev;
XkbInterestPtr	interest;
Bool		found;
unsigned long	autoCtrls,autoValues;
ClientPtr	client = NULL;

    found= False;
    autoCtrls= autoValues= 0;
    if ( dev->xkb_interest ) {
	interest = dev->xkb_interest;
	if (interest && (interest->resource==id)){
	    dev->xkb_interest = interest->next;
	    autoCtrls= interest->autoCtrls;
	    autoValues= interest->autoCtrlValues;
	    client= interest->client;
	    _XkbFree(interest);
	    found= True;
	}
	while ((!found)&&(interest->next)) {
	    if (interest->next->resource==id) {
		XkbInterestPtr	victim = interest->next;
		interest->next = victim->next;
		autoCtrls= victim->autoCtrls;
		autoValues= victim->autoCtrlValues;
		client= victim->client;
		_XkbFree(victim);
		found= True;
	    }
	    interest = interest->next;
	}
    }
    if (found && autoCtrls && dev->key && dev->key->xkbInfo ) {
	XkbEventCauseRec cause;

	xkbi= dev->key->xkbInfo;
	XkbSetCauseXkbReq(&cause,X_kbPerClientFlags,client);
	XkbEnableDisableControls(xkbi,autoCtrls,autoValues,NULL,&cause);
    }
    return found;
}