~ubuntu-branches/ubuntu/trusty/xorg-server-lts-xenial/trusty-proposed

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

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.

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

#ifdef HAVE_DIX_CONFIG_H

#include <dix-config.h>

#endif

#include <stdio.h>

#include <math.h>

#include <X11/X.h>

#include <X11/Xproto.h>

#include <X11/keysym.h>

#include "misc.h"

#include "inputstr.h"

#include "exevents.h"

#include "eventstr.h"

#include <xkbsrv.h>

#include "xkb.h"

#include <ctype.h>

#include "mi.h"

#include "mipointer.h"

#include "inpututils.h"

#define EXTENSION_EVENT_BASE 64

DevPrivateKeyRec xkbDevicePrivateKeyRec;

static void XkbFakePointerMotion(DeviceIntPtr dev, unsigned flags, int x,

                                 int y);

void

xkbUnwrapProc(DeviceIntPtr device, DeviceHandleProc proc, void *data)

{

    xkbDeviceInfoPtr xkbPrivPtr = XKBDEVICEINFO(device);

    ProcessInputProc backupproc;

    if (xkbPrivPtr->unwrapProc)

        xkbPrivPtr->unwrapProc = NULL;

    UNWRAP_PROCESS_INPUT_PROC(device, xkbPrivPtr, backupproc);

    proc(device, data);

    COND_WRAP_PROCESS_INPUT_PROC(device, xkbPrivPtr, backupproc, xkbUnwrapProc);

}

Bool

XkbInitPrivates(void)

{

    return dixRegisterPrivateKey(&xkbDevicePrivateKeyRec, PRIVATE_DEVICE,

                                 sizeof(xkbDeviceInfoRec));

}

void

XkbSetExtension(DeviceIntPtr device, ProcessInputProc proc)

{

    xkbDeviceInfoPtr xkbPrivPtr = XKBDEVICEINFO(device);

    WRAP_PROCESS_INPUT_PROC(device, xkbPrivPtr, proc, xkbUnwrapProc);

}

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

static XkbAction

_FixUpAction(XkbDescPtr xkb, XkbAction *act)

{

    static XkbAction fake;

    if (XkbIsPtrAction(act) &&

        (!(xkb->ctrls->enabled_ctrls & XkbMouseKeysMask))) {

        fake.type = XkbSA_NoAction;

        return fake;

    }

    if (xkb->ctrls->enabled_ctrls & XkbStickyKeysMask) {

        if (act->any.type == XkbSA_SetMods) {

            fake.mods.type = XkbSA_LatchMods;

            fake.mods.mask = act->mods.mask;

            if (XkbAX_NeedOption(xkb->ctrls, XkbAX_LatchToLockMask))

                fake.mods.flags = XkbSA_ClearLocks | XkbSA_LatchToLock;

            else

                fake.mods.flags = XkbSA_ClearLocks;

            return fake;

        }

        if (act->any.type == XkbSA_SetGroup) {

            fake.group.type = XkbSA_LatchGroup;

            if (XkbAX_NeedOption(xkb->ctrls, XkbAX_LatchToLockMask))

                fake.group.flags = XkbSA_ClearLocks | XkbSA_LatchToLock;

            else

                fake.group.flags = XkbSA_ClearLocks;

            XkbSASetGroup(&fake.group, XkbSAGroup(&act->group));

            return fake;

        }

    }

    return *act;

}

static XkbAction

XkbGetKeyAction(XkbSrvInfoPtr xkbi, XkbStatePtr xkbState, CARD8 key)

{

    int effectiveGroup;

    int col;

    XkbDescPtr xkb;

    XkbKeyTypePtr type;

    XkbAction *pActs;

    static XkbAction fake;

    xkb = xkbi->desc;

    if (!XkbKeyHasActions(xkb, key) || !XkbKeycodeInRange(xkb, key)) {

        fake.type = XkbSA_NoAction;

        return fake;

    }

    pActs = XkbKeyActionsPtr(xkb, key);

    col = 0;

    effectiveGroup = XkbGetEffectiveGroup(xkbi, xkbState, key);

    if (effectiveGroup != XkbGroup1Index)

        col += (effectiveGroup * XkbKeyGroupsWidth(xkb, key));

    type = XkbKeyKeyType(xkb, key, effectiveGroup);

    if (type->map != NULL) {

        register unsigned i, mods;

        register XkbKTMapEntryPtr entry;

        mods = xkbState->mods & type->mods.mask;

        for (entry = type->map, i = 0; i < type->map_count; i++, entry++) {

            if ((entry->active) && (entry->mods.mask == mods)) {

                col += entry->level;

                break;

            }

        }

    }

    if (pActs[col].any.type == XkbSA_NoAction)

        return pActs[col];

    fake = _FixUpAction(xkb, &pActs[col]);

    return fake;

}

static XkbAction

XkbGetButtonAction(DeviceIntPtr kbd, DeviceIntPtr dev, int button)

{

    XkbAction fake;

    if ((dev->button) && (dev->button->xkb_acts)) {

        if (dev->button->xkb_acts[button - 1].any.type != XkbSA_NoAction) {

            fake = _FixUpAction(kbd->key->xkbInfo->desc,

                                &dev->button->xkb_acts[button - 1]);

            return fake;

        }

    }

    fake.any.type = XkbSA_NoAction;

    return fake;

}

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

#define	SYNTHETIC_KEYCODE	1

#define	BTN_ACT_FLAG		0x100

static int

_XkbFilterSetState(XkbSrvInfoPtr xkbi,

                   XkbFilterPtr filter, unsigned keycode, XkbAction *pAction)

{

    if (filter->keycode == 0) { /* initial press */

        AccessXCancelRepeatKey(xkbi, keycode);

        filter->keycode = keycode;

        filter->active = 1;

        filter->filterOthers = ((pAction->mods.mask & XkbSA_ClearLocks) != 0);

        filter->priv = 0;

        filter->filter = _XkbFilterSetState;

        if (pAction->type == XkbSA_SetMods) {

            filter->upAction = *pAction;

            xkbi->setMods = pAction->mods.mask;

        }

        else {

            xkbi->groupChange = XkbSAGroup(&pAction->group);

            if (pAction->group.flags & XkbSA_GroupAbsolute)

                xkbi->groupChange -= xkbi->state.base_group;

            filter->upAction = *pAction;

            XkbSASetGroup(&filter->upAction.group, xkbi->groupChange);

        }

    }

    else if (filter->keycode == keycode) {

        if (filter->upAction.type == XkbSA_SetMods) {

            xkbi->clearMods = filter->upAction.mods.mask;

            if (filter->upAction.mods.flags & XkbSA_ClearLocks) {

                xkbi->state.locked_mods &= ~filter->upAction.mods.mask;

            }

        }

        else {

            if (filter->upAction.group.flags & XkbSA_ClearLocks) {

                xkbi->state.locked_group = 0;

            }

            xkbi->groupChange = -XkbSAGroup(&filter->upAction.group);

        }

        filter->active = 0;

    }

    else {

        filter->upAction.mods.flags &= ~XkbSA_ClearLocks;

        filter->filterOthers = 0;

    }

    return 1;

}

#define	LATCH_KEY_DOWN	1

#define	LATCH_PENDING	2

static int

_XkbFilterLatchState(XkbSrvInfoPtr xkbi,

                     XkbFilterPtr filter, unsigned keycode, XkbAction *pAction)

{

    if (filter->keycode == 0) { /* initial press */

        AccessXCancelRepeatKey(xkbi,keycode);

        filter->keycode = keycode;

        filter->active = 1;

        filter->filterOthers = 1;

        filter->priv = LATCH_KEY_DOWN;

        filter->filter = _XkbFilterLatchState;

        if (pAction->type == XkbSA_LatchMods) {

            filter->upAction = *pAction;

            xkbi->setMods = pAction->mods.mask;

        }

        else {

            xkbi->groupChange = XkbSAGroup(&pAction->group);

            if (pAction->group.flags & XkbSA_GroupAbsolute)

                xkbi->groupChange -= xkbi->state.base_group;

            filter->upAction = *pAction;

            XkbSASetGroup(&filter->upAction.group, xkbi->groupChange);

        }

    }

    else if (pAction && (filter->priv == LATCH_PENDING)) {

        if (((1 << pAction->type) & XkbSA_BreakLatch) != 0) {

            filter->active = 0;

            /* If one latch is broken, all latches are broken, so it's no use

               to find out which particular latch this filter tracks. */

            xkbi->state.latched_mods = 0;

            xkbi->state.latched_group = 0;

        }

    }

    else if (filter->keycode == keycode && filter->priv != LATCH_PENDING){

        /* The test above for LATCH_PENDING skips subsequent releases of the

           key after it has been released first time and the latch became

           pending. */

        XkbControlsPtr ctrls = xkbi->desc->ctrls;

        int needBeep = ((ctrls->enabled_ctrls & XkbStickyKeysMask) &&

                        XkbAX_NeedFeedback(ctrls, XkbAX_StickyKeysFBMask));

        if (filter->upAction.type == XkbSA_LatchMods) {

            unsigned char mask = filter->upAction.mods.mask;

            unsigned char common;

            xkbi->clearMods = mask;

            /* ClearLocks */

            common = mask & xkbi->state.locked_mods;

            if ((filter->upAction.mods.flags & XkbSA_ClearLocks) && common) {

                mask &= ~common;

                xkbi->state.locked_mods &= ~common;

                if (needBeep)

                    XkbDDXAccessXBeep(xkbi->device, _BEEP_STICKY_UNLOCK,

                                      XkbStickyKeysMask);

            }

            /* LatchToLock */

            common = mask & xkbi->state.latched_mods;

            if ((filter->upAction.mods.flags & XkbSA_LatchToLock) && common) {

                unsigned char newlocked;

                mask &= ~common;

                newlocked = common & ~xkbi->state.locked_mods;

                if(newlocked){

                    xkbi->state.locked_mods |= newlocked;

                    if (needBeep)

                        XkbDDXAccessXBeep(xkbi->device, _BEEP_STICKY_LOCK,

                                          XkbStickyKeysMask);

                }

                xkbi->state.latched_mods &= ~common;

            }

            /* Latch remaining modifiers, if any. */

            if (mask) {

                xkbi->state.latched_mods |= mask;

                filter->priv = LATCH_PENDING;

                if (needBeep)

                    XkbDDXAccessXBeep(xkbi->device, _BEEP_STICKY_LATCH,

                                      XkbStickyKeysMask);

            }

        }

        else {

            xkbi->groupChange = -XkbSAGroup(&filter->upAction.group);

            /* ClearLocks */

            if ((filter->upAction.group.flags & XkbSA_ClearLocks) &&

                (xkbi->state.locked_group)) {

                xkbi->state.locked_group = 0;

                if (needBeep)

                    XkbDDXAccessXBeep(xkbi->device, _BEEP_STICKY_UNLOCK,

                                      XkbStickyKeysMask);

            }

            /* LatchToLock */

            else if ((filter->upAction.group.flags & XkbSA_LatchToLock)

                     && (xkbi->state.latched_group)) {

                xkbi->state.locked_group  += XkbSAGroup(&filter->upAction.group);

                xkbi->state.latched_group -= XkbSAGroup(&filter->upAction.group);

                if(XkbSAGroup(&filter->upAction.group) && needBeep)

                    XkbDDXAccessXBeep(xkbi->device, _BEEP_STICKY_LOCK,

                                      XkbStickyKeysMask);

            }

            /* Latch group */

            else if(XkbSAGroup(&filter->upAction.group)){

                xkbi->state.latched_group += XkbSAGroup(&filter->upAction.group);

                filter->priv = LATCH_PENDING;

                if (needBeep)

                    XkbDDXAccessXBeep(xkbi->device, _BEEP_STICKY_LATCH,

                                      XkbStickyKeysMask);

            }

        }

        if (filter->priv != LATCH_PENDING)

            filter->active = 0;

    }

    else if (pAction && (filter->priv == LATCH_KEY_DOWN)) {

        /* Latch was broken before it became pending: degrade to a

           SetMods/SetGroup. */

        if (filter->upAction.type == XkbSA_LatchMods)

            filter->upAction.type = XkbSA_SetMods;

        else

            filter->upAction.type = XkbSA_SetGroup;

        filter->filter = _XkbFilterSetState;

        filter->priv = 0;

        return filter->filter(xkbi, filter, keycode, pAction);

    }

    return 1;

}

static int

_XkbFilterLockState(XkbSrvInfoPtr xkbi,

                    XkbFilterPtr filter, unsigned keycode, XkbAction *pAction)

{

    if (filter->keycode == 0) /* initial press */

        AccessXCancelRepeatKey(xkbi, keycode);

    if (pAction && (pAction->type == XkbSA_LockGroup)) {

        if (pAction->group.flags & XkbSA_GroupAbsolute)

            xkbi->state.locked_group = XkbSAGroup(&pAction->group);

        else

            xkbi->state.locked_group += XkbSAGroup(&pAction->group);

        return 1;

    }

    if (filter->keycode == 0) { /* initial press */

        filter->keycode = keycode;

        filter->active = 1;

        filter->filterOthers = 0;

        filter->priv = xkbi->state.locked_mods & pAction->mods.mask;

        filter->filter = _XkbFilterLockState;

        filter->upAction = *pAction;

        if (!(filter->upAction.mods.flags & XkbSA_LockNoLock))

            xkbi->state.locked_mods |= pAction->mods.mask;

        xkbi->setMods = pAction->mods.mask;

    }

    else if (filter->keycode == keycode) {

        filter->active = 0;

        xkbi->clearMods = filter->upAction.mods.mask;

        if (!(filter->upAction.mods.flags & XkbSA_LockNoUnlock))

            xkbi->state.locked_mods &= ~filter->priv;

    }

    return 1;

}

#define	ISO_KEY_DOWN		0

#define	NO_ISO_LOCK		1

static int

_XkbFilterISOLock(XkbSrvInfoPtr xkbi,

                  XkbFilterPtr filter, unsigned keycode, XkbAction *pAction)

{

    if (filter->keycode == 0) { /* initial press */

        CARD8 flags = pAction->iso.flags;

        filter->keycode = keycode;

        filter->active = 1;

        filter->filterOthers = 1;

        filter->priv = ISO_KEY_DOWN;

        filter->upAction = *pAction;

        filter->filter = _XkbFilterISOLock;

        if (flags & XkbSA_ISODfltIsGroup) {

            xkbi->groupChange = XkbSAGroup(&pAction->iso);

            xkbi->setMods = 0;

        }

        else {

            xkbi->setMods = pAction->iso.mask;

            xkbi->groupChange = 0;

        }

        if ((!(flags & XkbSA_ISONoAffectMods)) && (xkbi->state.base_mods)) {

            filter->priv = NO_ISO_LOCK;

            xkbi->state.locked_mods ^= xkbi->state.base_mods;

        }

        if ((!(flags & XkbSA_ISONoAffectGroup)) && (xkbi->state.base_group)) {

/* 6/22/93 (ef) -- lock groups if group key is down first */

        }

        if (!(flags & XkbSA_ISONoAffectPtr)) {

/* 6/22/93 (ef) -- lock mouse buttons if they're down */

        }

    }

    else if (filter->keycode == keycode) {

        CARD8 flags = filter->upAction.iso.flags;

        if (flags & XkbSA_ISODfltIsGroup) {

            xkbi->groupChange = -XkbSAGroup(&filter->upAction.iso);

            xkbi->clearMods = 0;

            if (filter->priv == ISO_KEY_DOWN)

                xkbi->state.locked_group += XkbSAGroup(&filter->upAction.iso);

        }

        else {

            xkbi->clearMods = filter->upAction.iso.mask;

            xkbi->groupChange = 0;

            if (filter->priv == ISO_KEY_DOWN)

                xkbi->state.locked_mods ^= filter->upAction.iso.mask;

        }

        filter->active = 0;

    }

    else if (pAction) {

        CARD8 flags = filter->upAction.iso.flags;

        switch (pAction->type) {

        case XkbSA_SetMods:

        case XkbSA_LatchMods:

            if (!(flags & XkbSA_ISONoAffectMods)) {

                pAction->type = XkbSA_LockMods;

                filter->priv = NO_ISO_LOCK;

            }

            break;

        case XkbSA_SetGroup:

        case XkbSA_LatchGroup:

            if (!(flags & XkbSA_ISONoAffectGroup)) {

                pAction->type = XkbSA_LockGroup;

                filter->priv = NO_ISO_LOCK;

            }

            break;

        case XkbSA_PtrBtn:

            if (!(flags & XkbSA_ISONoAffectPtr)) {

                pAction->type = XkbSA_LockPtrBtn;

                filter->priv = NO_ISO_LOCK;

            }

            break;

        case XkbSA_SetControls:

            if (!(flags & XkbSA_ISONoAffectCtrls)) {

                pAction->type = XkbSA_LockControls;

                filter->priv = NO_ISO_LOCK;

            }

            break;

        }

    }

    return 1;

}

static CARD32

_XkbPtrAccelExpire(OsTimerPtr timer, CARD32 now, void *arg)

{

    XkbSrvInfoPtr xkbi = (XkbSrvInfoPtr) arg;

    XkbControlsPtr ctrls = xkbi->desc->ctrls;

    int dx, dy;

    if (xkbi->mouseKey == 0)

        return 0;

    if (xkbi->mouseKeysAccel) {

        if ((xkbi->mouseKeysCounter) < ctrls->mk_time_to_max) {

            double step;

            xkbi->mouseKeysCounter++;

            step = xkbi->mouseKeysCurveFactor *

                pow((double) xkbi->mouseKeysCounter, xkbi->mouseKeysCurve);

            if (xkbi->mouseKeysDX < 0)

                dx = floor(((double) xkbi->mouseKeysDX) * step);

            else

                dx = ceil(((double) xkbi->mouseKeysDX) * step);

            if (xkbi->mouseKeysDY < 0)

                dy = floor(((double) xkbi->mouseKeysDY) * step);

            else

                dy = ceil(((double) xkbi->mouseKeysDY) * step);

        }

        else {

            dx = xkbi->mouseKeysDX * ctrls->mk_max_speed;

            dy = xkbi->mouseKeysDY * ctrls->mk_max_speed;

        }

        if (xkbi->mouseKeysFlags & XkbSA_MoveAbsoluteX)

            dx = xkbi->mouseKeysDX;

        if (xkbi->mouseKeysFlags & XkbSA_MoveAbsoluteY)

            dy = xkbi->mouseKeysDY;

    }

    else {

        dx = xkbi->mouseKeysDX;

        dy = xkbi->mouseKeysDY;

    }

    XkbFakePointerMotion(xkbi->device, xkbi->mouseKeysFlags, dx, dy);

    return xkbi->desc->ctrls->mk_interval;

}

static int

_XkbFilterPointerMove(XkbSrvInfoPtr xkbi,

                      XkbFilterPtr filter, unsigned keycode, XkbAction *pAction)

{

    int x, y;

    Bool accel;

    if (filter->keycode == 0) { /* initial press */

        filter->keycode = keycode;

        filter->active = 1;

        filter->filterOthers = 0;

        filter->priv = 0;

        filter->filter = _XkbFilterPointerMove;

        filter->upAction = *pAction;

        xkbi->mouseKeysCounter = 0;

        xkbi->mouseKey = keycode;

        accel = ((pAction->ptr.flags & XkbSA_NoAcceleration) == 0);

        x = XkbPtrActionX(&pAction->ptr);

        y = XkbPtrActionY(&pAction->ptr);

        XkbFakePointerMotion(xkbi->device, pAction->ptr.flags, x, y);

        AccessXCancelRepeatKey(xkbi, keycode);

        xkbi->mouseKeysAccel = accel &&

            (xkbi->desc->ctrls->enabled_ctrls & XkbMouseKeysAccelMask);

        xkbi->mouseKeysFlags = pAction->ptr.flags;

        xkbi->mouseKeysDX = XkbPtrActionX(&pAction->ptr);

        xkbi->mouseKeysDY = XkbPtrActionY(&pAction->ptr);

        xkbi->mouseKeyTimer = TimerSet(xkbi->mouseKeyTimer, 0,

                                       xkbi->desc->ctrls->mk_delay,

                                       _XkbPtrAccelExpire, (void *) xkbi);

    }

    else if (filter->keycode == keycode) {

        filter->active = 0;

        if (xkbi->mouseKey == keycode) {

            xkbi->mouseKey = 0;

            xkbi->mouseKeyTimer = TimerSet(xkbi->mouseKeyTimer, 0, 0,

                                           NULL, NULL);

        }

    }

    return 0;

}

static int

_XkbFilterPointerBtn(XkbSrvInfoPtr xkbi,

                     XkbFilterPtr filter, unsigned keycode, XkbAction *pAction)

{

    if (filter->keycode == 0) { /* initial press */

        int button = pAction->btn.button;

        if (button == XkbSA_UseDfltButton)

            button = xkbi->desc->ctrls->mk_dflt_btn;

        filter->keycode = keycode;

        filter->active = 1;

        filter->filterOthers = 0;

        filter->priv = 0;

        filter->filter = _XkbFilterPointerBtn;

        filter->upAction = *pAction;

        filter->upAction.btn.button = button;

        switch (pAction->type) {

        case XkbSA_LockPtrBtn:

            if (((xkbi->lockedPtrButtons & (1 << button)) == 0) &&

                ((pAction->btn.flags & XkbSA_LockNoLock) == 0)) {

                xkbi->lockedPtrButtons |= (1 << button);

                AccessXCancelRepeatKey(xkbi, keycode);

                XkbFakeDeviceButton(xkbi->device, 1, button);

                filter->upAction.type = XkbSA_NoAction;

            }

            break;

        case XkbSA_PtrBtn:

        {

            register int i, nClicks;

            AccessXCancelRepeatKey(xkbi, keycode);

            if (pAction->btn.count > 0) {

                nClicks = pAction->btn.count;

                for (i = 0; i < nClicks; i++) {

                    XkbFakeDeviceButton(xkbi->device, 1, button);

                    XkbFakeDeviceButton(xkbi->device, 0, button);

                }

                filter->upAction.type = XkbSA_NoAction;

            }

            else

                XkbFakeDeviceButton(xkbi->device, 1, button);

        }

            break;

        case XkbSA_SetPtrDflt:

        {

            XkbControlsPtr ctrls = xkbi->desc->ctrls;

            XkbControlsRec old;

            xkbControlsNotify cn;

            old = *ctrls;

            AccessXCancelRepeatKey(xkbi, keycode);

            switch (pAction->dflt.affect) {

            case XkbSA_AffectDfltBtn:

                if (pAction->dflt.flags & XkbSA_DfltBtnAbsolute)

                    ctrls->mk_dflt_btn = XkbSAPtrDfltValue(&pAction->dflt);

                else {

                    ctrls->mk_dflt_btn += XkbSAPtrDfltValue(&pAction->dflt);

                    if (ctrls->mk_dflt_btn > 5)

                        ctrls->mk_dflt_btn = 5;

                    else if (ctrls->mk_dflt_btn < 1)

                        ctrls->mk_dflt_btn = 1;

                }

                break;

            default:

                ErrorF

                    ("Attempt to change unknown pointer default (%d) ignored\n",

                     pAction->dflt.affect);

                break;

            }

            if (XkbComputeControlsNotify(xkbi->device,

                                         &old, xkbi->desc->ctrls, &cn, FALSE)) {

                cn.keycode = keycode;

                /* XXX: what about DeviceKeyPress? */

                cn.eventType = KeyPress;

                cn.requestMajor = 0;

                cn.requestMinor = 0;

                XkbSendControlsNotify(xkbi->device, &cn);

            }

        }

            break;

        }

        return 0;

    }

    else if (filter->keycode == keycode) {

        int button = filter->upAction.btn.button;

        switch (filter->upAction.type) {

        case XkbSA_LockPtrBtn:

            if (((filter->upAction.btn.flags & XkbSA_LockNoUnlock) != 0) ||

                ((xkbi->lockedPtrButtons & (1 << button)) == 0)) {

                break;

            }

            xkbi->lockedPtrButtons &= ~(1 << button);

            if (IsMaster(xkbi->device)) {

                XkbMergeLockedPtrBtns(xkbi->device);

                /* One SD still has lock set, don't post event */

                if ((xkbi->lockedPtrButtons & (1 << button)) != 0)

                    break;

            }

            /* fallthrough */

        case XkbSA_PtrBtn:

            XkbFakeDeviceButton(xkbi->device, 0, button);

            break;

        }

        filter->active = 0;

        return 0;

    }

    return 1;

}

static int

_XkbFilterControls(XkbSrvInfoPtr xkbi,

                   XkbFilterPtr filter, unsigned keycode, XkbAction *pAction)

{

    XkbControlsRec old;

    XkbControlsPtr ctrls;

    DeviceIntPtr kbd;

    unsigned int change;

    XkbEventCauseRec cause;

    kbd = xkbi->device;

    ctrls = xkbi->desc->ctrls;

    old = *ctrls;

    if (filter->keycode == 0) { /* initial press */

        AccessXCancelRepeatKey(xkbi, keycode);

        filter->keycode = keycode;

        filter->active = 1;

        filter->filterOthers = 0;

        change = XkbActionCtrls(&pAction->ctrls);

        filter->priv = change;

        filter->filter = _XkbFilterControls;

        filter->upAction = *pAction;

        if (pAction->type == XkbSA_LockControls) {

            filter->priv = (ctrls->enabled_ctrls & change);

            change &= ~ctrls->enabled_ctrls;

        }

        if (change) {

            xkbControlsNotify cn;

            XkbSrvLedInfoPtr sli;

            ctrls->enabled_ctrls |= change;

            if (XkbComputeControlsNotify(kbd, &old, ctrls, &cn, FALSE)) {