static void
AccessXStickyKeysTurnOff(DeviceIntPtr dev,xkbControlsNotify *pCN)
{
XkbSrvInfoPtr xkbi = dev->key->xkbInfo;
XkbControlsPtr ctrls = xkbi->desc->ctrls;
XkbControlsRec old;
XkbEventCauseRec cause;
XkbSrvLedInfoPtr sli;
old = *ctrls;
ctrls->enabled_ctrls &= ~XkbStickyKeysMask;
xkbi->shiftKeyCount = 0;
if (XkbComputeControlsNotify(dev,&old,ctrls,pCN,False))
XkbSendControlsNotify(dev,pCN);
cause.kc= pCN->keycode;
cause.event= pCN->eventType;
cause.mjr= pCN->requestMajor;
cause.mnr= pCN->requestMinor;
sli= XkbFindSrvLedInfo(dev,XkbDfltXIClass,XkbDfltXIId,0);
XkbUpdateIndicators(dev,sli->usesControls,True,NULL,&cause);
if (XkbAX_NeedFeedback(ctrls,XkbAX_FeatureFBMask)) {
XkbDDXAccessXBeep(dev,_BEEP_FEATURE_OFF,XkbStickyKeysMask);
}
#ifndef NO_CLEAR_LATCHES_FOR_STICKY_KEYS_OFF
XkbClearAllLatchesAndLocks(dev,xkbi,False,&cause);
#endif
return;
} /* AccessXStickyKeysTurnOff */
static void
AccessXKRGTurnOff(DeviceIntPtr dev,xkbControlsNotify *pCN)
{
XkbSrvInfoPtr xkbi = dev->key->xkbInfo;
XkbControlsPtr ctrls = xkbi->desc->ctrls;
XkbControlsRec old;
XkbEventCauseRec cause;
XkbSrvLedInfoPtr sli;
old = *ctrls;
ctrls->enabled_ctrls &= ~XkbAX_KRGMask;
if (XkbComputeControlsNotify(dev,&old,ctrls,pCN,False))
XkbSendControlsNotify(dev,pCN);
cause.kc= pCN->keycode;
cause.event= pCN->eventType;
cause.mjr= pCN->requestMajor;
cause.mnr= pCN->requestMinor;
sli= XkbFindSrvLedInfo(dev,XkbDfltXIClass,XkbDfltXIId,0);
XkbUpdateIndicators(dev,sli->usesControls,True,NULL,&cause);
if (XkbAX_NeedFeedback(ctrls,XkbAX_FeatureFBMask)) {
unsigned changes= old.enabled_ctrls^ctrls->enabled_ctrls;
XkbDDXAccessXBeep(dev,_BEEP_FEATURE_OFF,changes);
}
return;
} /* AccessXKRGTurnOff */
/*
* InitKeyClassDeviceStruct initializes the key class before it
* initializes the keyboard feedback class for a device.
* UpdateActions can't set up the correct autorepeat for keyboard
* initialization because the keyboard feedback isn't created yet.
* Instead, UpdateActions notes the "correct" autorepeat in the
* SrvInfo structure and InitKbdFeedbackClass calls UpdateAutoRepeat
* to apply the computed autorepeat once the feedback class exists.
*
* DIX will apply the changed autorepeat, so there's no need to
* do so here. This function returns True if both RepeatKeys and
* the core protocol autorepeat ctrls are set (i.e. should use
* software autorepeat), false otherwise.
*
* This function also computes the autorepeat accelerators for the
* default indicator feedback.
*/
int
XkbFinishDeviceInit(DeviceIntPtr pXDev)
{
XkbSrvInfoPtr xkbi;
XkbDescPtr xkb;
int softRepeat;
XkbSrvLedInfoPtr sli;
xkbi = NULL;
if (pXDev && pXDev->key && pXDev->key->xkbInfo && pXDev->kbdfeed) {
xkbi= pXDev->key->xkbInfo;
xkb= xkbi->desc;
if (pXDev->kbdfeed) {
xkbi->kbdProc= pXDev->kbdfeed->CtrlProc;
pXDev->kbdfeed->CtrlProc= XkbDDXKeybdCtrlProc;
}
if (pXDev->kbdfeed->ctrl.autoRepeat)
xkb->ctrls->enabled_ctrls|= XkbRepeatKeysMask;
softRepeat= (xkb->ctrls->enabled_ctrls&XkbRepeatKeysMask)!=0;
if (pXDev->kbdfeed) {
memcpy(pXDev->kbdfeed->ctrl.autoRepeats,
xkb->ctrls->per_key_repeat,XkbPerKeyBitArraySize);
softRepeat= softRepeat&&pXDev->kbdfeed->ctrl.autoRepeat;
}
}
else softRepeat= 0;
sli= XkbFindSrvLedInfo(pXDev,XkbDfltXIClass,XkbDfltXIId,0);
if (sli && xkbi)
XkbCheckIndicatorMaps(xkbi->device,sli,XkbAllIndicatorsMask);
#ifdef DEBUG
else ErrorF("No indicator feedback in XkbFinishInit (shouldn't happen)!\n");
#endif
return softRepeat;
}
void
ProcessPointerEvent( register xEvent * xE,
register DeviceIntPtr mouse,
int count)
{
DeviceIntPtr dev = (DeviceIntPtr)LookupKeyboardDevice();
XkbSrvInfoPtr xkbi = dev->key->xkbInfo;
unsigned changed = 0;
xkbi->shiftKeyCount = 0;
xkbi->lastPtrEventTime= xE->u.keyButtonPointer.time;
if (xE->u.u.type==ButtonPress) {
changed |= XkbPointerButtonMask;
}
else if (xE->u.u.type==ButtonRelease) {
xkbi->lockedPtrButtons&= ~(1<<(xE->u.u.detail&0x7));
changed |= XkbPointerButtonMask;
}
CoreProcessPointerEvent(xE,mouse,count);
xkbi->state.ptr_buttons = mouse->button->state;
/* clear any latched modifiers */
if ( xkbi->state.latched_mods && (xE->u.u.type==ButtonRelease) ) {
unsigned changed_leds;
XkbStateRec oldState;
XkbSrvLedInfoPtr sli;
sli= XkbFindSrvLedInfo(dev,XkbDfltXIClass,XkbDfltXIId,0);
oldState= xkbi->state;
XkbLatchModifiers(dev,0xFF,0x00);
XkbComputeDerivedState(xkbi);
changed |= XkbStateChangedFlags(&oldState,&xkbi->state);
if (changed&sli->usedComponents) {
changed_leds= XkbIndicatorsToUpdate(dev,changed,False);
if (changed_leds) {
XkbEventCauseRec cause;
XkbSetCauseKey(&cause,(xE->u.u.detail&0x7),xE->u.u.type);
XkbUpdateIndicators(dev,changed_leds,True,NULL,&cause);
}
}
dev->key->state= XkbStateFieldFromRec(&xkbi->state);
}
if (((xkbi->flags&_XkbStateNotifyInProgress)==0)&&(changed!=0)) {
xkbStateNotify sn;
sn.keycode= xE->u.u.detail;
sn.eventType= xE->u.u.type;
sn.requestMajor = sn.requestMinor = 0;
sn.changed= changed;
XkbSendStateNotify(dev,&sn);
}
} /* ProcessPointerEvent */
static CARD32
AccessXTimeoutExpire(OsTimerPtr timer,CARD32 now,pointer arg)
{
DeviceIntPtr dev = (DeviceIntPtr)arg;
XkbSrvInfoPtr xkbi= dev->key->xkbInfo;
XkbControlsPtr ctrls= xkbi->desc->ctrls;
XkbControlsRec old;
xkbControlsNotify cn;
XkbEventCauseRec cause;
XkbSrvLedInfoPtr sli;
if (xkbi->lastPtrEventTime) {
unsigned timeToWait = (ctrls->ax_timeout*1000);
unsigned timeElapsed = (now-xkbi->lastPtrEventTime);
if (timeToWait > timeElapsed)
return (timeToWait - timeElapsed);
}
old= *ctrls;
xkbi->shiftKeyCount= 0;
ctrls->enabled_ctrls&= ~ctrls->axt_ctrls_mask;
ctrls->enabled_ctrls|=
(ctrls->axt_ctrls_values&ctrls->axt_ctrls_mask);
if (ctrls->axt_opts_mask) {
ctrls->ax_options&= ~ctrls->axt_opts_mask;
ctrls->ax_options|= (ctrls->axt_opts_values&ctrls->axt_opts_mask);
}
if (XkbComputeControlsNotify(dev,&old,ctrls,&cn,False)) {
cn.keycode = 0;
cn.eventType = 0;
cn.requestMajor = 0;
cn.requestMinor = 0;
XkbSendControlsNotify(dev,&cn);
}
XkbSetCauseUnknown(&cause);
sli= XkbFindSrvLedInfo(dev,XkbDfltXIClass,XkbDfltXIId,0);
XkbUpdateIndicators(dev,sli->usesControls,True,NULL,&cause);
if (ctrls->ax_options!=old.ax_options) {
unsigned set,cleared,bell;
set= ctrls->ax_options&(~old.ax_options);
cleared= (~ctrls->ax_options)&old.ax_options;
if (set && cleared) bell= _BEEP_FEATURE_CHANGE;
else if (set) bell= _BEEP_FEATURE_ON;
else bell= _BEEP_FEATURE_OFF;
XkbDDXAccessXBeep(dev,bell,XkbAccessXTimeoutMask);
}
xkbi->krgTimerActive= _OFF_TIMER;
return 0;
}
static Status
XkbInitIndicatorMap(XkbSrvInfoPtr xkbi)
{
XkbDescPtr xkb;
XkbIndicatorPtr map;
XkbSrvLedInfoPtr sli;
xkb= xkbi->desc;
if (XkbAllocIndicatorMaps(xkb)!=Success)
return BadAlloc;
if (!(xkb->defined & XkmIndicatorsMask)) {
map= xkb->indicators;
map->phys_indicators = PHYS_LEDS;
map->maps[LED_CAPS-1].flags= XkbIM_NoExplicit;
map->maps[LED_CAPS-1].which_mods= XkbIM_UseLocked;
map->maps[LED_CAPS-1].mods.mask= LockMask;
map->maps[LED_CAPS-1].mods.real_mods= LockMask;
map->maps[LED_NUM-1].flags= XkbIM_NoExplicit;
map->maps[LED_NUM-1].which_mods= XkbIM_UseLocked;
map->maps[LED_NUM-1].mods.mask= 0;
map->maps[LED_NUM-1].mods.real_mods= 0;
map->maps[LED_NUM-1].mods.vmods= vmod_NumLockMask;
map->maps[LED_SCROLL-1].flags= XkbIM_NoExplicit;
map->maps[LED_SCROLL-1].which_mods= XkbIM_UseLocked;
map->maps[LED_SCROLL-1].mods.mask= Mod3Mask;
map->maps[LED_SCROLL-1].mods.real_mods= Mod3Mask;
}
sli= XkbFindSrvLedInfo(xkbi->device,XkbDfltXIClass,XkbDfltXIId,0);
if (sli)
XkbCheckIndicatorMaps(xkbi->device,sli,XkbAllIndicatorsMask);
return Success;
}
_X_EXPORT Bool
InitKeyboardDeviceStruct(DeviceIntPtr dev, XkbRMLVOSet *rmlvo,
BellProcPtr bell_func, KbdCtrlProcPtr ctrl_func)
{
int i;
unsigned int check;
XkbSrvInfoPtr xkbi;
XkbDescPtr xkb;
XkbSrvLedInfoPtr sli;
XkbChangesRec changes;
XkbEventCauseRec cause;
XkbRMLVOSet rmlvo_dflts = { NULL };
if (dev->key || dev->kbdfeed)
return FALSE;
if (!rmlvo)
{
rmlvo = &rmlvo_dflts;
XkbGetRulesDflts(rmlvo);
}
memset(&changes, 0, sizeof(changes));
XkbSetCauseUnknown(&cause);
dev->key = calloc(1, sizeof(*dev->key));
if (!dev->key) {
ErrorF("XKB: Failed to allocate key class\n");
return FALSE;
}
dev->key->sourceid = dev->id;
dev->kbdfeed = calloc(1, sizeof(*dev->kbdfeed));
if (!dev->kbdfeed) {
ErrorF("XKB: Failed to allocate key feedback class\n");
goto unwind_key;
}
xkbi = calloc(1, sizeof(*xkbi));
if (!xkbi) {
ErrorF("XKB: Failed to allocate XKB info\n");
goto unwind_kbdfeed;
}
dev->key->xkbInfo = xkbi;
if (xkb_cached_map && !XkbCompareUsedRMLVO(rmlvo)) {
XkbFreeKeyboard(xkb_cached_map, XkbAllComponentsMask, TRUE);
xkb_cached_map = NULL;
}
if (xkb_cached_map)
LogMessageVerb(X_INFO, 4, "XKB: Reusing cached keymap\n");
else {
xkb_cached_map = XkbCompileKeymap(dev, rmlvo);
if (!xkb_cached_map) {
ErrorF("XKB: Failed to compile keymap\n");
goto unwind_info;
}
}
xkb = XkbAllocKeyboard();
if (!xkb) {
ErrorF("XKB: Failed to allocate keyboard description\n");
goto unwind_info;
}
if (!XkbCopyKeymap(xkb, xkb_cached_map)) {
ErrorF("XKB: Failed to copy keymap\n");
goto unwind_desc;
}
xkb->defined = xkb_cached_map->defined;
xkb->flags = xkb_cached_map->flags;
xkb->device_spec = xkb_cached_map->device_spec;
xkbi->desc = xkb;
if (xkb->min_key_code == 0)
xkb->min_key_code = 8;
if (xkb->max_key_code == 0)
xkb->max_key_code = 255;
i = XkbNumKeys(xkb) / 3 + 1;
if (XkbAllocClientMap(xkb, XkbAllClientInfoMask, 0) != Success)
goto unwind_desc;
if (XkbAllocServerMap(xkb, XkbAllServerInfoMask, i) != Success)
goto unwind_desc;
xkbi->dfltPtrDelta = 1;
xkbi->device = dev;
XkbInitSemantics(xkb);
XkbInitNames(xkbi);
XkbInitRadioGroups(xkbi);
XkbInitControls(dev, xkbi);
XkbInitIndicatorMap(xkbi);
XkbUpdateActions(dev, xkb->min_key_code, XkbNumKeys(xkb), &changes,
&check, &cause);
InitFocusClassDeviceStruct(dev);
xkbi->kbdProc = ctrl_func;
dev->kbdfeed->BellProc = bell_func;
dev->kbdfeed->CtrlProc = XkbDDXKeybdCtrlProc;
dev->kbdfeed->ctrl = defaultKeyboardControl;
if (dev->kbdfeed->ctrl.autoRepeat)
xkb->ctrls->enabled_ctrls |= XkbRepeatKeysMask;
memcpy(dev->kbdfeed->ctrl.autoRepeats, xkb->ctrls->per_key_repeat,
XkbPerKeyBitArraySize);
sli = XkbFindSrvLedInfo(dev, XkbDfltXIClass, XkbDfltXIId, 0);
if (sli)
XkbCheckIndicatorMaps(dev, sli, XkbAllIndicatorsMask);
else
DebugF("XKB: No indicator feedback in XkbFinishInit!\n");
dev->kbdfeed->CtrlProc(dev,&dev->kbdfeed->ctrl);
XkbSetRulesDflts(rmlvo);
XkbSetRulesUsed(rmlvo);
XkbFreeRMLVOSet(&rmlvo_dflts, FALSE);
return TRUE;
unwind_desc:
XkbFreeKeyboard(xkb, 0, TRUE);
unwind_info:
free(xkbi);
dev->key->xkbInfo = NULL;
unwind_kbdfeed:
free(dev->kbdfeed);
dev->kbdfeed = NULL;
unwind_key:
free(dev->key);
dev->key = NULL;
return FALSE;
}
