<<>>
    <<XlInputExtensionImpl.mesa>>
        <<Copyright Ó 1991, 1992, 1993 by Xerox Corporation.  All rights reserved.>>
        <<Created by Christian Jacobi, December 30, 1991 1:59 pm PST>>
        <<Christian Jacobi, February 2, 1993 4:07 pm PST>>
        <<>>
    DIRECTORY Rope, Xl, XlDispatch, XlEndianPrivate, XlExtensions, XlInputExtension, XlInputExtensionPrivate, XlKeyButPrivate, 
    XlPrivate;

    XlInputExtensionImpl: CEDAR MONITOR 
        LOCKS c USING c: Xl.Connection 
        IMPORTS Rope, Xl, XlDispatch, XlEndianPrivate, XlExtensions, XlKeyButPrivate, XlPrivate
        EXPORTS XlInputExtension, XlInputExtensionPrivate
        SHARES Xl ~
    BEGIN OPEN XlInputExtension, XlInputExtensionPrivate; 

    extensionKey: ATOM ~ $XInputExtension;

    deviceKeyPressKey: PUBLIC REF Ź $deviceKeyPress;  
    deviceKeyReleaseKey: PUBLIC REF Ź $deviceKeyRelease;  
    deviceButtonPressKey: PUBLIC REF Ź $deviceButtonPress;  
    deviceButtonReleaseKey: PUBLIC REF Ź $deviceButtonRelease;  
    deviceMotionNotifyKey: PUBLIC REF Ź $deviceMotionNotify;  
    deviceFocusInKey: PUBLIC REF Ź $deviceFocusIn;  
    deviceFocusOutKey: PUBLIC REF Ź $deviceFocusOut;  
    proximityInKey: PUBLIC REF Ź $proximityIn;  
    proximityOutKey: PUBLIC REF Ź $proximityOut;  
    deviceStateNotifyKey: PUBLIC REF Ź $deviceStateNotify;  
    deviceMappingNotifyKey: PUBLIC REF Ź $deviceMapping;  
    changeDeviceNotifyKey: PUBLIC REF Ź $changeDeviceNotify;  

    extPropKey: REF ATOM ~ NEW[ATOM Ź extensionKey]; 

    lastConnectionData: REF ConnectionData Ź NEW[ConnectionData];

    GetConnectionData: PUBLIC PROC [c: Xl.Connection] RETURNS [cd: REF ConnectionData] = {
        cd Ź lastConnectionData;
        IF cd.c=c THEN RETURN[cd];
        cd Ź lastConnectionData Ź NARROW[Xl.GetConnectionPropAndInit[c, extPropKey, InitExtension]];
        };

    InitExtension: Xl.InitializeProcType = {--init availability of extension for this connection
        cd: REF ConnectionData ~ NEW[ConnectionData];
        cd.ex Ź XlExtensions.StartExtension[c, extensionKey];
        IF cd.ex#NIL THEN cd.ex.state Ź NEW[ExtensionStateRec];
        RETURN [cd]
        };

    GetExtensionVersion: PUBLIC PROC [c: Xl.Connection, name: Rope.ROPE] RETURNS [present: BOOL Ź FALSE, majorVersion: INT Ź 0, 
    minorVersion: INT Ź 0] = {
        reply: XlPrivate.Reply;
        n: INT ~ Rope.Length[name];
        cd: REF ConnectionData ~ GetConnectionData[c];
        IF n>c.info.maxRequestLengthBytes THEN ERROR;
        IF cd.ex#NIL THEN {
            DoIt: PROC [c: Xl.Connection] = {
                XlPrivate.BInit[c, cd.ex.majorOpcode, opGetExtensionVersion, 2+(n+3)/4];
                XlPrivate.BPut16[c, n]; -- length of name
                XlPrivate.BSkip[c, 2]; 
                XlPrivate.BPutPaddedRope[c, name];
                reply Ź XlPrivate.FinishWithReply[c];
                };
            XlPrivate.DoWithLocks[c, DoIt, NIL];
            XlPrivate.CheckReply[reply];
            XlPrivate.Skip[reply, 7];
            majorVersion Ź XlPrivate.Read16[reply];
            minorVersion Ź XlPrivate.Read16[reply];
            present Ź XlPrivate.Read8[reply]#0;
            XlPrivate.DisposeReply[c, reply];
            };
        };
        <<>>
    ListInputDevices: PUBLIC PROC [c: Xl.Connection] RETURNS [diList: LIST OF DeviceInfo Ź NIL] = {
        diRest: LIST OF DeviceInfo Ź NIL;
        infoRest: LIST OF REF InputInfo Ź NIL; 
        reply: XlPrivate.Reply;
        cd: REF ConnectionData ~ GetConnectionData[c];
        IF cd.ex#NIL THEN {
            DoIt: PROC [c: Xl.Connection] = {
                XlPrivate.BInit[c, cd.ex.majorOpcode, opListInputDevices, 1];
                reply Ź XlPrivate.FinishWithReply[c];
                };
            replyLength: CARD32;
            numberOfDevices: BYTE;
            XlPrivate.DoWithLocks[c, DoIt, NIL];
            XlPrivate.CheckReply[reply];
            XlPrivate.Skip[reply, 3];
            replyLength Ź XlPrivate.Read32[reply];
            numberOfDevices Ź XlPrivate.Read8[reply];
            XlPrivate.Skip[reply, 23];
            infoRest Ź NIL;
            FOR nd: INT IN [0..numberOfDevices) DO
                di: DeviceInfo;
                di.type Ź [XlPrivate.ERead32[reply]];
                di.id Ź XlPrivate.ERead8[reply] MOD 128;
                di.numClasses Ź XlPrivate.ERead8[reply];
                SELECT XlPrivate.ERead8[reply] FROM
                    0 => di.use Ź isXPointer;
                    1 => di.use Ź isXKeyboard;
                    ENDCASE => di.use Ź isExtensionDevice;
                XlPrivate.Skip[reply, 1];
                FOR nc: INT IN [0..di.numClasses) DO
                    inf: REF InputInfo;
                    infoRest: LIST OF REF InputInfo;
                    classId: BYTE Ź XlPrivate.ERead8[reply];
                    length: BYTE Ź XlPrivate.ERead8[reply];
                    SELECT classId FROM
                        0 => {
                            i: REF keyInfo InputInfo Ź NEW[keyInfo InputInfo]; 
                            i.min Ź XlPrivate.ERead8[reply];
                            i.max Ź XlPrivate.ERead8[reply];
                            i.number Ź XlPrivate.ERead16[reply];
                            XlPrivate.Skip[reply, 2];
                            inf Ź i;
                            };
                        1 => {
                            i: REF buttonInfo InputInfo Ź NEW[buttonInfo InputInfo]; 
                            i.number Ź XlPrivate.ERead16[reply];
                            inf Ź i;
                            };
                        2 => {
                            numAxes: BYTE Ź XlPrivate.ERead8[reply];
                            mode: BYTE Ź XlPrivate.ERead8[reply];
                            i: REF valuatorInfo InputInfo Ź NEW[valuatorInfo InputInfo[numAxes]];
                            i.supportsRelative Ź ((mode) MOD 2) = 1;
                            i.supportsAbsolute Ź ((mode / 2) MOD 2) = 1;
                            i.motionBufferSize Ź XlPrivate.ERead32[reply];
                            FOR n: INT IN [0..numAxes) DO
                                i.axisInfo[n].resolution Ź XlPrivate.ERead32[reply];
                                i.axisInfo[n].min Ź XlPrivate.ERead32[reply];
                                i.axisInfo[n].max Ź XlPrivate.ERead32[reply];
                                ENDLOOP;
                            inf Ź i;
                            };
                        ENDCASE => {};
                    inf.class Ź VAL[classId];
                <<--append this class (info)>>
                    IF di.info=NIL 
                        THEN di.info Ź infoRest Ź LIST[inf] 
                        ELSE {infoRest.rest Ź LIST[inf]; infoRest Ź infoRest.rest}
                    ENDLOOP;
                di.name Ź XlPrivate.EReadRope[reply];
            <<--append this device>>
                IF diRest=NIL 
                    THEN diList Ź diRest Ź LIST[di] 
                    ELSE {diRest.rest Ź LIST[di]; diRest Ź diRest.rest}
                ENDLOOP;
            XlPrivate.DisposeReply[c, reply];
            };
        };

    OpenDevice: PUBLIC PROC [c: Xl.Connection, id: DeviceId] RETURNS [od: REF OpenDeviceRec] = {
        reply: XlPrivate.Reply;
        cd: REF ConnectionData ~ GetConnectionData[c];
        replyLength: CARD32;
        numberOfClasses: BYTE;
        DoIt: PROC [c: Xl.Connection] = {
            XlPrivate.BInit[c, cd.ex.majorOpcode, opOpenDevice, 2];
            XlPrivate.BPut8[c, id];
            XlPrivate.BSkip[c, 3];
            reply Ź XlPrivate.FinishWithReply[c];
            };
        IF cd.ex=NIL THEN ERROR;
        XlPrivate.DoWithLocks[c, DoIt, NIL];
        XlPrivate.CheckReply[reply];
        XlPrivate.Skip[reply, 3];
        replyLength Ź XlPrivate.Read32[reply];
        numberOfClasses Ź XlPrivate.Read8[reply];
        XlPrivate.Skip[reply, 23];
        od Ź NEW[OpenDeviceRec[numberOfClasses]];
        od.id Ź id;
        FOR i: INT IN [0..numberOfClasses) DO
            od[i].inputClass Ź VAL[XlPrivate.ERead8[reply]];
            od[i].eventTypeBase Ź XlPrivate.ERead8[reply];
            ENDLOOP;
        XlPrivate.DisposeReply[c, reply];
        };
        <<>>
    CloseDevice: PUBLIC PROC [c: Xl.Connection, deviceId: DeviceId, details: Xl.Details Ź NIL] = {
        action: PROC [c: Xl.Connection] = {
            XlPrivate.BInit[c, cd.ex.majorOpcode, opCloseDevice, 2];
            XlPrivate.BPut8[c, deviceId];
            XlPrivate.BSkip[c, 3];
            XlPrivate.FinishWithDetails[c, details];
            };
        cd: REF ConnectionData ~ GetConnectionData[c];
        IF cd.ex#NIL THEN XlPrivate.DoWithLocks[c, action, details];
        };
        <<>>
    SetDeviceMode: PUBLIC PROC [c: Xl.Connection, deviceId: DeviceId, relativeMode: BOOL] RETURNS [status: DeviceStatus] = {
        reply: XlPrivate.Reply;
        action: PROC [c: Xl.Connection] = {
            XlPrivate.BInit[c, cd.ex.majorOpcode, opSetDeviceMode, 2];
            XlPrivate.BPut8[c, deviceId];
            XlPrivate.BPut8[c, ORD[relativeMode]];
            XlPrivate.BSkip[c, 2];
            reply Ź XlPrivate.FinishWithReply[c];
            };
        cd: REF ConnectionData ~ GetConnectionData[c];
        IF cd.ex=NIL THEN ERROR;
        XlPrivate.DoWithLocks[c, action, NIL];
        XlPrivate.Skip[reply, 7];
        SELECT XlPrivate.Read8[reply] FROM
            0 => status Ź success;
            1 => status Ź alreadyGrabbed;
            ENDCASE => status Ź deviceBusy;
        XlPrivate.DisposeReply[c, reply];
        };
        <<>>
    EventClassesLength: PUBLIC PROC [interest: LIST OF EventClass] RETURNS [count: INT Ź 0] = {
        limit: INT = 200;
        FOR l: LIST OF EventClass Ź interest, l.rest WHILE l#NIL DO
            IF count>=limit THEN ERROR;
            count Ź count+1; 
            ENDLOOP;
        };

    PutEventClasses: PUBLIC PROC [c: Xl.Connection, interest: LIST OF EventClass, count: INT] = {
        FOR i: INT IN [0..count) DO
            XlPrivate.BPut32[c, LOOPHOLE[interest.first, CARD32]];
            IF interest.rest#NIL THEN interest Ź interest.rest
            ENDLOOP;
        };

    SelectExtensionEvents: PUBLIC PROC [c: Xl.Connection, window: Xl.Window, interest: LIST OF EventClass, details: Xl.Details Ź NIL] = 
    {
        count: INT Ź EventClassesLength[interest];
        action: PROC [c: Xl.Connection] = {
            XlPrivate.BInit[c, cd.ex.majorOpcode, opSelectExtensionEvent, 3+count];
            XlPrivate.BPutDrawable[c, window];
            XlPrivate.BPut16[c, count];
            XlPrivate.BSkip[c, 2];
            PutEventClasses[c, interest, count];
            XlPrivate.FinishWithDetails[c, details];
            };
        cd: REF ConnectionData ~ GetConnectionData[c];
        IF cd.ex#NIL THEN XlPrivate.DoWithLocks[c, action, details];
        };

    MakeEventClass: PUBLIC PROC [od: REF READONLY OpenDeviceRec, request: RequestableEvent] RETURNS [EventClass Ź 0] = {
        id: CARD32 Ź od.id;
        x: CARD32 Ź (id MOD 128) * 256;
        IF request IN [devicePointerMotionHint..noExtensionEvent] 
            THEN {x Ź x + ORD[request]; RETURN [LOOPHOLE[x]]}
            ELSE {
                class: InputClass; offset: CARD32 Ź 0;
                SELECT request FROM
                    deviceKeyPress => {class Ź keyClass; offset Ź 0}; 
                    deviceKeyRelease => {class Ź keyClass; offset Ź 1}; 
                    deviceButtonPress => {class Ź buttonClass; offset Ź 0}; 
                    deviceButtonRelease => {class Ź buttonClass; offset Ź 1}; 
                    deviceMotionNotify => {class Ź valuatorClass; offset Ź 0}; 
                    deviceFocusIn => {class Ź focusClass; offset Ź 0}; 
                    deviceFocusOut => {class Ź focusClass; offset Ź 1}; 
                    proximityIn => {class Ź proximityClass; offset Ź 0}; 
                    proximityOut => {class Ź proximityClass; offset Ź 1}; 
                    deviceStateNotify => {class Ź otherClass; offset Ź 0}; 
                    deviceMappingNotify => {class Ź otherClass; offset Ź 1}; 
                    changeDeviceNotify => {class Ź otherClass; offset Ź 2}; 
                    ENDCASE => ERROR; --class is not known (by this version of the extension)
                FOR i: INT IN [0..od.numClasses) DO
                    IF od.classes[i].inputClass=class THEN {
                        x Ź x + od.classes[i].eventTypeBase + offset;
                        RETURN [LOOPHOLE[x]]
                        };
                    ENDLOOP;
                };
        ERROR; --class is not implemented (by this server instance)
        };

    GetSelectedExtensionEvents: PUBLIC PROC [c: Xl.Connection, window: Xl.Window] RETURNS [thisClient: EventClasses Ź NIL, allClients: 
    EventClasses Ź NIL] = {
        reply: XlPrivate.Reply;
        thisCnt, allCnt: NAT;
        action: PROC [c: Xl.Connection] = {
            XlPrivate.BInit[c, cd.ex.majorOpcode, opGetSelectedExtensionEvents, 2];
            XlPrivate.BPutDrawable[c, window];
            reply Ź XlPrivate.FinishWithReply[c];
            };
        cd: REF ConnectionData ~ GetConnectionData[c];
        IF cd.ex#NIL THEN {
            XlPrivate.DoWithLocks[c, action, NIL];
            XlPrivate.CheckReply[reply];
            XlPrivate.Skip[reply, 7];
            thisCnt Ź XlPrivate.Read16[reply];
            allCnt Ź XlPrivate.Read16[reply];
            thisClient Ź NEW[Xl.Card32Sequence[thisCnt]];
            allClients Ź NEW[Xl.Card32Sequence[allCnt]];
            XlPrivate.Skip[reply, 20];
            FOR i: NAT IN [0..thisCnt) DO
                thisClient[i] Ź XlPrivate.ERead32[reply];
                ENDLOOP;
            FOR i: NAT IN [0..allCnt) DO
                allClients[i] Ź XlPrivate.ERead32[reply];
                ENDLOOP;
            XlPrivate.DisposeReply[c, reply];
            };
        };

    ChangeDeviceDontPropagateList: PUBLIC PROC [c: Xl.Connection, window: Xl.Window, eventClass: LIST OF EventClass, mode: 
    ListModifierMode, details: Xl.Details Ź NIL] = {
        count: INT Ź EventClassesLength[eventClass];
        cd: REF ConnectionData ~ GetConnectionData[c];
        action: PROC [c: Xl.Connection] = {
            XlPrivate.BInit[c, cd.ex.majorOpcode, opChangeDeviceDontPropagateList, 3+count];
            XlPrivate.BPutDrawable[c, window];
            XlPrivate.BPut16[c, count];
            XlPrivate.BPut8[c, ORD[mode]];
            XlPrivate.BPut8[c, 0];
            PutEventClasses[c, eventClass, count];
            XlPrivate.FinishWithDetails[c, details];
            };
        IF cd.ex#NIL THEN XlPrivate.DoWithLocks[c, action, details];
        };

    GetDeviceDontPropagateList: PUBLIC PROC [c: Xl.Connection, window: Xl.Window] RETURNS [dontPropagateList: EventClasses Ź NIL] = {
        reply: XlPrivate.Reply;
        cnt: NAT;
        action: PROC [c: Xl.Connection] = {
            XlPrivate.BInit[c, cd.ex.majorOpcode, opGetDeviceDontPropagateList, 2];
            XlPrivate.BPutDrawable[c, window];
            reply Ź XlPrivate.FinishWithReply[c];
            };
        cd: REF ConnectionData ~ GetConnectionData[c];
        IF cd.ex#NIL THEN {
            XlPrivate.DoWithLocks[c, action, NIL];
            XlPrivate.CheckReply[reply];
            XlPrivate.Skip[reply, 7];
            cnt Ź XlPrivate.Read16[reply];
            dontPropagateList Ź NEW[Xl.Card32Sequence[cnt]];
            XlPrivate.Skip[reply, 22];
            FOR i: NAT IN [0..cnt) DO
                dontPropagateList[i] Ź XlPrivate.ERead32[reply];
                ENDLOOP;
            XlPrivate.DisposeReply[c, reply];
            };
        };

    DeviceTimeCoords: PUBLIC TYPE = XlPrivate.ReplyRec;
        <<Data structure is not monitored and should be queried by a single process>>

    GetDeviceMotionEvents: PUBLIC PROC [c: Xl.Connection, deviceId: DeviceId, start, stop: Xl.TimeStamp] RETURNS [REF DeviceTimeCoords 
    Ź NIL] = {
        reply: XlPrivate.Reply Ź NIL;
        action: PROC [c: Xl.Connection] = {
            XlPrivate.BInit[c, cd.ex.majorOpcode, opGetDeviceDontPropagateList, 2];
            XlPrivate.BPut32[c, start];
            XlPrivate.BPut32[c, stop];
            XlPrivate.BPut8[c, deviceId];
            XlPrivate.BSkip[c, 3];
            reply Ź XlPrivate.FinishWithReply[c];
            };
        cd: REF ConnectionData ~ GetConnectionData[c];
        IF cd.ex#NIL THEN {
            XlPrivate.DoWithLocks[c, action, NIL];
            XlPrivate.CheckReply[reply];
            RETURN [reply]
            };
        };

        IsAbsolute: PUBLIC PROC [dtc: REF DeviceTimeCoords] RETURNS [BOOL] = {
            RETURN [XlPrivate.Get8[dtc, 13]=0];
            };
        AxisCount: PUBLIC PROC [dtc: REF DeviceTimeCoords] RETURNS [NAT] = {
            IF dtc=NIL THEN RETURN [0];
            RETURN [XlPrivate.Get8[dtc, 12]];
            };
        NumberOfEvents: PUBLIC PROC [dtc: REF DeviceTimeCoords] RETURNS [NAT] = {
            IF dtc=NIL THEN RETURN [0];
            RETURN [XlPrivate.Get32[dtc, 8]];
            };
        TimeOfEvent: PUBLIC PROC [dtc: REF DeviceTimeCoords, eventNum: NAT] RETURNS [time: Xl.TimeStamp] = {
            vpe: BYTE ~ XlPrivate.Get8[dtc, 12];
            XlPrivate.SetPos[dtc, 32+eventNum*(4*vpe+4)];
            time Ź [XlPrivate.ERead32[dtc]]
            };
        ValuatorOfEvent: PUBLIC PROC [dtc: REF DeviceTimeCoords, eventNum: NAT, valuatorNum: NAT] RETURNS [CARD32] = {
            vpe: BYTE ~ XlPrivate.Get8[dtc, 12];
            XlPrivate.SetPos[dtc, 36+eventNum*(4*vpe+4)+valuatorNum*4];
            RETURN [ XlPrivate.ERead32[dtc] ]
            };

    ChangePointerDevice: PUBLIC PROC [c: Xl.Connection, deviceId: DeviceId, xaxis, yaxis: BYTE] RETURNS [status: ChangeReply] = {
        reply: XlPrivate.Reply Ź NIL;
        action: PROC [c: Xl.Connection] = {
            XlPrivate.BInit[c, cd.ex.majorOpcode, opChangePointerDevice, 2];
            XlPrivate.BPut8[c, xaxis];
            XlPrivate.BPut8[c, yaxis];
            XlPrivate.BPut8[c, deviceId];
            XlPrivate.BSkip[c, 1];
            reply Ź XlPrivate.FinishWithReply[c];
            };
        cd: REF ConnectionData ~ GetConnectionData[c];
        IF cd.ex=NIL THEN ERROR;
        XlPrivate.DoWithLocks[c, action, NIL];
        XlPrivate.Skip[reply, 7];
        SELECT XlPrivate.Read8[reply] FROM
            0 => status Ź success;
            1 => status Ź alreadyGrabbed;
            ENDCASE => status Ź deviceFrozen;
        XlPrivate.DisposeReply[c, reply];
        };

    GrabDevice: PUBLIC PROC [c: Xl.Connection, deviceId: DeviceId, grabWindow: Xl.Window, ownerEvents: BOOL, eventList: LIST OF 
    EventClass, thisDeviceMode: Xl.Synchronicity, otherDeviceMode: Xl.Synchronicity, time: Xl.TimeStamp] RETURNS [Xl.GrabStatus] = {
        reply: XlPrivate.Reply Ź NIL;
        got: BYTE;
        count: INT Ź EventClassesLength[eventList];
        action: PROC [c: Xl.Connection] = {
            XlPrivate.BInit[c, cd.ex.majorOpcode, opGrabDevice, 5+count];
            XlPrivate.BPutDrawable[c, grabWindow];
            XlPrivate.BPutTime[c, time];
            XlPrivate.BPut16[c, count];
            XlPrivate.BPut8[c, ORD[thisDeviceMode]];
            XlPrivate.BPut8[c, ORD[otherDeviceMode]];
            XlPrivate.BPut8[c, ORD[ownerEvents]];
            XlPrivate.BPut8[c, deviceId];
            XlPrivate.BSkip[c, 2];
            PutEventClasses[c, eventList, count];
            reply Ź XlPrivate.FinishWithReply[c];
            };
        cd: REF ConnectionData ~ GetConnectionData[c];
        IF cd.ex=NIL THEN ERROR;
        XlPrivate.DoWithLocks[c, action, NIL];
        XlPrivate.CheckReply[reply];
        got Ź XlPrivate.Read8[reply];
        IF got>ORD[Xl.GrabStatus.LAST] THEN ERROR;
        XlPrivate.DisposeReply[c, reply];
        RETURN [VAL[got]]
        };

    UngrabDevice: PUBLIC PROC [c: Xl.Connection, deviceId: DeviceId, time: Xl.TimeStamp Ź Xl.currentTime, details: Xl.Details Ź NIL] = {
        cd: REF ConnectionData ~ GetConnectionData[c];
        action: PROC [c: Xl.Connection] = {
            XlPrivate.BInit[c, cd.ex.majorOpcode, opUngrabDevice, 3];
            XlPrivate.BPutTime[c, time];
            XlPrivate.BPut8[c, deviceId];
            XlPrivate.BSkip[c, 3];
            XlPrivate.FinishWithDetails[c, details];
            };
        IF cd.ex#NIL THEN XlPrivate.DoWithLocks[c, action, details];
        };

    GrabDeviceButton: PUBLIC PROC [c: Xl.Connection, deviceId: DeviceId, grabWindow: Xl.Window, modifiers: Xl.SetOfKeyButMask, 
    modifierDevice: DeviceIdBase, button: BYTE Ź 0, ownerEvents: BOOL, eventList: LIST OF EventClass, thisDeviceMode: 
    Xl.Synchronicity, otherDeviceMode: Xl.Synchronicity, details: Xl.Details] = {
        count: INT Ź EventClassesLength[eventList];
        ownerEventsInternal: BYTE Ź ORD[ownerEvents];
        action: PROC [c: Xl.Connection] = {
            XlPrivate.BInit[c, cd.ex.majorOpcode, opGrabDeviceButton, 5+count];
            XlPrivate.BPutDrawable[c, grabWindow];
            XlPrivate.BPut8[c, deviceId];
            XlPrivate.BPut8[c, modifierDevice];
            XlPrivate.BPut16[c, count];
            XlPrivate.BPut16[c, XlKeyButPrivate.SetToWire[modifiers]];
            XlPrivate.BPut8[c, ORD[thisDeviceMode]];
            XlPrivate.BPut8[c, ORD[otherDeviceMode]];
            XlPrivate.BPut8[c, button];
            XlPrivate.BPut8[c, ownerEventsInternal]; --?
            XlPrivate.BSkip[c, 2];
            PutEventClasses[c, eventList, count];
            XlPrivate.FinishWithDetails[c, details];
            };
        cd: REF ConnectionData ~ GetConnectionData[c];
        IF cd.ex=NIL THEN ERROR;
        XlPrivate.DoWithLocks[c, action, details];
        };

    UngrabDeviceButton: PUBLIC PROC [c: Xl.Connection, deviceId: DeviceId, grabWindow: Xl.Window, modifiers: Xl.SetOfKeyButMask, 
    modifierDevice: DeviceIdBase, button: BYTE, details: Xl.Details] = {
        cd: REF ConnectionData ~ GetConnectionData[c];
        action: PROC [c: Xl.Connection] = {
            XlPrivate.BInit[c, cd.ex.majorOpcode, opUngrabDeviceButton, 4];
            XlPrivate.BPutDrawable[c, grabWindow];
            XlPrivate.BPut16[c, XlKeyButPrivate.SetToWire[modifiers]];
            XlPrivate.BPut8[c, modifierDevice];
            XlPrivate.BPut8[c, button];
            XlPrivate.BPut8[c, deviceId];
            XlPrivate.BSkip[c, 3];
            XlPrivate.FinishWithDetails[c, details];
            };
        IF cd.ex#NIL THEN XlPrivate.DoWithLocks[c, action, details];
        };

    AllowDeviceEvents: PUBLIC PROC [c: Xl.Connection, deviceId: DeviceId, time: Xl.TimeStamp Ź Xl.currentTime, mode: 
    AllowDeviceEventsMode, details: Xl.Details Ź NIL] = {
        cd: REF ConnectionData ~ GetConnectionData[c];
        action: PROC [c: Xl.Connection] = {
            XlPrivate.BInit[c, cd.ex.majorOpcode, opAllowDeviceEvents, 2];
            XlPrivate.BPutTime[c, time];
            XlPrivate.BPut8[c, ORD[mode]];
            XlPrivate.BPut8[c, deviceId];
            XlPrivate.BSkip[c, 2];
            XlPrivate.FinishWithDetails[c, details];
            };
        IF cd.ex#NIL THEN XlPrivate.DoWithLocks[c, action, details];
        };

    IntLength: PROC [list: LIST OF INT] RETURNS [cnt: BYTE Ź 0] = {
        FOR l: LIST OF INT Ź list, l.rest WHILE l#NIL DO
            IF cnt>=255 THEN ERROR;
            cnt Ź cnt+1;
            ENDLOOP
        };

    SetDeviceValuators: PUBLIC PROC [c: Xl.Connection, deviceId: DeviceId, first: INT, values: LIST OF INT] RETURNS [status: 
    ValuatorStatus] = {
        reply: XlPrivate.Reply;
        cnt: BYTE Ź IntLength[values];
        cd: REF ConnectionData ~ GetConnectionData[c];
        action: PROC [c: Xl.Connection] = {
            XlPrivate.BInit[c, cd.ex.majorOpcode, opSetDeviceValuators, 2+cnt];
            XlPrivate.BPut8[c, deviceId];
            XlPrivate.BPut8[c, first];
            XlPrivate.BPut8[c, cnt];
            XlPrivate.BSkip[c, 1];
            FOR i: INT IN [0..cnt) DO
                XlPrivate.BPut32[c, LOOPHOLE[values.first, CARD32]];
                IF values.rest#NIL THEN values Ź values.rest;
                ENDLOOP;
            reply Ź XlPrivate.FinishWithReply[c];
            };
        IF cd.ex=NIL THEN ERROR;
        IF first<0 OR first+cnt>255 THEN ERROR;
        XlPrivate.DoWithLocks[c, action, NIL];
        XlPrivate.Skip[reply, 7];
        SELECT XlPrivate.Read8[reply] FROM
            0 => status Ź success;
            1 => status Ź alreadyGrabbed;
            ENDCASE => ERROR;
        XlPrivate.DisposeReply[c, reply];
        };

    GetDeviceFocus: PUBLIC PROC [c: Xl.Connection, deviceId: DeviceId] RETURNS [dfr: DeviceFocusRec] = {
        reply: XlPrivate.Reply; x: BYTE;
        cd: REF ConnectionData ~ GetConnectionData[c];
        action: PROC [c: Xl.Connection] = {
            XlPrivate.BInit[c, cd.ex.majorOpcode, opGetDeviceFocus, 2];
            XlPrivate.BPut8[c, deviceId];
            XlPrivate.BSkip[c, 3];
            reply Ź XlPrivate.FinishWithReply[c];
            };
        IF cd.ex=NIL THEN ERROR;
        XlPrivate.DoWithLocks[c, action, NIL];
        XlPrivate.Skip[reply, 7];
        dfr.window Ź [[XlPrivate.ERead32[reply]]];
        dfr.time Ź [XlPrivate.ERead32[reply]];
        x Ź XlPrivate.Read8[reply];
        IF x>ORD[DeviceFocusReversion.LAST] THEN ERROR;
        dfr.revertTo Ź VAL[x];
        XlPrivate.DisposeReply[c, reply];
        };

    SetDeviceFocus: PUBLIC PROC [c: Xl.Connection, deviceId: DeviceId, dfr: DeviceFocusRec Ź [], details: Xl.Details] = {
        cd: REF ConnectionData ~ GetConnectionData[c];
        action: PROC [c: Xl.Connection] = {
            XlPrivate.BInit[c, cd.ex.majorOpcode, opSetDeviceFocus, 4];
            XlPrivate.BPutDrawable[c, dfr.window];
            XlPrivate.BPutTime[c, dfr.time];
            XlPrivate.BPut8[c, ORD[dfr.revertTo]];
            XlPrivate.BPut8[c, deviceId];
            XlPrivate.BSkip[c, 2];
            XlPrivate.FinishWithDetails[c, details];
            };
        IF cd.ex=NIL THEN ERROR;
        XlPrivate.DoWithLocks[c, action, details];
        };

    QueryDeviceState: PUBLIC PROC [c: Xl.Connection, deviceId: DeviceId] RETURNS [s: InputStates] = {
        cd: REF ConnectionData ~ GetConnectionData[c];
        reply: XlPrivate.Reply; 
        action: PROC [c: Xl.Connection] ~ {
            XlPrivate.BInit[c, cd.ex.majorOpcode, opQueryDeviceState, 2];
            XlPrivate.BPut8[c, deviceId];
            XlPrivate.BSkip[c, 3];
            reply Ź XlPrivate.FinishWithReply[c];
            };
        lastClass: LIST OF REF InputState Ź NIL;
        IF cd.ex=NIL THEN ERROR;
        XlPrivate.DoWithLocks[c, action, NIL];
        XlPrivate.CheckReply[reply];
        XlPrivate.Skip[reply, 7];
        s.numberOfClasses Ź XlPrivate.Read8[reply];
        XlPrivate.Skip[reply, 23];
        FOR i: BYTE IN [0..s.numberOfClasses) DO
            this: REF InputState Ź NIL;
            x: BYTE Ź XlPrivate.ERead8[reply];
            length: BYTE Ź XlPrivate.ERead8[reply];
            number: BYTE Ź XlPrivate.ERead8[reply];
            mode: BYTE Ź XlPrivate.ERead8[reply];
            SELECT x FROM
                ORD[InputClass[keyClass]] => {
                    keyThis: REF keyClass InputState Ź NEW[keyClass InputState];
                    FOR i: INT IN [0..32) DO
                        keyThis.keys[i] Ź XlPrivate.ERead8[reply];
                        ENDLOOP;
                    this Ź keyThis;
                    };
                ORD[InputClass[buttonClass]] => {
                    butThis: REF buttonClass InputState Ź NEW[buttonClass InputState];
                    FOR i: INT IN [0..32) DO
                        butThis.buttons[i] Ź XlPrivate.ERead8[reply];
                        ENDLOOP;
                    this Ź butThis;
                    };
                ORD[InputClass[valuatorClass]] => {
                    valThis: REF valuatorClass InputState Ź NEW[valuatorClass InputState];
                    valThis.relativeMode Ź ((mode) MOD 2)=0;
                    valThis.inProximity Ź ((mode / 2) MOD 2)=0;
                    valThis.valuators Ź NEW[Int32Sequence[number]];
                    FOR i: BYTE IN [0..number) DO
                        valThis.valuators[i] Ź XlPrivate.ERead32[reply];
                        ENDLOOP;
                    this Ź valThis;
                    };
                ENDCASE => ERROR;
            this.number Ź number;
            IF lastClass=NIL 
                THEN {lastClass Ź s.states Ź LIST[this]}
                ELSE {lastClass.rest Ź LIST[this]; lastClass Ź lastClass.rest}
            ENDLOOP;
        XlPrivate.DisposeReply[c, reply];
        };

    GetDeviceButtonMapping: PUBLIC PROC [c: Xl.Connection, deviceId: DeviceId] RETURNS [Xl.PointerMapping] = {
        <<--Should we do some caching ?>>
        reply: XlPrivate.Reply;
        action: PROC [c: Xl.Connection] ~ {
            XlPrivate.BInit[c, cd.ex.majorOpcode, opGetDeviceButtonMapping, 2];
            XlPrivate.BPut8[c, deviceId];
            XlPrivate.BSkip[c, 3];
            reply Ź XlPrivate.FinishWithReply[c];
            };
        n: BYTE;
        cd: REF ConnectionData ~ GetConnectionData[c];
        pm: REF Xl.PointerMappingSequence;
        IF cd.ex=NIL THEN ERROR;
        XlPrivate.DoWithLocks[c, action, NIL];
        XlPrivate.CheckReply[reply];
        XlPrivate.Skip[reply, 7];
        n Ź XlPrivate.Read8[reply];
        XlPrivate.Skip[reply, 23];
        pm Ź NEW[Xl.PointerMappingSequence[n+1]];
        pm[0] Ź 0;
        FOR i: BYTE IN [1..pm.leng) DO
            pm[i] Ź XlPrivate.ERead8[reply];
            ENDLOOP;
        XlPrivate.DisposeReply[c, reply];
        RETURN [pm];
        };
<<Events>>

    ExtensionStateRec: TYPE = RECORD [
        <<Accumulated state while accepting multi packet events>>
        lastMultiEvent: REF Xl.EventRep.extension Ź NIL, --assigned if it could have a continuation 
        lastMultiExt: REF ExtEventRep Ź NIL,
        valuators: REF Int32Sequence Ź NIL,
        keys: REF PACKED ARRAY [0..31] OF BYTE Ź NIL,
        buttons: REF PACKED ARRAY [0..31] OF BYTE Ź NIL,
        lastSequenceNo: Xl.SequenceNo
        ];

    FinishMulti: PROC [state: REF ExtensionStateRec] = {
        XlDispatch.FindAndDispatch[state.lastMultiEvent];
        state.lastMultiEvent Ź NIL;
        state.lastMultiExt Ź NIL;
        state.buttons Ź NIL;
        state.keys Ź NIL;
        state.valuators Ź NIL;
        };

    ProcessEvents: XlExtensions.ProcessExtensionEventProc = {--decodes arriving event
        <<This extension supports chunks of multiple events following immediately...>>
            <<We wait until all connected events are collected and the report the event to our client; if the events do not appear in the right 
            order we will not crash (it could be client generated), but we won't report exactly what has been seen either.>>
        eventOffset: EventOffset ~ VAL[xEvent.originalCodeByte MOD 128 - self.firstEvent];
        state: REF ExtensionStateRec ~ NARROW[self.state];
        DeviceBaseEvent: PROC [xEvent: REF Xl.EventRep.extension, state: REF ExtensionStateRec] RETURNS [e: REF deviceBase ExtEventRep Ź 
        NEW[deviceBase ExtEventRep]] = {
            state.lastMultiEvent Ź xEvent;
            state.lastMultiExt Ź e;
            e.seq Ź state.lastSequenceNo Ź XlEndianPrivate.InlineExtensionGet16[xEvent, 2];
            e.time Ź [XlEndianPrivate.InlineExtensionGet32[xEvent, 4]];
            e.rootWindow Ź DecodeWindow[xEvent, 8];
            xEvent.dispatchDrawable Ź e.eventWindow Ź DecodeWindow[xEvent, 12];
            e.childWindow Ź DecodeWindow[xEvent, 16];
            e.rootPos.x Ź DecodeIntFrom16[xEvent, 20];
            e.rootPos.y Ź DecodeIntFrom16[xEvent, 22];
            e.eventPos.x Ź DecodeIntFrom16[xEvent, 24];
            e.eventPos.y Ź DecodeIntFrom16[xEvent, 26];
            e.state Ź  XlKeyButPrivate.SetFromWire[XlEndianPrivate.InlineExtensionGet16[xEvent, 28]];
            e.sameScreen Ź  XlEndianPrivate.InlineExtensionGet8[xEvent, 30]#0;
            e.deviceId Ź  XlEndianPrivate.InlineExtensionGet8[xEvent, 31] MOD 128;
            xEvent.decoded Ź e;
            };
        DeviceFocusEvent: PROC [xEvent: REF Xl.EventRep.extension, state: REF ExtensionStateRec, in: BOOL] = {
            e: REF deviceFocus ExtEventRep ~ NEW[deviceFocus ExtEventRep];
            detail: BYTE Ź XlEndianPrivate.InlineExtensionGet8[xEvent, 1];
            mode: BYTE Ź XlEndianPrivate.InlineExtensionGet8[xEvent, 12];
            state.lastMultiEvent Ź NIL;
            state.lastMultiExt Ź NIL;
            IF detail>ORD[Xl.FocusDetail.LAST] OR mode>ORD[Xl.GrabMode.LAST] THEN RETURN;
            e.detail Ź VAL[detail];
            e.mode Ź VAL[mode];
            e.seq Ź XlEndianPrivate.InlineExtensionGet16[xEvent, 2];
            e.time Ź [XlEndianPrivate.InlineExtensionGet32[xEvent, 4]];
            e.eventWindow Ź DecodeWindow[xEvent, 8];
            e.deviceId Ź XlEndianPrivate.InlineExtensionGet8[xEvent, 13] MOD 128;
            IF in 
                THEN {e.eventOffset Ź deviceFocusIn; xEvent.match Ź deviceFocusInKey} 
                ELSE {e.eventOffset Ź deviceFocusOut; xEvent.match Ź deviceFocusOutKey};
            xEvent.decoded Ź e;
            XlDispatch.FindAndDispatch[xEvent];
            };
        xEvent.extension Ź extensionKey;
        SELECT eventOffset FROM
            deviceValuator => {
                DeviceValuator: PROC [xEvent: REF Xl.EventRep.extension, state: REF ExtensionStateRec] = {
                    seq: Xl.SequenceNo Ź XlEndianPrivate.InlineExtensionGet16[xEvent, 2];
                    <<Don't test sequence numbers for the benefit of client generated event sequences.>>
                    <<IF seq#state.lastSequenceNo THEN <<OOPS>> RETURN; --wrong formed events could have been sent by an other client.>>
                    valuators: REF Int32Sequence Ź state.valuators;
                    cnt: NAT Ź MIN[XlEndianPrivate.InlineExtensionGet8[xEvent, 6], 6]; 
                    first: NAT Ź XlEndianPrivate.InlineExtensionGet8[xEvent, 7]; 
                    Scan: PROC [] = {
                        IF valuators.leng<cnt+first THEN RETURN <<OOPS>>;
                        FOR i: NAT IN [0..cnt) DO
                            valuators[first+i] Ź LOOPHOLE[XlEndianPrivate.InlineExtensionGet32[xEvent, i*4 + 8]]
                            ENDLOOP;
                        IF first+6>=cnt THEN {
                            <<--don't test keys and buttons; the valuators are reported last>>
                            FinishMulti[state];
                            }
                        };
                    WITH state.lastMultiExt SELECT FROM
                        b: REF deviceBase ExtEventRep => {
                            IF valuators=NIL THEN 
                                b.valuators Ź state.valuators Ź valuators Ź NEW[Int32Sequence[cnt+first]];
                            b.deviceState Ź XlKeyButPrivate.SetFromWire[XlEndianPrivate.InlineExtensionGet16[xEvent, 4]]; 
                            Scan[];
                            };
                        s: REF deviceState ExtEventRep => {
                            IF valuators=NIL THEN RETURN; 
                            Scan[];
                            };
                        ENDCASE => {}
                    };
                DeviceValuator[xEvent, state];
                };
            deviceFocusIn => {
                DeviceFocusEvent[xEvent, state, TRUE];
                };
            deviceFocusOut => {
                DeviceFocusEvent[xEvent, state, FALSE];
                };
            deviceStateNotify => {
                DeviceStateNotify: PROC [xEvent: REF Xl.EventRep.extension, state: REF ExtensionStateRec] = {
                    x: BYTE Ź XlEndianPrivate.InlineExtensionGet8[xEvent, 11];
                    e: REF deviceState ExtEventRep ~ NEW[deviceState ExtEventRep];
                    state.lastMultiEvent Ź xEvent;
                    state.lastMultiExt Ź e;
                    state.valuators Ź NIL;
                    state.keys Ź NIL;
                    state.buttons Ź NIL;
                    e.deviceId Ź  XlEndianPrivate.InlineExtensionGet8[xEvent, 1] MOD 128;
                    e.seq Ź state.lastSequenceNo Ź XlEndianPrivate.InlineExtensionGet16[xEvent, 2];
                    e.time Ź [XlEndianPrivate.InlineExtensionGet32[xEvent, 4]];
                    e.numKeys Ź XlEndianPrivate.InlineExtensionGet8[xEvent, 8];
                    e.numButtons Ź XlEndianPrivate.InlineExtensionGet8[xEvent, 9];
                    e.numValuators Ź XlEndianPrivate.InlineExtensionGet8[xEvent, 10];
                    IF (x) MOD 2 # 0 THEN {
                        e.keys Ź state.keys Ź NEW[PACKED ARRAY [0..31] OF BYTE];
                        state.keys[0] Ź XlEndianPrivate.InlineExtensionGet8[xEvent, 12];
                        state.keys[1] Ź XlEndianPrivate.InlineExtensionGet8[xEvent, 13];
                        state.keys[2] Ź XlEndianPrivate.InlineExtensionGet8[xEvent, 14];
                        state.keys[3] Ź XlEndianPrivate.InlineExtensionGet8[xEvent, 15];
                        };
                    IF (x/2) MOD 2 # 0 THEN {
                        e.buttons Ź state.buttons Ź NEW[PACKED ARRAY [0..31] OF BYTE];
                        state.buttons[0] Ź XlEndianPrivate.InlineExtensionGet8[xEvent, 16];
                        state.buttons[1] Ź XlEndianPrivate.InlineExtensionGet8[xEvent, 17];
                        state.buttons[2] Ź XlEndianPrivate.InlineExtensionGet8[xEvent, 18];
                        state.buttons[3] Ź XlEndianPrivate.InlineExtensionGet8[xEvent, 19];
                        };
                    IF (x/4) MOD 2 # 0 THEN {
                        e.valuators Ź state.valuators Ź NEW[Int32Sequence[e.numValuators]];
                        state.valuators[0] Ź DecodeInt32[xEvent, 20];
                        state.valuators[1] Ź DecodeInt32[xEvent, 24];
                        state.valuators[2] Ź DecodeInt32[xEvent, 28];
                        };
                    e.relativeMode Ź (x MOD 040H) MOD 2 # 0;
                    e.inProximity Ź (x MOD 080H) MOD 2 # 0;
                    e.eventOffset Ź deviceStateNotify; 
                    xEvent.match Ź deviceStateNotifyKey;
                    xEvent.decoded Ź e;
                    IF (state.keys=NIL OR e.numKeys<32) AND (state.buttons=NIL OR e.numButtons<32) AND (state.valuators=NIL OR e.numValuators<3) THEN 
                    FinishMulti[state];
                    };
                DeviceStateNotify[xEvent, state];
                };
            deviceKeyStateNotify => {
            <<--after deviceStateNotify>>
                DeviceKeyStateNotify: PROC [xEvent: REF Xl.EventRep.extension, state: REF ExtensionStateRec] = {
                    WITH state.lastMultiExt SELECT FROM
                        s: REF deviceState ExtEventRep => {
                            IF state.keys=NIL THEN RETURN;
                            FOR i: INT IN [4..32) DO
                                state.keys[i] Ź XlEndianPrivate.InlineExtensionGet8[xEvent, i];
                                ENDLOOP;
                            IF (XlEndianPrivate.InlineExtensionGet8[xEvent, 1] / 080H) MOD 2 = 0 THEN FinishMulti[state];
                            };
                        ENDCASE => {}
                    };
                DeviceKeyStateNotify[xEvent, state];
                };
            deviceButtonStateNotify => {
            <<--immediately after deviceStateNotify>>
                DeviceButtonStateNotify: PROC [xEvent: REF Xl.EventRep.extension, state: REF ExtensionStateRec] = {
                    WITH state.lastMultiExt SELECT FROM
                        s: REF deviceState ExtEventRep => {
                            IF state.buttons=NIL THEN RETURN;
                            FOR i: INT IN [4..32) DO
                                state.buttons[i] Ź XlEndianPrivate.InlineExtensionGet8[xEvent, i];
                                ENDLOOP;
                            IF (XlEndianPrivate.InlineExtensionGet8[xEvent, 1] / 080H) MOD 2 = 0 THEN FinishMulti[state];
                            };
                        ENDCASE => {}
                    };
                DeviceButtonStateNotify[xEvent, state];
                };
            deviceMappingNotify => {
                DeviceMappingNotify: PROC [xEvent: REF Xl.EventRep.extension] = {
                    e: REF deviceMapping ExtEventRep ~ NEW[deviceMapping ExtEventRep];
                    request: BYTE Ź XlEndianPrivate.InlineExtensionGet8[xEvent, 4];
                    IF request>2 THEN RETURN <<OOPS>>;
                    e.deviceId Ź XlEndianPrivate.InlineExtensionGet8[xEvent, 1] MOD 128;
                    e.seq Ź XlEndianPrivate.InlineExtensionGet16[xEvent, 2];
                    e.time Ź [XlEndianPrivate.InlineExtensionGet32[xEvent, 8]];
                    e.firstKeycode Ź XlEndianPrivate.InlineExtensionGet8[xEvent, 5];
                    e.count Ź XlEndianPrivate.InlineExtensionGet8[xEvent, 6];
                    e.request Ź VAL[request];
                    e.eventOffset Ź deviceMappingNotify; 
                    xEvent.match Ź deviceMappingNotifyKey;
                    xEvent.decoded Ź e;
                    XlDispatch.FindAndDispatch[xEvent];
                    };
                DeviceMappingNotify[xEvent]
                };
            changeDeviceNotify => {
                ChangeDeviceNotify: PROC [xEvent: REF Xl.EventRep.extension] = {
                    e: REF deviceChange ExtEventRep ~ NEW[deviceChange ExtEventRep];
                    what: BYTE Ź XlEndianPrivate.InlineExtensionGet8[xEvent, 8];
                    IF what>1 THEN RETURN <<OOPS>>;
                    e.newWhat Ź VAL[what];
                    e.deviceId Ź XlEndianPrivate.InlineExtensionGet8[xEvent, 1] MOD 128;
                    e.seq Ź XlEndianPrivate.InlineExtensionGet16[xEvent, 2];
                    e.time Ź [XlEndianPrivate.InlineExtensionGet32[xEvent, 4]];
                    e.eventOffset Ź changeDeviceNotify; 
                    xEvent.match Ź changeDeviceNotifyKey;
                    xEvent.decoded Ź e;
                    XlDispatch.FindAndDispatch[xEvent];
                    };
                ChangeDeviceNotify[xEvent]
                };
            deviceKeyPress => {
                moreEvents: BOOL;
                e: REF deviceBase ExtEventRep ~ DeviceBaseEvent[xEvent, state];
                e.keyCode Ź VAL[XlEndianPrivate.InlineExtensionGet8[xEvent, 1]];
                e.eventOffset Ź deviceKeyPress;
                xEvent.match Ź deviceKeyPressKey;
                moreEvents Ź (XlEndianPrivate.InlineExtensionGet8[xEvent, 31] / 128) # 0;
                IF ~moreEvents THEN XlDispatch.FindAndDispatch[xEvent];
                };
            deviceKeyRelease => {
                moreEvents: BOOL;
                e: REF deviceBase ExtEventRep ~ DeviceBaseEvent[xEvent, state];
                e.keyCode Ź VAL[XlEndianPrivate.InlineExtensionGet8[xEvent, 1]];
                e.eventOffset Ź deviceKeyRelease;
                xEvent.match Ź deviceKeyReleaseKey;
                moreEvents Ź (XlEndianPrivate.InlineExtensionGet8[xEvent, 31] / 128) # 0;
                IF ~moreEvents THEN XlDispatch.FindAndDispatch[xEvent];
                };
            deviceButtonPress => {
                moreEvents: BOOL;
                e: REF deviceBase ExtEventRep ~ DeviceBaseEvent[xEvent, state];
                e.button Ź XlEndianPrivate.InlineExtensionGet8[xEvent, 1];
                e.eventOffset Ź deviceButtonPress;
                xEvent.match Ź deviceButtonPressKey;
                moreEvents Ź (XlEndianPrivate.InlineExtensionGet8[xEvent, 31] / 128) # 0;
                IF ~moreEvents THEN XlDispatch.FindAndDispatch[xEvent];
                };
            deviceButtonRelease => {
                moreEvents: BOOL;
                e: REF deviceBase ExtEventRep ~ DeviceBaseEvent[xEvent, state];
                e.button Ź XlEndianPrivate.InlineExtensionGet8[xEvent, 1];
                e.eventOffset Ź deviceButtonRelease;
                xEvent.match Ź deviceButtonReleaseKey;
                moreEvents Ź (XlEndianPrivate.InlineExtensionGet8[xEvent, 31] / 128) # 0;
                IF ~moreEvents THEN XlDispatch.FindAndDispatch[xEvent];
                };
            deviceMotionNotify => {
                moreEvents: BOOL;
                e: REF deviceBase ExtEventRep ~ DeviceBaseEvent[xEvent, state];
                e.normalHint Ź VAL[XlEndianPrivate.InlineExtensionGet8[xEvent, 1] MOD 2];
                e.eventOffset Ź deviceMotionNotify;
                xEvent.match Ź deviceMotionNotifyKey;
                moreEvents Ź (XlEndianPrivate.InlineExtensionGet8[xEvent, 31] / 128) # 0;
                IF ~moreEvents THEN XlDispatch.FindAndDispatch[xEvent];
                };
            proximityIn => {
                moreEvents: BOOL;
                e: REF deviceBase ExtEventRep ~ DeviceBaseEvent[xEvent, state];
                e.eventOffset Ź proximityIn;
                xEvent.match Ź proximityInKey;
                moreEvents Ź (XlEndianPrivate.InlineExtensionGet8[xEvent, 31] / 128) # 0;
                IF ~moreEvents THEN XlDispatch.FindAndDispatch[xEvent];
                };
            proximityOut => {
                moreEvents: BOOL;
                e: REF deviceBase ExtEventRep ~ DeviceBaseEvent[xEvent, state];
                e.eventOffset Ź proximityOut;
                xEvent.match Ź proximityOutKey;
                moreEvents Ź (XlEndianPrivate.InlineExtensionGet8[xEvent, 31] / 128) # 0;
                IF ~moreEvents THEN XlDispatch.FindAndDispatch[xEvent];
                };
            ENDCASE => ERROR;
        };

    DecodeIntFrom16: PROC [xEvent: REF Xl.EventRep.extension, pos: INT] RETURNS [i: INT] = {
        i Ź LOOPHOLE[XlEndianPrivate.InlineExtensionGet16[xEvent, pos], INT16];
        };
    DecodeInt32: PROC [xEvent: REF Xl.EventRep.extension, pos: INT] RETURNS [i: INT] = {
        i Ź LOOPHOLE[XlEndianPrivate.InlineExtensionGet32[xEvent, pos], INT32];
        };
    DecodeWindow: PROC [xEvent: REF Xl.EventRep.extension, pos: INT] RETURNS [w: Xl.Window] = {
        w Ź LOOPHOLE[XlEndianPrivate.InlineExtensionGet32[xEvent, pos], Xl.Window];
        };

    XlExtensions.DefineExtensionClass[extensionKey, ProcessEvents, ORD[EventOffset.LAST]+1];
    END.