7296 lines
156 KiB
Go
7296 lines
156 KiB
Go
package xgb
|
|
|
|
/*
|
|
This file was generated by xinput.xml on May 6 2012 5:48:48pm EDT.
|
|
This file is automatically generated. Edit at your peril!
|
|
*/
|
|
|
|
// Imports are not necessary for XGB because everything is
|
|
// in one package. They are still listed here for reference.
|
|
// import "xproto"
|
|
|
|
// XinputInit must be called before using the XInputExtension extension.
|
|
func (c *Conn) XinputInit() error {
|
|
reply, err := c.QueryExtension(15, "XInputExtension").Reply()
|
|
switch {
|
|
case err != nil:
|
|
return err
|
|
case !reply.Present:
|
|
return newError("No extension named XInputExtension could be found on on the server.")
|
|
}
|
|
|
|
c.extLock.Lock()
|
|
c.extensions["XInputExtension"] = reply.MajorOpcode
|
|
for evNum, fun := range newExtEventFuncs["XInputExtension"] {
|
|
newEventFuncs[int(reply.FirstEvent)+evNum] = fun
|
|
}
|
|
c.extLock.Unlock()
|
|
|
|
return nil
|
|
}
|
|
|
|
func init() {
|
|
newExtEventFuncs["XInputExtension"] = make(map[int]newEventFun)
|
|
}
|
|
|
|
// Skipping definition for base type 'Int8'
|
|
|
|
// Skipping definition for base type 'Card16'
|
|
|
|
// Skipping definition for base type 'Char'
|
|
|
|
// Skipping definition for base type 'Card32'
|
|
|
|
// Skipping definition for base type 'Double'
|
|
|
|
// Skipping definition for base type 'Bool'
|
|
|
|
// Skipping definition for base type 'Float'
|
|
|
|
// Skipping definition for base type 'Id'
|
|
|
|
// Skipping definition for base type 'Card8'
|
|
|
|
// Skipping definition for base type 'Int16'
|
|
|
|
// Skipping definition for base type 'Int32'
|
|
|
|
// Skipping definition for base type 'Void'
|
|
|
|
// Skipping definition for base type 'Byte'
|
|
|
|
const (
|
|
XinputValuatorModeRelative = 0
|
|
XinputValuatorModeAbsolute = 1
|
|
)
|
|
|
|
const (
|
|
XinputPropagateModeAddToList = 0
|
|
XinputPropagateModeDeleteFromList = 1
|
|
)
|
|
|
|
const (
|
|
XinputDeviceUseIsXPointer = 0
|
|
XinputDeviceUseIsXKeyboard = 1
|
|
XinputDeviceUseIsXExtensionDevice = 2
|
|
XinputDeviceUseIsXExtensionKeyboard = 3
|
|
XinputDeviceUseIsXExtensionPointer = 4
|
|
)
|
|
|
|
const (
|
|
XinputInputClassKey = 0
|
|
XinputInputClassButton = 1
|
|
XinputInputClassValuator = 2
|
|
XinputInputClassFeedback = 3
|
|
XinputInputClassProximity = 4
|
|
XinputInputClassFocus = 5
|
|
XinputInputClassOther = 6
|
|
)
|
|
|
|
const (
|
|
XinputDeviceInputModeAsyncThisDevice = 0
|
|
XinputDeviceInputModeSyncThisDevice = 1
|
|
XinputDeviceInputModeReplayThisDevice = 2
|
|
XinputDeviceInputModeAsyncOtherDevices = 3
|
|
XinputDeviceInputModeAsyncAll = 4
|
|
XinputDeviceInputModeSyncAll = 5
|
|
)
|
|
|
|
const (
|
|
XinputFeedbackClassKeyboard = 0
|
|
XinputFeedbackClassPointer = 1
|
|
XinputFeedbackClassString = 2
|
|
XinputFeedbackClassInteger = 3
|
|
XinputFeedbackClassLed = 4
|
|
XinputFeedbackClassBell = 5
|
|
)
|
|
|
|
type XinputKeyCode byte
|
|
|
|
type XinputEventClass uint32
|
|
|
|
// 'XinputDeviceInfo' struct definition
|
|
// Size: 8
|
|
type XinputDeviceInfo struct {
|
|
DeviceType Id
|
|
DeviceId byte
|
|
NumClassInfo byte
|
|
DeviceUse byte
|
|
// padding: 1 bytes
|
|
}
|
|
|
|
// Struct read XinputDeviceInfo
|
|
func ReadXinputDeviceInfo(buf []byte, v *XinputDeviceInfo) int {
|
|
b := 0
|
|
|
|
v.DeviceType = Id(Get32(buf[b:]))
|
|
b += 4
|
|
|
|
v.DeviceId = buf[b]
|
|
b += 1
|
|
|
|
v.NumClassInfo = buf[b]
|
|
b += 1
|
|
|
|
v.DeviceUse = buf[b]
|
|
b += 1
|
|
|
|
b += 1 // padding
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputDeviceInfo
|
|
func ReadXinputDeviceInfoList(buf []byte, dest []XinputDeviceInfo) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputDeviceInfo{}
|
|
b += ReadXinputDeviceInfo(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputDeviceInfo
|
|
func (v XinputDeviceInfo) Bytes() []byte {
|
|
buf := make([]byte, 8)
|
|
b := 0
|
|
|
|
Put32(buf[b:], uint32(v.DeviceType))
|
|
b += 4
|
|
|
|
buf[b] = v.DeviceId
|
|
b += 1
|
|
|
|
buf[b] = v.NumClassInfo
|
|
b += 1
|
|
|
|
buf[b] = v.DeviceUse
|
|
b += 1
|
|
|
|
b += 1 // padding
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputDeviceInfo
|
|
func XinputDeviceInfoListBytes(buf []byte, list []XinputDeviceInfo) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// 'XinputInputInfo' struct definition
|
|
// Size: 2
|
|
type XinputInputInfo struct {
|
|
ClassId byte
|
|
Len byte
|
|
}
|
|
|
|
// Struct read XinputInputInfo
|
|
func ReadXinputInputInfo(buf []byte, v *XinputInputInfo) int {
|
|
b := 0
|
|
|
|
v.ClassId = buf[b]
|
|
b += 1
|
|
|
|
v.Len = buf[b]
|
|
b += 1
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputInputInfo
|
|
func ReadXinputInputInfoList(buf []byte, dest []XinputInputInfo) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputInputInfo{}
|
|
b += ReadXinputInputInfo(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputInputInfo
|
|
func (v XinputInputInfo) Bytes() []byte {
|
|
buf := make([]byte, 2)
|
|
b := 0
|
|
|
|
buf[b] = v.ClassId
|
|
b += 1
|
|
|
|
buf[b] = v.Len
|
|
b += 1
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputInputInfo
|
|
func XinputInputInfoListBytes(buf []byte, list []XinputInputInfo) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// 'XinputKeyInfo' struct definition
|
|
// Size: 8
|
|
type XinputKeyInfo struct {
|
|
ClassId byte
|
|
Len byte
|
|
MinKeycode XinputKeyCode
|
|
MaxKeycode XinputKeyCode
|
|
NumKeys uint16
|
|
// padding: 2 bytes
|
|
}
|
|
|
|
// Struct read XinputKeyInfo
|
|
func ReadXinputKeyInfo(buf []byte, v *XinputKeyInfo) int {
|
|
b := 0
|
|
|
|
v.ClassId = buf[b]
|
|
b += 1
|
|
|
|
v.Len = buf[b]
|
|
b += 1
|
|
|
|
v.MinKeycode = XinputKeyCode(buf[b])
|
|
b += 1
|
|
|
|
v.MaxKeycode = XinputKeyCode(buf[b])
|
|
b += 1
|
|
|
|
v.NumKeys = Get16(buf[b:])
|
|
b += 2
|
|
|
|
b += 2 // padding
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputKeyInfo
|
|
func ReadXinputKeyInfoList(buf []byte, dest []XinputKeyInfo) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputKeyInfo{}
|
|
b += ReadXinputKeyInfo(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputKeyInfo
|
|
func (v XinputKeyInfo) Bytes() []byte {
|
|
buf := make([]byte, 8)
|
|
b := 0
|
|
|
|
buf[b] = v.ClassId
|
|
b += 1
|
|
|
|
buf[b] = v.Len
|
|
b += 1
|
|
|
|
buf[b] = byte(v.MinKeycode)
|
|
b += 1
|
|
|
|
buf[b] = byte(v.MaxKeycode)
|
|
b += 1
|
|
|
|
Put16(buf[b:], v.NumKeys)
|
|
b += 2
|
|
|
|
b += 2 // padding
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputKeyInfo
|
|
func XinputKeyInfoListBytes(buf []byte, list []XinputKeyInfo) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// 'XinputButtonInfo' struct definition
|
|
// Size: 4
|
|
type XinputButtonInfo struct {
|
|
ClassId byte
|
|
Len byte
|
|
NumButtons uint16
|
|
}
|
|
|
|
// Struct read XinputButtonInfo
|
|
func ReadXinputButtonInfo(buf []byte, v *XinputButtonInfo) int {
|
|
b := 0
|
|
|
|
v.ClassId = buf[b]
|
|
b += 1
|
|
|
|
v.Len = buf[b]
|
|
b += 1
|
|
|
|
v.NumButtons = Get16(buf[b:])
|
|
b += 2
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputButtonInfo
|
|
func ReadXinputButtonInfoList(buf []byte, dest []XinputButtonInfo) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputButtonInfo{}
|
|
b += ReadXinputButtonInfo(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputButtonInfo
|
|
func (v XinputButtonInfo) Bytes() []byte {
|
|
buf := make([]byte, 4)
|
|
b := 0
|
|
|
|
buf[b] = v.ClassId
|
|
b += 1
|
|
|
|
buf[b] = v.Len
|
|
b += 1
|
|
|
|
Put16(buf[b:], v.NumButtons)
|
|
b += 2
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputButtonInfo
|
|
func XinputButtonInfoListBytes(buf []byte, list []XinputButtonInfo) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// 'XinputAxisInfo' struct definition
|
|
// Size: 12
|
|
type XinputAxisInfo struct {
|
|
Resolution uint32
|
|
Minimum int32
|
|
Maximum int32
|
|
}
|
|
|
|
// Struct read XinputAxisInfo
|
|
func ReadXinputAxisInfo(buf []byte, v *XinputAxisInfo) int {
|
|
b := 0
|
|
|
|
v.Resolution = Get32(buf[b:])
|
|
b += 4
|
|
|
|
v.Minimum = int32(Get32(buf[b:]))
|
|
b += 4
|
|
|
|
v.Maximum = int32(Get32(buf[b:]))
|
|
b += 4
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputAxisInfo
|
|
func ReadXinputAxisInfoList(buf []byte, dest []XinputAxisInfo) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputAxisInfo{}
|
|
b += ReadXinputAxisInfo(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputAxisInfo
|
|
func (v XinputAxisInfo) Bytes() []byte {
|
|
buf := make([]byte, 12)
|
|
b := 0
|
|
|
|
Put32(buf[b:], v.Resolution)
|
|
b += 4
|
|
|
|
Put32(buf[b:], uint32(v.Minimum))
|
|
b += 4
|
|
|
|
Put32(buf[b:], uint32(v.Maximum))
|
|
b += 4
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputAxisInfo
|
|
func XinputAxisInfoListBytes(buf []byte, list []XinputAxisInfo) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// 'XinputValuatorInfo' struct definition
|
|
// Size: (8 + pad((int(AxesLen) * 12)))
|
|
type XinputValuatorInfo struct {
|
|
ClassId byte
|
|
Len byte
|
|
AxesLen byte
|
|
Mode byte
|
|
MotionSize uint32
|
|
Axes []XinputAxisInfo // size: pad((int(AxesLen) * 12))
|
|
}
|
|
|
|
// Struct read XinputValuatorInfo
|
|
func ReadXinputValuatorInfo(buf []byte, v *XinputValuatorInfo) int {
|
|
b := 0
|
|
|
|
v.ClassId = buf[b]
|
|
b += 1
|
|
|
|
v.Len = buf[b]
|
|
b += 1
|
|
|
|
v.AxesLen = buf[b]
|
|
b += 1
|
|
|
|
v.Mode = buf[b]
|
|
b += 1
|
|
|
|
v.MotionSize = Get32(buf[b:])
|
|
b += 4
|
|
|
|
v.Axes = make([]XinputAxisInfo, v.AxesLen)
|
|
b += ReadXinputAxisInfoList(buf[b:], v.Axes)
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputValuatorInfo
|
|
func ReadXinputValuatorInfoList(buf []byte, dest []XinputValuatorInfo) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputValuatorInfo{}
|
|
b += ReadXinputValuatorInfo(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputValuatorInfo
|
|
func (v XinputValuatorInfo) Bytes() []byte {
|
|
buf := make([]byte, (8 + pad((int(v.AxesLen) * 12))))
|
|
b := 0
|
|
|
|
buf[b] = v.ClassId
|
|
b += 1
|
|
|
|
buf[b] = v.Len
|
|
b += 1
|
|
|
|
buf[b] = v.AxesLen
|
|
b += 1
|
|
|
|
buf[b] = v.Mode
|
|
b += 1
|
|
|
|
Put32(buf[b:], v.MotionSize)
|
|
b += 4
|
|
|
|
b += XinputAxisInfoListBytes(buf[b:], v.Axes)
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputValuatorInfo
|
|
func XinputValuatorInfoListBytes(buf []byte, list []XinputValuatorInfo) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// Struct list size XinputValuatorInfo
|
|
func XinputValuatorInfoListSize(list []XinputValuatorInfo) int {
|
|
size := 0
|
|
for _, item := range list {
|
|
size += (8 + pad((int(item.AxesLen) * 12)))
|
|
}
|
|
return size
|
|
}
|
|
|
|
// 'XinputInputClassInfo' struct definition
|
|
// Size: 2
|
|
type XinputInputClassInfo struct {
|
|
ClassId byte
|
|
EventTypeBase byte
|
|
}
|
|
|
|
// Struct read XinputInputClassInfo
|
|
func ReadXinputInputClassInfo(buf []byte, v *XinputInputClassInfo) int {
|
|
b := 0
|
|
|
|
v.ClassId = buf[b]
|
|
b += 1
|
|
|
|
v.EventTypeBase = buf[b]
|
|
b += 1
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputInputClassInfo
|
|
func ReadXinputInputClassInfoList(buf []byte, dest []XinputInputClassInfo) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputInputClassInfo{}
|
|
b += ReadXinputInputClassInfo(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputInputClassInfo
|
|
func (v XinputInputClassInfo) Bytes() []byte {
|
|
buf := make([]byte, 2)
|
|
b := 0
|
|
|
|
buf[b] = v.ClassId
|
|
b += 1
|
|
|
|
buf[b] = v.EventTypeBase
|
|
b += 1
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputInputClassInfo
|
|
func XinputInputClassInfoListBytes(buf []byte, list []XinputInputClassInfo) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// 'XinputDeviceTimeCoord' struct definition
|
|
// Size: 4
|
|
type XinputDeviceTimeCoord struct {
|
|
Time Timestamp
|
|
}
|
|
|
|
// Struct read XinputDeviceTimeCoord
|
|
func ReadXinputDeviceTimeCoord(buf []byte, v *XinputDeviceTimeCoord) int {
|
|
b := 0
|
|
|
|
v.Time = Timestamp(Get32(buf[b:]))
|
|
b += 4
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputDeviceTimeCoord
|
|
func ReadXinputDeviceTimeCoordList(buf []byte, dest []XinputDeviceTimeCoord) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputDeviceTimeCoord{}
|
|
b += ReadXinputDeviceTimeCoord(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputDeviceTimeCoord
|
|
func (v XinputDeviceTimeCoord) Bytes() []byte {
|
|
buf := make([]byte, 4)
|
|
b := 0
|
|
|
|
Put32(buf[b:], uint32(v.Time))
|
|
b += 4
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputDeviceTimeCoord
|
|
func XinputDeviceTimeCoordListBytes(buf []byte, list []XinputDeviceTimeCoord) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// 'XinputFeedbackState' struct definition
|
|
// Size: 4
|
|
type XinputFeedbackState struct {
|
|
ClassId byte
|
|
Id byte
|
|
Len uint16
|
|
}
|
|
|
|
// Struct read XinputFeedbackState
|
|
func ReadXinputFeedbackState(buf []byte, v *XinputFeedbackState) int {
|
|
b := 0
|
|
|
|
v.ClassId = buf[b]
|
|
b += 1
|
|
|
|
v.Id = buf[b]
|
|
b += 1
|
|
|
|
v.Len = Get16(buf[b:])
|
|
b += 2
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputFeedbackState
|
|
func ReadXinputFeedbackStateList(buf []byte, dest []XinputFeedbackState) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputFeedbackState{}
|
|
b += ReadXinputFeedbackState(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputFeedbackState
|
|
func (v XinputFeedbackState) Bytes() []byte {
|
|
buf := make([]byte, 4)
|
|
b := 0
|
|
|
|
buf[b] = v.ClassId
|
|
b += 1
|
|
|
|
buf[b] = v.Id
|
|
b += 1
|
|
|
|
Put16(buf[b:], v.Len)
|
|
b += 2
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputFeedbackState
|
|
func XinputFeedbackStateListBytes(buf []byte, list []XinputFeedbackState) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// 'XinputKbdFeedbackState' struct definition
|
|
// Size: 52
|
|
type XinputKbdFeedbackState struct {
|
|
ClassId byte
|
|
Id byte
|
|
Len uint16
|
|
Pitch uint16
|
|
Duration uint16
|
|
LedMask uint32
|
|
LedValues uint32
|
|
GlobalAutoRepeat bool
|
|
Click byte
|
|
Percent byte
|
|
// padding: 1 bytes
|
|
AutoRepeats []byte // size: 32
|
|
}
|
|
|
|
// Struct read XinputKbdFeedbackState
|
|
func ReadXinputKbdFeedbackState(buf []byte, v *XinputKbdFeedbackState) int {
|
|
b := 0
|
|
|
|
v.ClassId = buf[b]
|
|
b += 1
|
|
|
|
v.Id = buf[b]
|
|
b += 1
|
|
|
|
v.Len = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Pitch = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Duration = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.LedMask = Get32(buf[b:])
|
|
b += 4
|
|
|
|
v.LedValues = Get32(buf[b:])
|
|
b += 4
|
|
|
|
if buf[b] == 1 {
|
|
v.GlobalAutoRepeat = true
|
|
} else {
|
|
v.GlobalAutoRepeat = false
|
|
}
|
|
b += 1
|
|
|
|
v.Click = buf[b]
|
|
b += 1
|
|
|
|
v.Percent = buf[b]
|
|
b += 1
|
|
|
|
b += 1 // padding
|
|
|
|
v.AutoRepeats = make([]byte, 32)
|
|
copy(v.AutoRepeats[:32], buf[b:])
|
|
b += pad(int(32))
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputKbdFeedbackState
|
|
func ReadXinputKbdFeedbackStateList(buf []byte, dest []XinputKbdFeedbackState) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputKbdFeedbackState{}
|
|
b += ReadXinputKbdFeedbackState(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputKbdFeedbackState
|
|
func (v XinputKbdFeedbackState) Bytes() []byte {
|
|
buf := make([]byte, 52)
|
|
b := 0
|
|
|
|
buf[b] = v.ClassId
|
|
b += 1
|
|
|
|
buf[b] = v.Id
|
|
b += 1
|
|
|
|
Put16(buf[b:], v.Len)
|
|
b += 2
|
|
|
|
Put16(buf[b:], v.Pitch)
|
|
b += 2
|
|
|
|
Put16(buf[b:], v.Duration)
|
|
b += 2
|
|
|
|
Put32(buf[b:], v.LedMask)
|
|
b += 4
|
|
|
|
Put32(buf[b:], v.LedValues)
|
|
b += 4
|
|
|
|
if v.GlobalAutoRepeat {
|
|
buf[b] = 1
|
|
} else {
|
|
buf[b] = 0
|
|
}
|
|
b += 1
|
|
|
|
buf[b] = v.Click
|
|
b += 1
|
|
|
|
buf[b] = v.Percent
|
|
b += 1
|
|
|
|
b += 1 // padding
|
|
|
|
copy(buf[b:], v.AutoRepeats[:32])
|
|
b += pad(int(32))
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputKbdFeedbackState
|
|
func XinputKbdFeedbackStateListBytes(buf []byte, list []XinputKbdFeedbackState) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// Struct list size XinputKbdFeedbackState
|
|
func XinputKbdFeedbackStateListSize(list []XinputKbdFeedbackState) int {
|
|
size := 0
|
|
for _ = range list {
|
|
size += 52
|
|
}
|
|
return size
|
|
}
|
|
|
|
// 'XinputPtrFeedbackState' struct definition
|
|
// Size: 12
|
|
type XinputPtrFeedbackState struct {
|
|
ClassId byte
|
|
Id byte
|
|
Len uint16
|
|
// padding: 2 bytes
|
|
AccelNum uint16
|
|
AccelDenom uint16
|
|
Threshold uint16
|
|
}
|
|
|
|
// Struct read XinputPtrFeedbackState
|
|
func ReadXinputPtrFeedbackState(buf []byte, v *XinputPtrFeedbackState) int {
|
|
b := 0
|
|
|
|
v.ClassId = buf[b]
|
|
b += 1
|
|
|
|
v.Id = buf[b]
|
|
b += 1
|
|
|
|
v.Len = Get16(buf[b:])
|
|
b += 2
|
|
|
|
b += 2 // padding
|
|
|
|
v.AccelNum = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.AccelDenom = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Threshold = Get16(buf[b:])
|
|
b += 2
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputPtrFeedbackState
|
|
func ReadXinputPtrFeedbackStateList(buf []byte, dest []XinputPtrFeedbackState) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputPtrFeedbackState{}
|
|
b += ReadXinputPtrFeedbackState(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputPtrFeedbackState
|
|
func (v XinputPtrFeedbackState) Bytes() []byte {
|
|
buf := make([]byte, 12)
|
|
b := 0
|
|
|
|
buf[b] = v.ClassId
|
|
b += 1
|
|
|
|
buf[b] = v.Id
|
|
b += 1
|
|
|
|
Put16(buf[b:], v.Len)
|
|
b += 2
|
|
|
|
b += 2 // padding
|
|
|
|
Put16(buf[b:], v.AccelNum)
|
|
b += 2
|
|
|
|
Put16(buf[b:], v.AccelDenom)
|
|
b += 2
|
|
|
|
Put16(buf[b:], v.Threshold)
|
|
b += 2
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputPtrFeedbackState
|
|
func XinputPtrFeedbackStateListBytes(buf []byte, list []XinputPtrFeedbackState) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// 'XinputIntegerFeedbackState' struct definition
|
|
// Size: 16
|
|
type XinputIntegerFeedbackState struct {
|
|
ClassId byte
|
|
Id byte
|
|
Len uint16
|
|
Resolution uint32
|
|
MinValue int32
|
|
MaxValue int32
|
|
}
|
|
|
|
// Struct read XinputIntegerFeedbackState
|
|
func ReadXinputIntegerFeedbackState(buf []byte, v *XinputIntegerFeedbackState) int {
|
|
b := 0
|
|
|
|
v.ClassId = buf[b]
|
|
b += 1
|
|
|
|
v.Id = buf[b]
|
|
b += 1
|
|
|
|
v.Len = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Resolution = Get32(buf[b:])
|
|
b += 4
|
|
|
|
v.MinValue = int32(Get32(buf[b:]))
|
|
b += 4
|
|
|
|
v.MaxValue = int32(Get32(buf[b:]))
|
|
b += 4
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputIntegerFeedbackState
|
|
func ReadXinputIntegerFeedbackStateList(buf []byte, dest []XinputIntegerFeedbackState) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputIntegerFeedbackState{}
|
|
b += ReadXinputIntegerFeedbackState(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputIntegerFeedbackState
|
|
func (v XinputIntegerFeedbackState) Bytes() []byte {
|
|
buf := make([]byte, 16)
|
|
b := 0
|
|
|
|
buf[b] = v.ClassId
|
|
b += 1
|
|
|
|
buf[b] = v.Id
|
|
b += 1
|
|
|
|
Put16(buf[b:], v.Len)
|
|
b += 2
|
|
|
|
Put32(buf[b:], v.Resolution)
|
|
b += 4
|
|
|
|
Put32(buf[b:], uint32(v.MinValue))
|
|
b += 4
|
|
|
|
Put32(buf[b:], uint32(v.MaxValue))
|
|
b += 4
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputIntegerFeedbackState
|
|
func XinputIntegerFeedbackStateListBytes(buf []byte, list []XinputIntegerFeedbackState) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// 'XinputStringFeedbackState' struct definition
|
|
// Size: (8 + pad((int(NumKeysyms) * 4)))
|
|
type XinputStringFeedbackState struct {
|
|
ClassId byte
|
|
Id byte
|
|
Len uint16
|
|
MaxSymbols uint16
|
|
NumKeysyms uint16
|
|
Keysyms []Keysym // size: pad((int(NumKeysyms) * 4))
|
|
}
|
|
|
|
// Struct read XinputStringFeedbackState
|
|
func ReadXinputStringFeedbackState(buf []byte, v *XinputStringFeedbackState) int {
|
|
b := 0
|
|
|
|
v.ClassId = buf[b]
|
|
b += 1
|
|
|
|
v.Id = buf[b]
|
|
b += 1
|
|
|
|
v.Len = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.MaxSymbols = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.NumKeysyms = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Keysyms = make([]Keysym, v.NumKeysyms)
|
|
for i := 0; i < int(v.NumKeysyms); i++ {
|
|
v.Keysyms[i] = Keysym(Get32(buf[b:]))
|
|
b += 4
|
|
}
|
|
b = pad(b)
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputStringFeedbackState
|
|
func ReadXinputStringFeedbackStateList(buf []byte, dest []XinputStringFeedbackState) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputStringFeedbackState{}
|
|
b += ReadXinputStringFeedbackState(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputStringFeedbackState
|
|
func (v XinputStringFeedbackState) Bytes() []byte {
|
|
buf := make([]byte, (8 + pad((int(v.NumKeysyms) * 4))))
|
|
b := 0
|
|
|
|
buf[b] = v.ClassId
|
|
b += 1
|
|
|
|
buf[b] = v.Id
|
|
b += 1
|
|
|
|
Put16(buf[b:], v.Len)
|
|
b += 2
|
|
|
|
Put16(buf[b:], v.MaxSymbols)
|
|
b += 2
|
|
|
|
Put16(buf[b:], v.NumKeysyms)
|
|
b += 2
|
|
|
|
for i := 0; i < int(v.NumKeysyms); i++ {
|
|
Put32(buf[b:], uint32(v.Keysyms[i]))
|
|
b += 4
|
|
}
|
|
b = pad(b)
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputStringFeedbackState
|
|
func XinputStringFeedbackStateListBytes(buf []byte, list []XinputStringFeedbackState) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// Struct list size XinputStringFeedbackState
|
|
func XinputStringFeedbackStateListSize(list []XinputStringFeedbackState) int {
|
|
size := 0
|
|
for _, item := range list {
|
|
size += (8 + pad((int(item.NumKeysyms) * 4)))
|
|
}
|
|
return size
|
|
}
|
|
|
|
// 'XinputBellFeedbackState' struct definition
|
|
// Size: 12
|
|
type XinputBellFeedbackState struct {
|
|
ClassId byte
|
|
Id byte
|
|
Len uint16
|
|
Percent byte
|
|
// padding: 3 bytes
|
|
Pitch uint16
|
|
Duration uint16
|
|
}
|
|
|
|
// Struct read XinputBellFeedbackState
|
|
func ReadXinputBellFeedbackState(buf []byte, v *XinputBellFeedbackState) int {
|
|
b := 0
|
|
|
|
v.ClassId = buf[b]
|
|
b += 1
|
|
|
|
v.Id = buf[b]
|
|
b += 1
|
|
|
|
v.Len = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Percent = buf[b]
|
|
b += 1
|
|
|
|
b += 3 // padding
|
|
|
|
v.Pitch = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Duration = Get16(buf[b:])
|
|
b += 2
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputBellFeedbackState
|
|
func ReadXinputBellFeedbackStateList(buf []byte, dest []XinputBellFeedbackState) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputBellFeedbackState{}
|
|
b += ReadXinputBellFeedbackState(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputBellFeedbackState
|
|
func (v XinputBellFeedbackState) Bytes() []byte {
|
|
buf := make([]byte, 12)
|
|
b := 0
|
|
|
|
buf[b] = v.ClassId
|
|
b += 1
|
|
|
|
buf[b] = v.Id
|
|
b += 1
|
|
|
|
Put16(buf[b:], v.Len)
|
|
b += 2
|
|
|
|
buf[b] = v.Percent
|
|
b += 1
|
|
|
|
b += 3 // padding
|
|
|
|
Put16(buf[b:], v.Pitch)
|
|
b += 2
|
|
|
|
Put16(buf[b:], v.Duration)
|
|
b += 2
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputBellFeedbackState
|
|
func XinputBellFeedbackStateListBytes(buf []byte, list []XinputBellFeedbackState) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// 'XinputLedFeedbackState' struct definition
|
|
// Size: 12
|
|
type XinputLedFeedbackState struct {
|
|
ClassId byte
|
|
Id byte
|
|
Len uint16
|
|
LedMask uint32
|
|
LedValues uint32
|
|
}
|
|
|
|
// Struct read XinputLedFeedbackState
|
|
func ReadXinputLedFeedbackState(buf []byte, v *XinputLedFeedbackState) int {
|
|
b := 0
|
|
|
|
v.ClassId = buf[b]
|
|
b += 1
|
|
|
|
v.Id = buf[b]
|
|
b += 1
|
|
|
|
v.Len = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.LedMask = Get32(buf[b:])
|
|
b += 4
|
|
|
|
v.LedValues = Get32(buf[b:])
|
|
b += 4
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputLedFeedbackState
|
|
func ReadXinputLedFeedbackStateList(buf []byte, dest []XinputLedFeedbackState) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputLedFeedbackState{}
|
|
b += ReadXinputLedFeedbackState(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputLedFeedbackState
|
|
func (v XinputLedFeedbackState) Bytes() []byte {
|
|
buf := make([]byte, 12)
|
|
b := 0
|
|
|
|
buf[b] = v.ClassId
|
|
b += 1
|
|
|
|
buf[b] = v.Id
|
|
b += 1
|
|
|
|
Put16(buf[b:], v.Len)
|
|
b += 2
|
|
|
|
Put32(buf[b:], v.LedMask)
|
|
b += 4
|
|
|
|
Put32(buf[b:], v.LedValues)
|
|
b += 4
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputLedFeedbackState
|
|
func XinputLedFeedbackStateListBytes(buf []byte, list []XinputLedFeedbackState) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// 'XinputFeedbackCtl' struct definition
|
|
// Size: 4
|
|
type XinputFeedbackCtl struct {
|
|
ClassId byte
|
|
Id byte
|
|
Len uint16
|
|
}
|
|
|
|
// Struct read XinputFeedbackCtl
|
|
func ReadXinputFeedbackCtl(buf []byte, v *XinputFeedbackCtl) int {
|
|
b := 0
|
|
|
|
v.ClassId = buf[b]
|
|
b += 1
|
|
|
|
v.Id = buf[b]
|
|
b += 1
|
|
|
|
v.Len = Get16(buf[b:])
|
|
b += 2
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputFeedbackCtl
|
|
func ReadXinputFeedbackCtlList(buf []byte, dest []XinputFeedbackCtl) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputFeedbackCtl{}
|
|
b += ReadXinputFeedbackCtl(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputFeedbackCtl
|
|
func (v XinputFeedbackCtl) Bytes() []byte {
|
|
buf := make([]byte, 4)
|
|
b := 0
|
|
|
|
buf[b] = v.ClassId
|
|
b += 1
|
|
|
|
buf[b] = v.Id
|
|
b += 1
|
|
|
|
Put16(buf[b:], v.Len)
|
|
b += 2
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputFeedbackCtl
|
|
func XinputFeedbackCtlListBytes(buf []byte, list []XinputFeedbackCtl) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// 'XinputKbdFeedbackCtl' struct definition
|
|
// Size: 20
|
|
type XinputKbdFeedbackCtl struct {
|
|
ClassId byte
|
|
Id byte
|
|
Len uint16
|
|
Key XinputKeyCode
|
|
AutoRepeatMode byte
|
|
KeyClickPercent int8
|
|
BellPercent int8
|
|
BellPitch int16
|
|
BellDuration int16
|
|
LedMask uint32
|
|
LedValues uint32
|
|
}
|
|
|
|
// Struct read XinputKbdFeedbackCtl
|
|
func ReadXinputKbdFeedbackCtl(buf []byte, v *XinputKbdFeedbackCtl) int {
|
|
b := 0
|
|
|
|
v.ClassId = buf[b]
|
|
b += 1
|
|
|
|
v.Id = buf[b]
|
|
b += 1
|
|
|
|
v.Len = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Key = XinputKeyCode(buf[b])
|
|
b += 1
|
|
|
|
v.AutoRepeatMode = buf[b]
|
|
b += 1
|
|
|
|
v.KeyClickPercent = int8(buf[b])
|
|
b += 1
|
|
|
|
v.BellPercent = int8(buf[b])
|
|
b += 1
|
|
|
|
v.BellPitch = int16(Get16(buf[b:]))
|
|
b += 2
|
|
|
|
v.BellDuration = int16(Get16(buf[b:]))
|
|
b += 2
|
|
|
|
v.LedMask = Get32(buf[b:])
|
|
b += 4
|
|
|
|
v.LedValues = Get32(buf[b:])
|
|
b += 4
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputKbdFeedbackCtl
|
|
func ReadXinputKbdFeedbackCtlList(buf []byte, dest []XinputKbdFeedbackCtl) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputKbdFeedbackCtl{}
|
|
b += ReadXinputKbdFeedbackCtl(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputKbdFeedbackCtl
|
|
func (v XinputKbdFeedbackCtl) Bytes() []byte {
|
|
buf := make([]byte, 20)
|
|
b := 0
|
|
|
|
buf[b] = v.ClassId
|
|
b += 1
|
|
|
|
buf[b] = v.Id
|
|
b += 1
|
|
|
|
Put16(buf[b:], v.Len)
|
|
b += 2
|
|
|
|
buf[b] = byte(v.Key)
|
|
b += 1
|
|
|
|
buf[b] = v.AutoRepeatMode
|
|
b += 1
|
|
|
|
buf[b] = byte(v.KeyClickPercent)
|
|
b += 1
|
|
|
|
buf[b] = byte(v.BellPercent)
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(v.BellPitch))
|
|
b += 2
|
|
|
|
Put16(buf[b:], uint16(v.BellDuration))
|
|
b += 2
|
|
|
|
Put32(buf[b:], v.LedMask)
|
|
b += 4
|
|
|
|
Put32(buf[b:], v.LedValues)
|
|
b += 4
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputKbdFeedbackCtl
|
|
func XinputKbdFeedbackCtlListBytes(buf []byte, list []XinputKbdFeedbackCtl) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// 'XinputPtrFeedbackCtl' struct definition
|
|
// Size: 12
|
|
type XinputPtrFeedbackCtl struct {
|
|
ClassId byte
|
|
Id byte
|
|
Len uint16
|
|
// padding: 2 bytes
|
|
Num int16
|
|
Denom int16
|
|
Threshold int16
|
|
}
|
|
|
|
// Struct read XinputPtrFeedbackCtl
|
|
func ReadXinputPtrFeedbackCtl(buf []byte, v *XinputPtrFeedbackCtl) int {
|
|
b := 0
|
|
|
|
v.ClassId = buf[b]
|
|
b += 1
|
|
|
|
v.Id = buf[b]
|
|
b += 1
|
|
|
|
v.Len = Get16(buf[b:])
|
|
b += 2
|
|
|
|
b += 2 // padding
|
|
|
|
v.Num = int16(Get16(buf[b:]))
|
|
b += 2
|
|
|
|
v.Denom = int16(Get16(buf[b:]))
|
|
b += 2
|
|
|
|
v.Threshold = int16(Get16(buf[b:]))
|
|
b += 2
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputPtrFeedbackCtl
|
|
func ReadXinputPtrFeedbackCtlList(buf []byte, dest []XinputPtrFeedbackCtl) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputPtrFeedbackCtl{}
|
|
b += ReadXinputPtrFeedbackCtl(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputPtrFeedbackCtl
|
|
func (v XinputPtrFeedbackCtl) Bytes() []byte {
|
|
buf := make([]byte, 12)
|
|
b := 0
|
|
|
|
buf[b] = v.ClassId
|
|
b += 1
|
|
|
|
buf[b] = v.Id
|
|
b += 1
|
|
|
|
Put16(buf[b:], v.Len)
|
|
b += 2
|
|
|
|
b += 2 // padding
|
|
|
|
Put16(buf[b:], uint16(v.Num))
|
|
b += 2
|
|
|
|
Put16(buf[b:], uint16(v.Denom))
|
|
b += 2
|
|
|
|
Put16(buf[b:], uint16(v.Threshold))
|
|
b += 2
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputPtrFeedbackCtl
|
|
func XinputPtrFeedbackCtlListBytes(buf []byte, list []XinputPtrFeedbackCtl) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// 'XinputIntegerFeedbackCtl' struct definition
|
|
// Size: 8
|
|
type XinputIntegerFeedbackCtl struct {
|
|
ClassId byte
|
|
Id byte
|
|
Len uint16
|
|
IntToDisplay int32
|
|
}
|
|
|
|
// Struct read XinputIntegerFeedbackCtl
|
|
func ReadXinputIntegerFeedbackCtl(buf []byte, v *XinputIntegerFeedbackCtl) int {
|
|
b := 0
|
|
|
|
v.ClassId = buf[b]
|
|
b += 1
|
|
|
|
v.Id = buf[b]
|
|
b += 1
|
|
|
|
v.Len = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.IntToDisplay = int32(Get32(buf[b:]))
|
|
b += 4
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputIntegerFeedbackCtl
|
|
func ReadXinputIntegerFeedbackCtlList(buf []byte, dest []XinputIntegerFeedbackCtl) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputIntegerFeedbackCtl{}
|
|
b += ReadXinputIntegerFeedbackCtl(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputIntegerFeedbackCtl
|
|
func (v XinputIntegerFeedbackCtl) Bytes() []byte {
|
|
buf := make([]byte, 8)
|
|
b := 0
|
|
|
|
buf[b] = v.ClassId
|
|
b += 1
|
|
|
|
buf[b] = v.Id
|
|
b += 1
|
|
|
|
Put16(buf[b:], v.Len)
|
|
b += 2
|
|
|
|
Put32(buf[b:], uint32(v.IntToDisplay))
|
|
b += 4
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputIntegerFeedbackCtl
|
|
func XinputIntegerFeedbackCtlListBytes(buf []byte, list []XinputIntegerFeedbackCtl) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// 'XinputStringFeedbackCtl' struct definition
|
|
// Size: (8 + pad((int(NumKeysyms) * 4)))
|
|
type XinputStringFeedbackCtl struct {
|
|
ClassId byte
|
|
Id byte
|
|
Len uint16
|
|
// padding: 2 bytes
|
|
NumKeysyms uint16
|
|
Keysyms []Keysym // size: pad((int(NumKeysyms) * 4))
|
|
}
|
|
|
|
// Struct read XinputStringFeedbackCtl
|
|
func ReadXinputStringFeedbackCtl(buf []byte, v *XinputStringFeedbackCtl) int {
|
|
b := 0
|
|
|
|
v.ClassId = buf[b]
|
|
b += 1
|
|
|
|
v.Id = buf[b]
|
|
b += 1
|
|
|
|
v.Len = Get16(buf[b:])
|
|
b += 2
|
|
|
|
b += 2 // padding
|
|
|
|
v.NumKeysyms = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Keysyms = make([]Keysym, v.NumKeysyms)
|
|
for i := 0; i < int(v.NumKeysyms); i++ {
|
|
v.Keysyms[i] = Keysym(Get32(buf[b:]))
|
|
b += 4
|
|
}
|
|
b = pad(b)
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputStringFeedbackCtl
|
|
func ReadXinputStringFeedbackCtlList(buf []byte, dest []XinputStringFeedbackCtl) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputStringFeedbackCtl{}
|
|
b += ReadXinputStringFeedbackCtl(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputStringFeedbackCtl
|
|
func (v XinputStringFeedbackCtl) Bytes() []byte {
|
|
buf := make([]byte, (8 + pad((int(v.NumKeysyms) * 4))))
|
|
b := 0
|
|
|
|
buf[b] = v.ClassId
|
|
b += 1
|
|
|
|
buf[b] = v.Id
|
|
b += 1
|
|
|
|
Put16(buf[b:], v.Len)
|
|
b += 2
|
|
|
|
b += 2 // padding
|
|
|
|
Put16(buf[b:], v.NumKeysyms)
|
|
b += 2
|
|
|
|
for i := 0; i < int(v.NumKeysyms); i++ {
|
|
Put32(buf[b:], uint32(v.Keysyms[i]))
|
|
b += 4
|
|
}
|
|
b = pad(b)
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputStringFeedbackCtl
|
|
func XinputStringFeedbackCtlListBytes(buf []byte, list []XinputStringFeedbackCtl) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// Struct list size XinputStringFeedbackCtl
|
|
func XinputStringFeedbackCtlListSize(list []XinputStringFeedbackCtl) int {
|
|
size := 0
|
|
for _, item := range list {
|
|
size += (8 + pad((int(item.NumKeysyms) * 4)))
|
|
}
|
|
return size
|
|
}
|
|
|
|
// 'XinputBellFeedbackCtl' struct definition
|
|
// Size: 12
|
|
type XinputBellFeedbackCtl struct {
|
|
ClassId byte
|
|
Id byte
|
|
Len uint16
|
|
Percent int8
|
|
// padding: 3 bytes
|
|
Pitch int16
|
|
Duration int16
|
|
}
|
|
|
|
// Struct read XinputBellFeedbackCtl
|
|
func ReadXinputBellFeedbackCtl(buf []byte, v *XinputBellFeedbackCtl) int {
|
|
b := 0
|
|
|
|
v.ClassId = buf[b]
|
|
b += 1
|
|
|
|
v.Id = buf[b]
|
|
b += 1
|
|
|
|
v.Len = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Percent = int8(buf[b])
|
|
b += 1
|
|
|
|
b += 3 // padding
|
|
|
|
v.Pitch = int16(Get16(buf[b:]))
|
|
b += 2
|
|
|
|
v.Duration = int16(Get16(buf[b:]))
|
|
b += 2
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputBellFeedbackCtl
|
|
func ReadXinputBellFeedbackCtlList(buf []byte, dest []XinputBellFeedbackCtl) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputBellFeedbackCtl{}
|
|
b += ReadXinputBellFeedbackCtl(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputBellFeedbackCtl
|
|
func (v XinputBellFeedbackCtl) Bytes() []byte {
|
|
buf := make([]byte, 12)
|
|
b := 0
|
|
|
|
buf[b] = v.ClassId
|
|
b += 1
|
|
|
|
buf[b] = v.Id
|
|
b += 1
|
|
|
|
Put16(buf[b:], v.Len)
|
|
b += 2
|
|
|
|
buf[b] = byte(v.Percent)
|
|
b += 1
|
|
|
|
b += 3 // padding
|
|
|
|
Put16(buf[b:], uint16(v.Pitch))
|
|
b += 2
|
|
|
|
Put16(buf[b:], uint16(v.Duration))
|
|
b += 2
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputBellFeedbackCtl
|
|
func XinputBellFeedbackCtlListBytes(buf []byte, list []XinputBellFeedbackCtl) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// 'XinputLedFeedbackCtl' struct definition
|
|
// Size: 12
|
|
type XinputLedFeedbackCtl struct {
|
|
ClassId byte
|
|
Id byte
|
|
Len uint16
|
|
LedMask uint32
|
|
LedValues uint32
|
|
}
|
|
|
|
// Struct read XinputLedFeedbackCtl
|
|
func ReadXinputLedFeedbackCtl(buf []byte, v *XinputLedFeedbackCtl) int {
|
|
b := 0
|
|
|
|
v.ClassId = buf[b]
|
|
b += 1
|
|
|
|
v.Id = buf[b]
|
|
b += 1
|
|
|
|
v.Len = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.LedMask = Get32(buf[b:])
|
|
b += 4
|
|
|
|
v.LedValues = Get32(buf[b:])
|
|
b += 4
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputLedFeedbackCtl
|
|
func ReadXinputLedFeedbackCtlList(buf []byte, dest []XinputLedFeedbackCtl) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputLedFeedbackCtl{}
|
|
b += ReadXinputLedFeedbackCtl(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputLedFeedbackCtl
|
|
func (v XinputLedFeedbackCtl) Bytes() []byte {
|
|
buf := make([]byte, 12)
|
|
b := 0
|
|
|
|
buf[b] = v.ClassId
|
|
b += 1
|
|
|
|
buf[b] = v.Id
|
|
b += 1
|
|
|
|
Put16(buf[b:], v.Len)
|
|
b += 2
|
|
|
|
Put32(buf[b:], v.LedMask)
|
|
b += 4
|
|
|
|
Put32(buf[b:], v.LedValues)
|
|
b += 4
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputLedFeedbackCtl
|
|
func XinputLedFeedbackCtlListBytes(buf []byte, list []XinputLedFeedbackCtl) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// 'XinputInputState' struct definition
|
|
// Size: 3
|
|
type XinputInputState struct {
|
|
ClassId byte
|
|
Len byte
|
|
NumItems byte
|
|
}
|
|
|
|
// Struct read XinputInputState
|
|
func ReadXinputInputState(buf []byte, v *XinputInputState) int {
|
|
b := 0
|
|
|
|
v.ClassId = buf[b]
|
|
b += 1
|
|
|
|
v.Len = buf[b]
|
|
b += 1
|
|
|
|
v.NumItems = buf[b]
|
|
b += 1
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputInputState
|
|
func ReadXinputInputStateList(buf []byte, dest []XinputInputState) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputInputState{}
|
|
b += ReadXinputInputState(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputInputState
|
|
func (v XinputInputState) Bytes() []byte {
|
|
buf := make([]byte, 3)
|
|
b := 0
|
|
|
|
buf[b] = v.ClassId
|
|
b += 1
|
|
|
|
buf[b] = v.Len
|
|
b += 1
|
|
|
|
buf[b] = v.NumItems
|
|
b += 1
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputInputState
|
|
func XinputInputStateListBytes(buf []byte, list []XinputInputState) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// 'XinputKeyState' struct definition
|
|
// Size: 36
|
|
type XinputKeyState struct {
|
|
ClassId byte
|
|
Len byte
|
|
NumKeys byte
|
|
// padding: 1 bytes
|
|
Keys []byte // size: 32
|
|
}
|
|
|
|
// Struct read XinputKeyState
|
|
func ReadXinputKeyState(buf []byte, v *XinputKeyState) int {
|
|
b := 0
|
|
|
|
v.ClassId = buf[b]
|
|
b += 1
|
|
|
|
v.Len = buf[b]
|
|
b += 1
|
|
|
|
v.NumKeys = buf[b]
|
|
b += 1
|
|
|
|
b += 1 // padding
|
|
|
|
v.Keys = make([]byte, 32)
|
|
copy(v.Keys[:32], buf[b:])
|
|
b += pad(int(32))
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputKeyState
|
|
func ReadXinputKeyStateList(buf []byte, dest []XinputKeyState) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputKeyState{}
|
|
b += ReadXinputKeyState(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputKeyState
|
|
func (v XinputKeyState) Bytes() []byte {
|
|
buf := make([]byte, 36)
|
|
b := 0
|
|
|
|
buf[b] = v.ClassId
|
|
b += 1
|
|
|
|
buf[b] = v.Len
|
|
b += 1
|
|
|
|
buf[b] = v.NumKeys
|
|
b += 1
|
|
|
|
b += 1 // padding
|
|
|
|
copy(buf[b:], v.Keys[:32])
|
|
b += pad(int(32))
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputKeyState
|
|
func XinputKeyStateListBytes(buf []byte, list []XinputKeyState) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// Struct list size XinputKeyState
|
|
func XinputKeyStateListSize(list []XinputKeyState) int {
|
|
size := 0
|
|
for _ = range list {
|
|
size += 36
|
|
}
|
|
return size
|
|
}
|
|
|
|
// 'XinputButtonState' struct definition
|
|
// Size: 36
|
|
type XinputButtonState struct {
|
|
ClassId byte
|
|
Len byte
|
|
NumButtons byte
|
|
// padding: 1 bytes
|
|
Buttons []byte // size: 32
|
|
}
|
|
|
|
// Struct read XinputButtonState
|
|
func ReadXinputButtonState(buf []byte, v *XinputButtonState) int {
|
|
b := 0
|
|
|
|
v.ClassId = buf[b]
|
|
b += 1
|
|
|
|
v.Len = buf[b]
|
|
b += 1
|
|
|
|
v.NumButtons = buf[b]
|
|
b += 1
|
|
|
|
b += 1 // padding
|
|
|
|
v.Buttons = make([]byte, 32)
|
|
copy(v.Buttons[:32], buf[b:])
|
|
b += pad(int(32))
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputButtonState
|
|
func ReadXinputButtonStateList(buf []byte, dest []XinputButtonState) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputButtonState{}
|
|
b += ReadXinputButtonState(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputButtonState
|
|
func (v XinputButtonState) Bytes() []byte {
|
|
buf := make([]byte, 36)
|
|
b := 0
|
|
|
|
buf[b] = v.ClassId
|
|
b += 1
|
|
|
|
buf[b] = v.Len
|
|
b += 1
|
|
|
|
buf[b] = v.NumButtons
|
|
b += 1
|
|
|
|
b += 1 // padding
|
|
|
|
copy(buf[b:], v.Buttons[:32])
|
|
b += pad(int(32))
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputButtonState
|
|
func XinputButtonStateListBytes(buf []byte, list []XinputButtonState) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// Struct list size XinputButtonState
|
|
func XinputButtonStateListSize(list []XinputButtonState) int {
|
|
size := 0
|
|
for _ = range list {
|
|
size += 36
|
|
}
|
|
return size
|
|
}
|
|
|
|
// 'XinputValuatorState' struct definition
|
|
// Size: (4 + pad((int(NumValuators) * 4)))
|
|
type XinputValuatorState struct {
|
|
ClassId byte
|
|
Len byte
|
|
NumValuators byte
|
|
Mode byte
|
|
Valuators []uint32 // size: pad((int(NumValuators) * 4))
|
|
}
|
|
|
|
// Struct read XinputValuatorState
|
|
func ReadXinputValuatorState(buf []byte, v *XinputValuatorState) int {
|
|
b := 0
|
|
|
|
v.ClassId = buf[b]
|
|
b += 1
|
|
|
|
v.Len = buf[b]
|
|
b += 1
|
|
|
|
v.NumValuators = buf[b]
|
|
b += 1
|
|
|
|
v.Mode = buf[b]
|
|
b += 1
|
|
|
|
v.Valuators = make([]uint32, v.NumValuators)
|
|
for i := 0; i < int(v.NumValuators); i++ {
|
|
v.Valuators[i] = Get32(buf[b:])
|
|
b += 4
|
|
}
|
|
b = pad(b)
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputValuatorState
|
|
func ReadXinputValuatorStateList(buf []byte, dest []XinputValuatorState) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputValuatorState{}
|
|
b += ReadXinputValuatorState(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputValuatorState
|
|
func (v XinputValuatorState) Bytes() []byte {
|
|
buf := make([]byte, (4 + pad((int(v.NumValuators) * 4))))
|
|
b := 0
|
|
|
|
buf[b] = v.ClassId
|
|
b += 1
|
|
|
|
buf[b] = v.Len
|
|
b += 1
|
|
|
|
buf[b] = v.NumValuators
|
|
b += 1
|
|
|
|
buf[b] = v.Mode
|
|
b += 1
|
|
|
|
for i := 0; i < int(v.NumValuators); i++ {
|
|
Put32(buf[b:], v.Valuators[i])
|
|
b += 4
|
|
}
|
|
b = pad(b)
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputValuatorState
|
|
func XinputValuatorStateListBytes(buf []byte, list []XinputValuatorState) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// Struct list size XinputValuatorState
|
|
func XinputValuatorStateListSize(list []XinputValuatorState) int {
|
|
size := 0
|
|
for _, item := range list {
|
|
size += (4 + pad((int(item.NumValuators) * 4)))
|
|
}
|
|
return size
|
|
}
|
|
|
|
// 'XinputDeviceState' struct definition
|
|
// Size: 4
|
|
type XinputDeviceState struct {
|
|
ControlId uint16
|
|
Len uint16
|
|
}
|
|
|
|
// Struct read XinputDeviceState
|
|
func ReadXinputDeviceState(buf []byte, v *XinputDeviceState) int {
|
|
b := 0
|
|
|
|
v.ControlId = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Len = Get16(buf[b:])
|
|
b += 2
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputDeviceState
|
|
func ReadXinputDeviceStateList(buf []byte, dest []XinputDeviceState) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputDeviceState{}
|
|
b += ReadXinputDeviceState(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputDeviceState
|
|
func (v XinputDeviceState) Bytes() []byte {
|
|
buf := make([]byte, 4)
|
|
b := 0
|
|
|
|
Put16(buf[b:], v.ControlId)
|
|
b += 2
|
|
|
|
Put16(buf[b:], v.Len)
|
|
b += 2
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputDeviceState
|
|
func XinputDeviceStateListBytes(buf []byte, list []XinputDeviceState) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// 'XinputDeviceResolutionState' struct definition
|
|
// Size: (((8 + pad((int(NumValuators) * 4))) + pad((int(NumValuators) * 4))) + pad((int(NumValuators) * 4)))
|
|
type XinputDeviceResolutionState struct {
|
|
ControlId uint16
|
|
Len uint16
|
|
NumValuators uint32
|
|
ResolutionValues []uint32 // size: pad((int(NumValuators) * 4))
|
|
ResolutionMin []uint32 // size: pad((int(NumValuators) * 4))
|
|
ResolutionMax []uint32 // size: pad((int(NumValuators) * 4))
|
|
}
|
|
|
|
// Struct read XinputDeviceResolutionState
|
|
func ReadXinputDeviceResolutionState(buf []byte, v *XinputDeviceResolutionState) int {
|
|
b := 0
|
|
|
|
v.ControlId = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Len = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.NumValuators = Get32(buf[b:])
|
|
b += 4
|
|
|
|
v.ResolutionValues = make([]uint32, v.NumValuators)
|
|
for i := 0; i < int(v.NumValuators); i++ {
|
|
v.ResolutionValues[i] = Get32(buf[b:])
|
|
b += 4
|
|
}
|
|
b = pad(b)
|
|
|
|
v.ResolutionMin = make([]uint32, v.NumValuators)
|
|
for i := 0; i < int(v.NumValuators); i++ {
|
|
v.ResolutionMin[i] = Get32(buf[b:])
|
|
b += 4
|
|
}
|
|
b = pad(b)
|
|
|
|
v.ResolutionMax = make([]uint32, v.NumValuators)
|
|
for i := 0; i < int(v.NumValuators); i++ {
|
|
v.ResolutionMax[i] = Get32(buf[b:])
|
|
b += 4
|
|
}
|
|
b = pad(b)
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputDeviceResolutionState
|
|
func ReadXinputDeviceResolutionStateList(buf []byte, dest []XinputDeviceResolutionState) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputDeviceResolutionState{}
|
|
b += ReadXinputDeviceResolutionState(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputDeviceResolutionState
|
|
func (v XinputDeviceResolutionState) Bytes() []byte {
|
|
buf := make([]byte, (((8 + pad((int(v.NumValuators) * 4))) + pad((int(v.NumValuators) * 4))) + pad((int(v.NumValuators) * 4))))
|
|
b := 0
|
|
|
|
Put16(buf[b:], v.ControlId)
|
|
b += 2
|
|
|
|
Put16(buf[b:], v.Len)
|
|
b += 2
|
|
|
|
Put32(buf[b:], v.NumValuators)
|
|
b += 4
|
|
|
|
for i := 0; i < int(v.NumValuators); i++ {
|
|
Put32(buf[b:], v.ResolutionValues[i])
|
|
b += 4
|
|
}
|
|
b = pad(b)
|
|
|
|
for i := 0; i < int(v.NumValuators); i++ {
|
|
Put32(buf[b:], v.ResolutionMin[i])
|
|
b += 4
|
|
}
|
|
b = pad(b)
|
|
|
|
for i := 0; i < int(v.NumValuators); i++ {
|
|
Put32(buf[b:], v.ResolutionMax[i])
|
|
b += 4
|
|
}
|
|
b = pad(b)
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputDeviceResolutionState
|
|
func XinputDeviceResolutionStateListBytes(buf []byte, list []XinputDeviceResolutionState) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// Struct list size XinputDeviceResolutionState
|
|
func XinputDeviceResolutionStateListSize(list []XinputDeviceResolutionState) int {
|
|
size := 0
|
|
for _, item := range list {
|
|
size += (((8 + pad((int(item.NumValuators) * 4))) + pad((int(item.NumValuators) * 4))) + pad((int(item.NumValuators) * 4)))
|
|
}
|
|
return size
|
|
}
|
|
|
|
// 'XinputDeviceAbsCalibState' struct definition
|
|
// Size: 36
|
|
type XinputDeviceAbsCalibState struct {
|
|
ControlId uint16
|
|
Len uint16
|
|
MinX int32
|
|
MaxX int32
|
|
MinY int32
|
|
MaxY int32
|
|
FlipX uint32
|
|
FlipY uint32
|
|
Rotation uint32
|
|
ButtonThreshold uint32
|
|
}
|
|
|
|
// Struct read XinputDeviceAbsCalibState
|
|
func ReadXinputDeviceAbsCalibState(buf []byte, v *XinputDeviceAbsCalibState) int {
|
|
b := 0
|
|
|
|
v.ControlId = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Len = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.MinX = int32(Get32(buf[b:]))
|
|
b += 4
|
|
|
|
v.MaxX = int32(Get32(buf[b:]))
|
|
b += 4
|
|
|
|
v.MinY = int32(Get32(buf[b:]))
|
|
b += 4
|
|
|
|
v.MaxY = int32(Get32(buf[b:]))
|
|
b += 4
|
|
|
|
v.FlipX = Get32(buf[b:])
|
|
b += 4
|
|
|
|
v.FlipY = Get32(buf[b:])
|
|
b += 4
|
|
|
|
v.Rotation = Get32(buf[b:])
|
|
b += 4
|
|
|
|
v.ButtonThreshold = Get32(buf[b:])
|
|
b += 4
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputDeviceAbsCalibState
|
|
func ReadXinputDeviceAbsCalibStateList(buf []byte, dest []XinputDeviceAbsCalibState) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputDeviceAbsCalibState{}
|
|
b += ReadXinputDeviceAbsCalibState(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputDeviceAbsCalibState
|
|
func (v XinputDeviceAbsCalibState) Bytes() []byte {
|
|
buf := make([]byte, 36)
|
|
b := 0
|
|
|
|
Put16(buf[b:], v.ControlId)
|
|
b += 2
|
|
|
|
Put16(buf[b:], v.Len)
|
|
b += 2
|
|
|
|
Put32(buf[b:], uint32(v.MinX))
|
|
b += 4
|
|
|
|
Put32(buf[b:], uint32(v.MaxX))
|
|
b += 4
|
|
|
|
Put32(buf[b:], uint32(v.MinY))
|
|
b += 4
|
|
|
|
Put32(buf[b:], uint32(v.MaxY))
|
|
b += 4
|
|
|
|
Put32(buf[b:], v.FlipX)
|
|
b += 4
|
|
|
|
Put32(buf[b:], v.FlipY)
|
|
b += 4
|
|
|
|
Put32(buf[b:], v.Rotation)
|
|
b += 4
|
|
|
|
Put32(buf[b:], v.ButtonThreshold)
|
|
b += 4
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputDeviceAbsCalibState
|
|
func XinputDeviceAbsCalibStateListBytes(buf []byte, list []XinputDeviceAbsCalibState) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// 'XinputDeviceAbsAreaState' struct definition
|
|
// Size: 28
|
|
type XinputDeviceAbsAreaState struct {
|
|
ControlId uint16
|
|
Len uint16
|
|
OffsetX uint32
|
|
OffsetY uint32
|
|
Width uint32
|
|
Height uint32
|
|
Screen uint32
|
|
Following uint32
|
|
}
|
|
|
|
// Struct read XinputDeviceAbsAreaState
|
|
func ReadXinputDeviceAbsAreaState(buf []byte, v *XinputDeviceAbsAreaState) int {
|
|
b := 0
|
|
|
|
v.ControlId = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Len = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.OffsetX = Get32(buf[b:])
|
|
b += 4
|
|
|
|
v.OffsetY = Get32(buf[b:])
|
|
b += 4
|
|
|
|
v.Width = Get32(buf[b:])
|
|
b += 4
|
|
|
|
v.Height = Get32(buf[b:])
|
|
b += 4
|
|
|
|
v.Screen = Get32(buf[b:])
|
|
b += 4
|
|
|
|
v.Following = Get32(buf[b:])
|
|
b += 4
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputDeviceAbsAreaState
|
|
func ReadXinputDeviceAbsAreaStateList(buf []byte, dest []XinputDeviceAbsAreaState) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputDeviceAbsAreaState{}
|
|
b += ReadXinputDeviceAbsAreaState(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputDeviceAbsAreaState
|
|
func (v XinputDeviceAbsAreaState) Bytes() []byte {
|
|
buf := make([]byte, 28)
|
|
b := 0
|
|
|
|
Put16(buf[b:], v.ControlId)
|
|
b += 2
|
|
|
|
Put16(buf[b:], v.Len)
|
|
b += 2
|
|
|
|
Put32(buf[b:], v.OffsetX)
|
|
b += 4
|
|
|
|
Put32(buf[b:], v.OffsetY)
|
|
b += 4
|
|
|
|
Put32(buf[b:], v.Width)
|
|
b += 4
|
|
|
|
Put32(buf[b:], v.Height)
|
|
b += 4
|
|
|
|
Put32(buf[b:], v.Screen)
|
|
b += 4
|
|
|
|
Put32(buf[b:], v.Following)
|
|
b += 4
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputDeviceAbsAreaState
|
|
func XinputDeviceAbsAreaStateListBytes(buf []byte, list []XinputDeviceAbsAreaState) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// 'XinputDeviceCoreState' struct definition
|
|
// Size: 8
|
|
type XinputDeviceCoreState struct {
|
|
ControlId uint16
|
|
Len uint16
|
|
Status byte
|
|
Iscore byte
|
|
// padding: 2 bytes
|
|
}
|
|
|
|
// Struct read XinputDeviceCoreState
|
|
func ReadXinputDeviceCoreState(buf []byte, v *XinputDeviceCoreState) int {
|
|
b := 0
|
|
|
|
v.ControlId = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Len = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Status = buf[b]
|
|
b += 1
|
|
|
|
v.Iscore = buf[b]
|
|
b += 1
|
|
|
|
b += 2 // padding
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputDeviceCoreState
|
|
func ReadXinputDeviceCoreStateList(buf []byte, dest []XinputDeviceCoreState) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputDeviceCoreState{}
|
|
b += ReadXinputDeviceCoreState(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputDeviceCoreState
|
|
func (v XinputDeviceCoreState) Bytes() []byte {
|
|
buf := make([]byte, 8)
|
|
b := 0
|
|
|
|
Put16(buf[b:], v.ControlId)
|
|
b += 2
|
|
|
|
Put16(buf[b:], v.Len)
|
|
b += 2
|
|
|
|
buf[b] = v.Status
|
|
b += 1
|
|
|
|
buf[b] = v.Iscore
|
|
b += 1
|
|
|
|
b += 2 // padding
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputDeviceCoreState
|
|
func XinputDeviceCoreStateListBytes(buf []byte, list []XinputDeviceCoreState) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// 'XinputDeviceEnableState' struct definition
|
|
// Size: 8
|
|
type XinputDeviceEnableState struct {
|
|
ControlId uint16
|
|
Len uint16
|
|
Enable byte
|
|
// padding: 3 bytes
|
|
}
|
|
|
|
// Struct read XinputDeviceEnableState
|
|
func ReadXinputDeviceEnableState(buf []byte, v *XinputDeviceEnableState) int {
|
|
b := 0
|
|
|
|
v.ControlId = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Len = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Enable = buf[b]
|
|
b += 1
|
|
|
|
b += 3 // padding
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputDeviceEnableState
|
|
func ReadXinputDeviceEnableStateList(buf []byte, dest []XinputDeviceEnableState) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputDeviceEnableState{}
|
|
b += ReadXinputDeviceEnableState(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputDeviceEnableState
|
|
func (v XinputDeviceEnableState) Bytes() []byte {
|
|
buf := make([]byte, 8)
|
|
b := 0
|
|
|
|
Put16(buf[b:], v.ControlId)
|
|
b += 2
|
|
|
|
Put16(buf[b:], v.Len)
|
|
b += 2
|
|
|
|
buf[b] = v.Enable
|
|
b += 1
|
|
|
|
b += 3 // padding
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputDeviceEnableState
|
|
func XinputDeviceEnableStateListBytes(buf []byte, list []XinputDeviceEnableState) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// 'XinputDeviceCtl' struct definition
|
|
// Size: 4
|
|
type XinputDeviceCtl struct {
|
|
ControlId uint16
|
|
Len uint16
|
|
}
|
|
|
|
// Struct read XinputDeviceCtl
|
|
func ReadXinputDeviceCtl(buf []byte, v *XinputDeviceCtl) int {
|
|
b := 0
|
|
|
|
v.ControlId = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Len = Get16(buf[b:])
|
|
b += 2
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputDeviceCtl
|
|
func ReadXinputDeviceCtlList(buf []byte, dest []XinputDeviceCtl) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputDeviceCtl{}
|
|
b += ReadXinputDeviceCtl(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputDeviceCtl
|
|
func (v XinputDeviceCtl) Bytes() []byte {
|
|
buf := make([]byte, 4)
|
|
b := 0
|
|
|
|
Put16(buf[b:], v.ControlId)
|
|
b += 2
|
|
|
|
Put16(buf[b:], v.Len)
|
|
b += 2
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputDeviceCtl
|
|
func XinputDeviceCtlListBytes(buf []byte, list []XinputDeviceCtl) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// 'XinputDeviceResolutionCtl' struct definition
|
|
// Size: (6 + pad((int(NumValuators) * 4)))
|
|
type XinputDeviceResolutionCtl struct {
|
|
ControlId uint16
|
|
Len uint16
|
|
FirstValuator byte
|
|
NumValuators byte
|
|
ResolutionValues []uint32 // size: pad((int(NumValuators) * 4))
|
|
}
|
|
|
|
// Struct read XinputDeviceResolutionCtl
|
|
func ReadXinputDeviceResolutionCtl(buf []byte, v *XinputDeviceResolutionCtl) int {
|
|
b := 0
|
|
|
|
v.ControlId = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Len = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.FirstValuator = buf[b]
|
|
b += 1
|
|
|
|
v.NumValuators = buf[b]
|
|
b += 1
|
|
|
|
v.ResolutionValues = make([]uint32, v.NumValuators)
|
|
for i := 0; i < int(v.NumValuators); i++ {
|
|
v.ResolutionValues[i] = Get32(buf[b:])
|
|
b += 4
|
|
}
|
|
b = pad(b)
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputDeviceResolutionCtl
|
|
func ReadXinputDeviceResolutionCtlList(buf []byte, dest []XinputDeviceResolutionCtl) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputDeviceResolutionCtl{}
|
|
b += ReadXinputDeviceResolutionCtl(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputDeviceResolutionCtl
|
|
func (v XinputDeviceResolutionCtl) Bytes() []byte {
|
|
buf := make([]byte, (6 + pad((int(v.NumValuators) * 4))))
|
|
b := 0
|
|
|
|
Put16(buf[b:], v.ControlId)
|
|
b += 2
|
|
|
|
Put16(buf[b:], v.Len)
|
|
b += 2
|
|
|
|
buf[b] = v.FirstValuator
|
|
b += 1
|
|
|
|
buf[b] = v.NumValuators
|
|
b += 1
|
|
|
|
for i := 0; i < int(v.NumValuators); i++ {
|
|
Put32(buf[b:], v.ResolutionValues[i])
|
|
b += 4
|
|
}
|
|
b = pad(b)
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputDeviceResolutionCtl
|
|
func XinputDeviceResolutionCtlListBytes(buf []byte, list []XinputDeviceResolutionCtl) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// Struct list size XinputDeviceResolutionCtl
|
|
func XinputDeviceResolutionCtlListSize(list []XinputDeviceResolutionCtl) int {
|
|
size := 0
|
|
for _, item := range list {
|
|
size += (6 + pad((int(item.NumValuators) * 4)))
|
|
}
|
|
return size
|
|
}
|
|
|
|
// 'XinputDeviceAbsCalibCtl' struct definition
|
|
// Size: 36
|
|
type XinputDeviceAbsCalibCtl struct {
|
|
ControlId uint16
|
|
Len uint16
|
|
MinX int32
|
|
MaxX int32
|
|
MinY int32
|
|
MaxY int32
|
|
FlipX uint32
|
|
FlipY uint32
|
|
Rotation uint32
|
|
ButtonThreshold uint32
|
|
}
|
|
|
|
// Struct read XinputDeviceAbsCalibCtl
|
|
func ReadXinputDeviceAbsCalibCtl(buf []byte, v *XinputDeviceAbsCalibCtl) int {
|
|
b := 0
|
|
|
|
v.ControlId = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Len = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.MinX = int32(Get32(buf[b:]))
|
|
b += 4
|
|
|
|
v.MaxX = int32(Get32(buf[b:]))
|
|
b += 4
|
|
|
|
v.MinY = int32(Get32(buf[b:]))
|
|
b += 4
|
|
|
|
v.MaxY = int32(Get32(buf[b:]))
|
|
b += 4
|
|
|
|
v.FlipX = Get32(buf[b:])
|
|
b += 4
|
|
|
|
v.FlipY = Get32(buf[b:])
|
|
b += 4
|
|
|
|
v.Rotation = Get32(buf[b:])
|
|
b += 4
|
|
|
|
v.ButtonThreshold = Get32(buf[b:])
|
|
b += 4
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputDeviceAbsCalibCtl
|
|
func ReadXinputDeviceAbsCalibCtlList(buf []byte, dest []XinputDeviceAbsCalibCtl) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputDeviceAbsCalibCtl{}
|
|
b += ReadXinputDeviceAbsCalibCtl(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputDeviceAbsCalibCtl
|
|
func (v XinputDeviceAbsCalibCtl) Bytes() []byte {
|
|
buf := make([]byte, 36)
|
|
b := 0
|
|
|
|
Put16(buf[b:], v.ControlId)
|
|
b += 2
|
|
|
|
Put16(buf[b:], v.Len)
|
|
b += 2
|
|
|
|
Put32(buf[b:], uint32(v.MinX))
|
|
b += 4
|
|
|
|
Put32(buf[b:], uint32(v.MaxX))
|
|
b += 4
|
|
|
|
Put32(buf[b:], uint32(v.MinY))
|
|
b += 4
|
|
|
|
Put32(buf[b:], uint32(v.MaxY))
|
|
b += 4
|
|
|
|
Put32(buf[b:], v.FlipX)
|
|
b += 4
|
|
|
|
Put32(buf[b:], v.FlipY)
|
|
b += 4
|
|
|
|
Put32(buf[b:], v.Rotation)
|
|
b += 4
|
|
|
|
Put32(buf[b:], v.ButtonThreshold)
|
|
b += 4
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputDeviceAbsCalibCtl
|
|
func XinputDeviceAbsCalibCtlListBytes(buf []byte, list []XinputDeviceAbsCalibCtl) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// 'XinputDeviceAbsAreaCtrl' struct definition
|
|
// Size: 28
|
|
type XinputDeviceAbsAreaCtrl struct {
|
|
ControlId uint16
|
|
Len uint16
|
|
OffsetX uint32
|
|
OffsetY uint32
|
|
Width int32
|
|
Height int32
|
|
Screen int32
|
|
Following uint32
|
|
}
|
|
|
|
// Struct read XinputDeviceAbsAreaCtrl
|
|
func ReadXinputDeviceAbsAreaCtrl(buf []byte, v *XinputDeviceAbsAreaCtrl) int {
|
|
b := 0
|
|
|
|
v.ControlId = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Len = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.OffsetX = Get32(buf[b:])
|
|
b += 4
|
|
|
|
v.OffsetY = Get32(buf[b:])
|
|
b += 4
|
|
|
|
v.Width = int32(Get32(buf[b:]))
|
|
b += 4
|
|
|
|
v.Height = int32(Get32(buf[b:]))
|
|
b += 4
|
|
|
|
v.Screen = int32(Get32(buf[b:]))
|
|
b += 4
|
|
|
|
v.Following = Get32(buf[b:])
|
|
b += 4
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputDeviceAbsAreaCtrl
|
|
func ReadXinputDeviceAbsAreaCtrlList(buf []byte, dest []XinputDeviceAbsAreaCtrl) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputDeviceAbsAreaCtrl{}
|
|
b += ReadXinputDeviceAbsAreaCtrl(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputDeviceAbsAreaCtrl
|
|
func (v XinputDeviceAbsAreaCtrl) Bytes() []byte {
|
|
buf := make([]byte, 28)
|
|
b := 0
|
|
|
|
Put16(buf[b:], v.ControlId)
|
|
b += 2
|
|
|
|
Put16(buf[b:], v.Len)
|
|
b += 2
|
|
|
|
Put32(buf[b:], v.OffsetX)
|
|
b += 4
|
|
|
|
Put32(buf[b:], v.OffsetY)
|
|
b += 4
|
|
|
|
Put32(buf[b:], uint32(v.Width))
|
|
b += 4
|
|
|
|
Put32(buf[b:], uint32(v.Height))
|
|
b += 4
|
|
|
|
Put32(buf[b:], uint32(v.Screen))
|
|
b += 4
|
|
|
|
Put32(buf[b:], v.Following)
|
|
b += 4
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputDeviceAbsAreaCtrl
|
|
func XinputDeviceAbsAreaCtrlListBytes(buf []byte, list []XinputDeviceAbsAreaCtrl) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// 'XinputDeviceCoreCtrl' struct definition
|
|
// Size: 8
|
|
type XinputDeviceCoreCtrl struct {
|
|
ControlId uint16
|
|
Len uint16
|
|
Status byte
|
|
// padding: 3 bytes
|
|
}
|
|
|
|
// Struct read XinputDeviceCoreCtrl
|
|
func ReadXinputDeviceCoreCtrl(buf []byte, v *XinputDeviceCoreCtrl) int {
|
|
b := 0
|
|
|
|
v.ControlId = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Len = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Status = buf[b]
|
|
b += 1
|
|
|
|
b += 3 // padding
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputDeviceCoreCtrl
|
|
func ReadXinputDeviceCoreCtrlList(buf []byte, dest []XinputDeviceCoreCtrl) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputDeviceCoreCtrl{}
|
|
b += ReadXinputDeviceCoreCtrl(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputDeviceCoreCtrl
|
|
func (v XinputDeviceCoreCtrl) Bytes() []byte {
|
|
buf := make([]byte, 8)
|
|
b := 0
|
|
|
|
Put16(buf[b:], v.ControlId)
|
|
b += 2
|
|
|
|
Put16(buf[b:], v.Len)
|
|
b += 2
|
|
|
|
buf[b] = v.Status
|
|
b += 1
|
|
|
|
b += 3 // padding
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputDeviceCoreCtrl
|
|
func XinputDeviceCoreCtrlListBytes(buf []byte, list []XinputDeviceCoreCtrl) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// 'XinputDeviceEnableCtrl' struct definition
|
|
// Size: 8
|
|
type XinputDeviceEnableCtrl struct {
|
|
ControlId uint16
|
|
Len uint16
|
|
Enable byte
|
|
// padding: 3 bytes
|
|
}
|
|
|
|
// Struct read XinputDeviceEnableCtrl
|
|
func ReadXinputDeviceEnableCtrl(buf []byte, v *XinputDeviceEnableCtrl) int {
|
|
b := 0
|
|
|
|
v.ControlId = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Len = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Enable = buf[b]
|
|
b += 1
|
|
|
|
b += 3 // padding
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XinputDeviceEnableCtrl
|
|
func ReadXinputDeviceEnableCtrlList(buf []byte, dest []XinputDeviceEnableCtrl) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XinputDeviceEnableCtrl{}
|
|
b += ReadXinputDeviceEnableCtrl(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XinputDeviceEnableCtrl
|
|
func (v XinputDeviceEnableCtrl) Bytes() []byte {
|
|
buf := make([]byte, 8)
|
|
b := 0
|
|
|
|
Put16(buf[b:], v.ControlId)
|
|
b += 2
|
|
|
|
Put16(buf[b:], v.Len)
|
|
b += 2
|
|
|
|
buf[b] = v.Enable
|
|
b += 1
|
|
|
|
b += 3 // padding
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XinputDeviceEnableCtrl
|
|
func XinputDeviceEnableCtrlListBytes(buf []byte, list []XinputDeviceEnableCtrl) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// Event definition XinputDeviceValuator (0)
|
|
// Size: 32
|
|
|
|
const XinputDeviceValuator = 0
|
|
|
|
type XinputDeviceValuatorEvent struct {
|
|
Sequence uint16
|
|
DeviceId byte
|
|
DeviceState uint16
|
|
NumValuators byte
|
|
FirstValuator byte
|
|
Valuators []int32 // size: 24
|
|
}
|
|
|
|
// Event read XinputDeviceValuator
|
|
func NewXinputDeviceValuatorEvent(buf []byte) Event {
|
|
v := XinputDeviceValuatorEvent{}
|
|
b := 1 // don't read event number
|
|
|
|
v.DeviceId = buf[b]
|
|
b += 1
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.DeviceState = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.NumValuators = buf[b]
|
|
b += 1
|
|
|
|
v.FirstValuator = buf[b]
|
|
b += 1
|
|
|
|
v.Valuators = make([]int32, 6)
|
|
for i := 0; i < int(6); i++ {
|
|
v.Valuators[i] = int32(Get32(buf[b:]))
|
|
b += 4
|
|
}
|
|
b = pad(b)
|
|
|
|
return v
|
|
}
|
|
|
|
// Event write XinputDeviceValuator
|
|
func (v XinputDeviceValuatorEvent) Bytes() []byte {
|
|
buf := make([]byte, 32)
|
|
b := 0
|
|
|
|
// write event number
|
|
buf[b] = 0
|
|
b += 1
|
|
|
|
buf[b] = v.DeviceId
|
|
b += 1
|
|
|
|
b += 2 // skip sequence number
|
|
|
|
Put16(buf[b:], v.DeviceState)
|
|
b += 2
|
|
|
|
buf[b] = v.NumValuators
|
|
b += 1
|
|
|
|
buf[b] = v.FirstValuator
|
|
b += 1
|
|
|
|
for i := 0; i < int(6); i++ {
|
|
Put32(buf[b:], uint32(v.Valuators[i]))
|
|
b += 4
|
|
}
|
|
b = pad(b)
|
|
|
|
return buf
|
|
}
|
|
|
|
func (v XinputDeviceValuatorEvent) ImplementsEvent() {}
|
|
|
|
func (v XinputDeviceValuatorEvent) SequenceId() uint16 {
|
|
return v.Sequence
|
|
}
|
|
|
|
func (v XinputDeviceValuatorEvent) String() string {
|
|
fieldVals := make([]string, 0, 5)
|
|
fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
|
|
fieldVals = append(fieldVals, sprintf("DeviceId: %d", v.DeviceId))
|
|
fieldVals = append(fieldVals, sprintf("DeviceState: %d", v.DeviceState))
|
|
fieldVals = append(fieldVals, sprintf("NumValuators: %d", v.NumValuators))
|
|
fieldVals = append(fieldVals, sprintf("FirstValuator: %d", v.FirstValuator))
|
|
return "XinputDeviceValuator {" + stringsJoin(fieldVals, ", ") + "}"
|
|
}
|
|
|
|
func init() {
|
|
newExtEventFuncs["XInputExtension"][0] = NewXinputDeviceValuatorEvent
|
|
}
|
|
|
|
// Event definition XinputDeviceKeyPress (1)
|
|
// Size: 32
|
|
|
|
const XinputDeviceKeyPress = 1
|
|
|
|
type XinputDeviceKeyPressEvent struct {
|
|
Sequence uint16
|
|
Detail byte
|
|
Time Timestamp
|
|
Root Id
|
|
Event Id
|
|
Child Id
|
|
RootX int16
|
|
RootY int16
|
|
EventX int16
|
|
EventY int16
|
|
State uint16
|
|
SameScreen bool
|
|
DeviceId byte
|
|
}
|
|
|
|
// Event read XinputDeviceKeyPress
|
|
func NewXinputDeviceKeyPressEvent(buf []byte) Event {
|
|
v := XinputDeviceKeyPressEvent{}
|
|
b := 1 // don't read event number
|
|
|
|
v.Detail = buf[b]
|
|
b += 1
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Time = Timestamp(Get32(buf[b:]))
|
|
b += 4
|
|
|
|
v.Root = Id(Get32(buf[b:]))
|
|
b += 4
|
|
|
|
v.Event = Id(Get32(buf[b:]))
|
|
b += 4
|
|
|
|
v.Child = Id(Get32(buf[b:]))
|
|
b += 4
|
|
|
|
v.RootX = int16(Get16(buf[b:]))
|
|
b += 2
|
|
|
|
v.RootY = int16(Get16(buf[b:]))
|
|
b += 2
|
|
|
|
v.EventX = int16(Get16(buf[b:]))
|
|
b += 2
|
|
|
|
v.EventY = int16(Get16(buf[b:]))
|
|
b += 2
|
|
|
|
v.State = Get16(buf[b:])
|
|
b += 2
|
|
|
|
if buf[b] == 1 {
|
|
v.SameScreen = true
|
|
} else {
|
|
v.SameScreen = false
|
|
}
|
|
b += 1
|
|
|
|
v.DeviceId = buf[b]
|
|
b += 1
|
|
|
|
return v
|
|
}
|
|
|
|
// Event write XinputDeviceKeyPress
|
|
func (v XinputDeviceKeyPressEvent) Bytes() []byte {
|
|
buf := make([]byte, 32)
|
|
b := 0
|
|
|
|
// write event number
|
|
buf[b] = 1
|
|
b += 1
|
|
|
|
buf[b] = v.Detail
|
|
b += 1
|
|
|
|
b += 2 // skip sequence number
|
|
|
|
Put32(buf[b:], uint32(v.Time))
|
|
b += 4
|
|
|
|
Put32(buf[b:], uint32(v.Root))
|
|
b += 4
|
|
|
|
Put32(buf[b:], uint32(v.Event))
|
|
b += 4
|
|
|
|
Put32(buf[b:], uint32(v.Child))
|
|
b += 4
|
|
|
|
Put16(buf[b:], uint16(v.RootX))
|
|
b += 2
|
|
|
|
Put16(buf[b:], uint16(v.RootY))
|
|
b += 2
|
|
|
|
Put16(buf[b:], uint16(v.EventX))
|
|
b += 2
|
|
|
|
Put16(buf[b:], uint16(v.EventY))
|
|
b += 2
|
|
|
|
Put16(buf[b:], v.State)
|
|
b += 2
|
|
|
|
if v.SameScreen {
|
|
buf[b] = 1
|
|
} else {
|
|
buf[b] = 0
|
|
}
|
|
b += 1
|
|
|
|
buf[b] = v.DeviceId
|
|
b += 1
|
|
|
|
return buf
|
|
}
|
|
|
|
func (v XinputDeviceKeyPressEvent) ImplementsEvent() {}
|
|
|
|
func (v XinputDeviceKeyPressEvent) SequenceId() uint16 {
|
|
return v.Sequence
|
|
}
|
|
|
|
func (v XinputDeviceKeyPressEvent) String() string {
|
|
fieldVals := make([]string, 0, 12)
|
|
fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
|
|
fieldVals = append(fieldVals, sprintf("Detail: %d", v.Detail))
|
|
fieldVals = append(fieldVals, sprintf("Time: %d", v.Time))
|
|
fieldVals = append(fieldVals, sprintf("Root: %d", v.Root))
|
|
fieldVals = append(fieldVals, sprintf("Event: %d", v.Event))
|
|
fieldVals = append(fieldVals, sprintf("Child: %d", v.Child))
|
|
fieldVals = append(fieldVals, sprintf("RootX: %d", v.RootX))
|
|
fieldVals = append(fieldVals, sprintf("RootY: %d", v.RootY))
|
|
fieldVals = append(fieldVals, sprintf("EventX: %d", v.EventX))
|
|
fieldVals = append(fieldVals, sprintf("EventY: %d", v.EventY))
|
|
fieldVals = append(fieldVals, sprintf("State: %d", v.State))
|
|
fieldVals = append(fieldVals, sprintf("SameScreen: %t", v.SameScreen))
|
|
fieldVals = append(fieldVals, sprintf("DeviceId: %d", v.DeviceId))
|
|
return "XinputDeviceKeyPress {" + stringsJoin(fieldVals, ", ") + "}"
|
|
}
|
|
|
|
func init() {
|
|
newExtEventFuncs["XInputExtension"][1] = NewXinputDeviceKeyPressEvent
|
|
}
|
|
|
|
// Event definition XinputFocusIn (6)
|
|
// Size: 32
|
|
|
|
const XinputFocusIn = 6
|
|
|
|
type XinputFocusInEvent struct {
|
|
Sequence uint16
|
|
Detail byte
|
|
Time Timestamp
|
|
Window Id
|
|
Mode byte
|
|
DeviceId byte
|
|
// padding: 18 bytes
|
|
}
|
|
|
|
// Event read XinputFocusIn
|
|
func NewXinputFocusInEvent(buf []byte) Event {
|
|
v := XinputFocusInEvent{}
|
|
b := 1 // don't read event number
|
|
|
|
v.Detail = buf[b]
|
|
b += 1
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Time = Timestamp(Get32(buf[b:]))
|
|
b += 4
|
|
|
|
v.Window = Id(Get32(buf[b:]))
|
|
b += 4
|
|
|
|
v.Mode = buf[b]
|
|
b += 1
|
|
|
|
v.DeviceId = buf[b]
|
|
b += 1
|
|
|
|
b += 18 // padding
|
|
|
|
return v
|
|
}
|
|
|
|
// Event write XinputFocusIn
|
|
func (v XinputFocusInEvent) Bytes() []byte {
|
|
buf := make([]byte, 32)
|
|
b := 0
|
|
|
|
// write event number
|
|
buf[b] = 6
|
|
b += 1
|
|
|
|
buf[b] = v.Detail
|
|
b += 1
|
|
|
|
b += 2 // skip sequence number
|
|
|
|
Put32(buf[b:], uint32(v.Time))
|
|
b += 4
|
|
|
|
Put32(buf[b:], uint32(v.Window))
|
|
b += 4
|
|
|
|
buf[b] = v.Mode
|
|
b += 1
|
|
|
|
buf[b] = v.DeviceId
|
|
b += 1
|
|
|
|
b += 18 // padding
|
|
|
|
return buf
|
|
}
|
|
|
|
func (v XinputFocusInEvent) ImplementsEvent() {}
|
|
|
|
func (v XinputFocusInEvent) SequenceId() uint16 {
|
|
return v.Sequence
|
|
}
|
|
|
|
func (v XinputFocusInEvent) String() string {
|
|
fieldVals := make([]string, 0, 6)
|
|
fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
|
|
fieldVals = append(fieldVals, sprintf("Detail: %d", v.Detail))
|
|
fieldVals = append(fieldVals, sprintf("Time: %d", v.Time))
|
|
fieldVals = append(fieldVals, sprintf("Window: %d", v.Window))
|
|
fieldVals = append(fieldVals, sprintf("Mode: %d", v.Mode))
|
|
fieldVals = append(fieldVals, sprintf("DeviceId: %d", v.DeviceId))
|
|
return "XinputFocusIn {" + stringsJoin(fieldVals, ", ") + "}"
|
|
}
|
|
|
|
func init() {
|
|
newExtEventFuncs["XInputExtension"][6] = NewXinputFocusInEvent
|
|
}
|
|
|
|
// Event definition XinputDeviceStateNotify (10)
|
|
// Size: 32
|
|
|
|
const XinputDeviceStateNotify = 10
|
|
|
|
type XinputDeviceStateNotifyEvent struct {
|
|
Sequence uint16
|
|
DeviceId byte
|
|
Time Timestamp
|
|
NumKeys byte
|
|
NumButtons byte
|
|
NumValuators byte
|
|
ClassesReported byte
|
|
Buttons []byte // size: 4
|
|
Keys []byte // size: 4
|
|
Valuators []uint32 // size: 12
|
|
}
|
|
|
|
// Event read XinputDeviceStateNotify
|
|
func NewXinputDeviceStateNotifyEvent(buf []byte) Event {
|
|
v := XinputDeviceStateNotifyEvent{}
|
|
b := 1 // don't read event number
|
|
|
|
v.DeviceId = buf[b]
|
|
b += 1
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Time = Timestamp(Get32(buf[b:]))
|
|
b += 4
|
|
|
|
v.NumKeys = buf[b]
|
|
b += 1
|
|
|
|
v.NumButtons = buf[b]
|
|
b += 1
|
|
|
|
v.NumValuators = buf[b]
|
|
b += 1
|
|
|
|
v.ClassesReported = buf[b]
|
|
b += 1
|
|
|
|
v.Buttons = make([]byte, 4)
|
|
copy(v.Buttons[:4], buf[b:])
|
|
b += pad(int(4))
|
|
|
|
v.Keys = make([]byte, 4)
|
|
copy(v.Keys[:4], buf[b:])
|
|
b += pad(int(4))
|
|
|
|
v.Valuators = make([]uint32, 3)
|
|
for i := 0; i < int(3); i++ {
|
|
v.Valuators[i] = Get32(buf[b:])
|
|
b += 4
|
|
}
|
|
b = pad(b)
|
|
|
|
return v
|
|
}
|
|
|
|
// Event write XinputDeviceStateNotify
|
|
func (v XinputDeviceStateNotifyEvent) Bytes() []byte {
|
|
buf := make([]byte, 32)
|
|
b := 0
|
|
|
|
// write event number
|
|
buf[b] = 10
|
|
b += 1
|
|
|
|
buf[b] = v.DeviceId
|
|
b += 1
|
|
|
|
b += 2 // skip sequence number
|
|
|
|
Put32(buf[b:], uint32(v.Time))
|
|
b += 4
|
|
|
|
buf[b] = v.NumKeys
|
|
b += 1
|
|
|
|
buf[b] = v.NumButtons
|
|
b += 1
|
|
|
|
buf[b] = v.NumValuators
|
|
b += 1
|
|
|
|
buf[b] = v.ClassesReported
|
|
b += 1
|
|
|
|
copy(buf[b:], v.Buttons[:4])
|
|
b += pad(int(4))
|
|
|
|
copy(buf[b:], v.Keys[:4])
|
|
b += pad(int(4))
|
|
|
|
for i := 0; i < int(3); i++ {
|
|
Put32(buf[b:], v.Valuators[i])
|
|
b += 4
|
|
}
|
|
b = pad(b)
|
|
|
|
return buf
|
|
}
|
|
|
|
func (v XinputDeviceStateNotifyEvent) ImplementsEvent() {}
|
|
|
|
func (v XinputDeviceStateNotifyEvent) SequenceId() uint16 {
|
|
return v.Sequence
|
|
}
|
|
|
|
func (v XinputDeviceStateNotifyEvent) String() string {
|
|
fieldVals := make([]string, 0, 9)
|
|
fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
|
|
fieldVals = append(fieldVals, sprintf("DeviceId: %d", v.DeviceId))
|
|
fieldVals = append(fieldVals, sprintf("Time: %d", v.Time))
|
|
fieldVals = append(fieldVals, sprintf("NumKeys: %d", v.NumKeys))
|
|
fieldVals = append(fieldVals, sprintf("NumButtons: %d", v.NumButtons))
|
|
fieldVals = append(fieldVals, sprintf("NumValuators: %d", v.NumValuators))
|
|
fieldVals = append(fieldVals, sprintf("ClassesReported: %d", v.ClassesReported))
|
|
return "XinputDeviceStateNotify {" + stringsJoin(fieldVals, ", ") + "}"
|
|
}
|
|
|
|
func init() {
|
|
newExtEventFuncs["XInputExtension"][10] = NewXinputDeviceStateNotifyEvent
|
|
}
|
|
|
|
// Event definition XinputDeviceMappingNotify (11)
|
|
// Size: 32
|
|
|
|
const XinputDeviceMappingNotify = 11
|
|
|
|
type XinputDeviceMappingNotifyEvent struct {
|
|
Sequence uint16
|
|
DeviceId byte
|
|
Request byte
|
|
FirstKeycode XinputKeyCode
|
|
Count byte
|
|
// padding: 1 bytes
|
|
Time Timestamp
|
|
// padding: 20 bytes
|
|
}
|
|
|
|
// Event read XinputDeviceMappingNotify
|
|
func NewXinputDeviceMappingNotifyEvent(buf []byte) Event {
|
|
v := XinputDeviceMappingNotifyEvent{}
|
|
b := 1 // don't read event number
|
|
|
|
v.DeviceId = buf[b]
|
|
b += 1
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Request = buf[b]
|
|
b += 1
|
|
|
|
v.FirstKeycode = XinputKeyCode(buf[b])
|
|
b += 1
|
|
|
|
v.Count = buf[b]
|
|
b += 1
|
|
|
|
b += 1 // padding
|
|
|
|
v.Time = Timestamp(Get32(buf[b:]))
|
|
b += 4
|
|
|
|
b += 20 // padding
|
|
|
|
return v
|
|
}
|
|
|
|
// Event write XinputDeviceMappingNotify
|
|
func (v XinputDeviceMappingNotifyEvent) Bytes() []byte {
|
|
buf := make([]byte, 32)
|
|
b := 0
|
|
|
|
// write event number
|
|
buf[b] = 11
|
|
b += 1
|
|
|
|
buf[b] = v.DeviceId
|
|
b += 1
|
|
|
|
b += 2 // skip sequence number
|
|
|
|
buf[b] = v.Request
|
|
b += 1
|
|
|
|
buf[b] = byte(v.FirstKeycode)
|
|
b += 1
|
|
|
|
buf[b] = v.Count
|
|
b += 1
|
|
|
|
b += 1 // padding
|
|
|
|
Put32(buf[b:], uint32(v.Time))
|
|
b += 4
|
|
|
|
b += 20 // padding
|
|
|
|
return buf
|
|
}
|
|
|
|
func (v XinputDeviceMappingNotifyEvent) ImplementsEvent() {}
|
|
|
|
func (v XinputDeviceMappingNotifyEvent) SequenceId() uint16 {
|
|
return v.Sequence
|
|
}
|
|
|
|
func (v XinputDeviceMappingNotifyEvent) String() string {
|
|
fieldVals := make([]string, 0, 7)
|
|
fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
|
|
fieldVals = append(fieldVals, sprintf("DeviceId: %d", v.DeviceId))
|
|
fieldVals = append(fieldVals, sprintf("Request: %d", v.Request))
|
|
fieldVals = append(fieldVals, sprintf("FirstKeycode: %d", v.FirstKeycode))
|
|
fieldVals = append(fieldVals, sprintf("Count: %d", v.Count))
|
|
fieldVals = append(fieldVals, sprintf("Time: %d", v.Time))
|
|
return "XinputDeviceMappingNotify {" + stringsJoin(fieldVals, ", ") + "}"
|
|
}
|
|
|
|
func init() {
|
|
newExtEventFuncs["XInputExtension"][11] = NewXinputDeviceMappingNotifyEvent
|
|
}
|
|
|
|
// Event definition XinputChangeDeviceNotify (12)
|
|
// Size: 32
|
|
|
|
const XinputChangeDeviceNotify = 12
|
|
|
|
type XinputChangeDeviceNotifyEvent struct {
|
|
Sequence uint16
|
|
DeviceId byte
|
|
Time Timestamp
|
|
Request byte
|
|
// padding: 23 bytes
|
|
}
|
|
|
|
// Event read XinputChangeDeviceNotify
|
|
func NewXinputChangeDeviceNotifyEvent(buf []byte) Event {
|
|
v := XinputChangeDeviceNotifyEvent{}
|
|
b := 1 // don't read event number
|
|
|
|
v.DeviceId = buf[b]
|
|
b += 1
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Time = Timestamp(Get32(buf[b:]))
|
|
b += 4
|
|
|
|
v.Request = buf[b]
|
|
b += 1
|
|
|
|
b += 23 // padding
|
|
|
|
return v
|
|
}
|
|
|
|
// Event write XinputChangeDeviceNotify
|
|
func (v XinputChangeDeviceNotifyEvent) Bytes() []byte {
|
|
buf := make([]byte, 32)
|
|
b := 0
|
|
|
|
// write event number
|
|
buf[b] = 12
|
|
b += 1
|
|
|
|
buf[b] = v.DeviceId
|
|
b += 1
|
|
|
|
b += 2 // skip sequence number
|
|
|
|
Put32(buf[b:], uint32(v.Time))
|
|
b += 4
|
|
|
|
buf[b] = v.Request
|
|
b += 1
|
|
|
|
b += 23 // padding
|
|
|
|
return buf
|
|
}
|
|
|
|
func (v XinputChangeDeviceNotifyEvent) ImplementsEvent() {}
|
|
|
|
func (v XinputChangeDeviceNotifyEvent) SequenceId() uint16 {
|
|
return v.Sequence
|
|
}
|
|
|
|
func (v XinputChangeDeviceNotifyEvent) String() string {
|
|
fieldVals := make([]string, 0, 4)
|
|
fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
|
|
fieldVals = append(fieldVals, sprintf("DeviceId: %d", v.DeviceId))
|
|
fieldVals = append(fieldVals, sprintf("Time: %d", v.Time))
|
|
fieldVals = append(fieldVals, sprintf("Request: %d", v.Request))
|
|
return "XinputChangeDeviceNotify {" + stringsJoin(fieldVals, ", ") + "}"
|
|
}
|
|
|
|
func init() {
|
|
newExtEventFuncs["XInputExtension"][12] = NewXinputChangeDeviceNotifyEvent
|
|
}
|
|
|
|
// Event definition XinputDeviceKeyStateNotify (13)
|
|
// Size: 32
|
|
|
|
const XinputDeviceKeyStateNotify = 13
|
|
|
|
type XinputDeviceKeyStateNotifyEvent struct {
|
|
Sequence uint16
|
|
DeviceId byte
|
|
Keys []byte // size: 28
|
|
}
|
|
|
|
// Event read XinputDeviceKeyStateNotify
|
|
func NewXinputDeviceKeyStateNotifyEvent(buf []byte) Event {
|
|
v := XinputDeviceKeyStateNotifyEvent{}
|
|
b := 1 // don't read event number
|
|
|
|
v.DeviceId = buf[b]
|
|
b += 1
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Keys = make([]byte, 28)
|
|
copy(v.Keys[:28], buf[b:])
|
|
b += pad(int(28))
|
|
|
|
return v
|
|
}
|
|
|
|
// Event write XinputDeviceKeyStateNotify
|
|
func (v XinputDeviceKeyStateNotifyEvent) Bytes() []byte {
|
|
buf := make([]byte, 32)
|
|
b := 0
|
|
|
|
// write event number
|
|
buf[b] = 13
|
|
b += 1
|
|
|
|
buf[b] = v.DeviceId
|
|
b += 1
|
|
|
|
b += 2 // skip sequence number
|
|
|
|
copy(buf[b:], v.Keys[:28])
|
|
b += pad(int(28))
|
|
|
|
return buf
|
|
}
|
|
|
|
func (v XinputDeviceKeyStateNotifyEvent) ImplementsEvent() {}
|
|
|
|
func (v XinputDeviceKeyStateNotifyEvent) SequenceId() uint16 {
|
|
return v.Sequence
|
|
}
|
|
|
|
func (v XinputDeviceKeyStateNotifyEvent) String() string {
|
|
fieldVals := make([]string, 0, 2)
|
|
fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
|
|
fieldVals = append(fieldVals, sprintf("DeviceId: %d", v.DeviceId))
|
|
return "XinputDeviceKeyStateNotify {" + stringsJoin(fieldVals, ", ") + "}"
|
|
}
|
|
|
|
func init() {
|
|
newExtEventFuncs["XInputExtension"][13] = NewXinputDeviceKeyStateNotifyEvent
|
|
}
|
|
|
|
// Event definition XinputDeviceButtonStateNotify (14)
|
|
// Size: 32
|
|
|
|
const XinputDeviceButtonStateNotify = 14
|
|
|
|
type XinputDeviceButtonStateNotifyEvent struct {
|
|
Sequence uint16
|
|
DeviceId byte
|
|
Buttons []byte // size: 28
|
|
}
|
|
|
|
// Event read XinputDeviceButtonStateNotify
|
|
func NewXinputDeviceButtonStateNotifyEvent(buf []byte) Event {
|
|
v := XinputDeviceButtonStateNotifyEvent{}
|
|
b := 1 // don't read event number
|
|
|
|
v.DeviceId = buf[b]
|
|
b += 1
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Buttons = make([]byte, 28)
|
|
copy(v.Buttons[:28], buf[b:])
|
|
b += pad(int(28))
|
|
|
|
return v
|
|
}
|
|
|
|
// Event write XinputDeviceButtonStateNotify
|
|
func (v XinputDeviceButtonStateNotifyEvent) Bytes() []byte {
|
|
buf := make([]byte, 32)
|
|
b := 0
|
|
|
|
// write event number
|
|
buf[b] = 14
|
|
b += 1
|
|
|
|
buf[b] = v.DeviceId
|
|
b += 1
|
|
|
|
b += 2 // skip sequence number
|
|
|
|
copy(buf[b:], v.Buttons[:28])
|
|
b += pad(int(28))
|
|
|
|
return buf
|
|
}
|
|
|
|
func (v XinputDeviceButtonStateNotifyEvent) ImplementsEvent() {}
|
|
|
|
func (v XinputDeviceButtonStateNotifyEvent) SequenceId() uint16 {
|
|
return v.Sequence
|
|
}
|
|
|
|
func (v XinputDeviceButtonStateNotifyEvent) String() string {
|
|
fieldVals := make([]string, 0, 2)
|
|
fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
|
|
fieldVals = append(fieldVals, sprintf("DeviceId: %d", v.DeviceId))
|
|
return "XinputDeviceButtonStateNotify {" + stringsJoin(fieldVals, ", ") + "}"
|
|
}
|
|
|
|
func init() {
|
|
newExtEventFuncs["XInputExtension"][14] = NewXinputDeviceButtonStateNotifyEvent
|
|
}
|
|
|
|
// Event definition XinputDevicePresenceNotify (15)
|
|
// Size: 32
|
|
|
|
const XinputDevicePresenceNotify = 15
|
|
|
|
type XinputDevicePresenceNotifyEvent struct {
|
|
Sequence uint16
|
|
// padding: 1 bytes
|
|
Time Timestamp
|
|
Devchange byte
|
|
DeviceId byte
|
|
Control uint16
|
|
// padding: 20 bytes
|
|
}
|
|
|
|
// Event read XinputDevicePresenceNotify
|
|
func NewXinputDevicePresenceNotifyEvent(buf []byte) Event {
|
|
v := XinputDevicePresenceNotifyEvent{}
|
|
b := 1 // don't read event number
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Time = Timestamp(Get32(buf[b:]))
|
|
b += 4
|
|
|
|
v.Devchange = buf[b]
|
|
b += 1
|
|
|
|
v.DeviceId = buf[b]
|
|
b += 1
|
|
|
|
v.Control = Get16(buf[b:])
|
|
b += 2
|
|
|
|
b += 20 // padding
|
|
|
|
return v
|
|
}
|
|
|
|
// Event write XinputDevicePresenceNotify
|
|
func (v XinputDevicePresenceNotifyEvent) Bytes() []byte {
|
|
buf := make([]byte, 32)
|
|
b := 0
|
|
|
|
// write event number
|
|
buf[b] = 15
|
|
b += 1
|
|
|
|
b += 1 // padding
|
|
|
|
b += 2 // skip sequence number
|
|
|
|
Put32(buf[b:], uint32(v.Time))
|
|
b += 4
|
|
|
|
buf[b] = v.Devchange
|
|
b += 1
|
|
|
|
buf[b] = v.DeviceId
|
|
b += 1
|
|
|
|
Put16(buf[b:], v.Control)
|
|
b += 2
|
|
|
|
b += 20 // padding
|
|
|
|
return buf
|
|
}
|
|
|
|
func (v XinputDevicePresenceNotifyEvent) ImplementsEvent() {}
|
|
|
|
func (v XinputDevicePresenceNotifyEvent) SequenceId() uint16 {
|
|
return v.Sequence
|
|
}
|
|
|
|
func (v XinputDevicePresenceNotifyEvent) String() string {
|
|
fieldVals := make([]string, 0, 6)
|
|
fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
|
|
fieldVals = append(fieldVals, sprintf("Time: %d", v.Time))
|
|
fieldVals = append(fieldVals, sprintf("Devchange: %d", v.Devchange))
|
|
fieldVals = append(fieldVals, sprintf("DeviceId: %d", v.DeviceId))
|
|
fieldVals = append(fieldVals, sprintf("Control: %d", v.Control))
|
|
return "XinputDevicePresenceNotify {" + stringsJoin(fieldVals, ", ") + "}"
|
|
}
|
|
|
|
func init() {
|
|
newExtEventFuncs["XInputExtension"][15] = NewXinputDevicePresenceNotifyEvent
|
|
}
|
|
|
|
// EventCopy definition XinputDeviceKeyRelease (2)
|
|
|
|
const XinputDeviceKeyRelease = 2
|
|
|
|
type XinputDeviceKeyReleaseEvent XinputDeviceKeyPressEvent
|
|
|
|
func NewXinputDeviceKeyReleaseEvent(buf []byte) Event {
|
|
return XinputDeviceKeyReleaseEvent(NewXinputDeviceKeyPressEvent(buf).(XinputDeviceKeyPressEvent))
|
|
}
|
|
|
|
func (v XinputDeviceKeyReleaseEvent) Bytes() []byte {
|
|
return XinputDeviceKeyPressEvent(v).Bytes()
|
|
}
|
|
|
|
func (v XinputDeviceKeyReleaseEvent) ImplementsEvent() {}
|
|
|
|
func (v XinputDeviceKeyReleaseEvent) SequenceId() uint16 {
|
|
return v.Sequence
|
|
}
|
|
|
|
func (v XinputDeviceKeyReleaseEvent) String() string {
|
|
fieldVals := make([]string, 0, 12)
|
|
fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
|
|
fieldVals = append(fieldVals, sprintf("Detail: %d", v.Detail))
|
|
fieldVals = append(fieldVals, sprintf("Time: %d", v.Time))
|
|
fieldVals = append(fieldVals, sprintf("Root: %d", v.Root))
|
|
fieldVals = append(fieldVals, sprintf("Event: %d", v.Event))
|
|
fieldVals = append(fieldVals, sprintf("Child: %d", v.Child))
|
|
fieldVals = append(fieldVals, sprintf("RootX: %d", v.RootX))
|
|
fieldVals = append(fieldVals, sprintf("RootY: %d", v.RootY))
|
|
fieldVals = append(fieldVals, sprintf("EventX: %d", v.EventX))
|
|
fieldVals = append(fieldVals, sprintf("EventY: %d", v.EventY))
|
|
fieldVals = append(fieldVals, sprintf("State: %d", v.State))
|
|
fieldVals = append(fieldVals, sprintf("SameScreen: %t", v.SameScreen))
|
|
fieldVals = append(fieldVals, sprintf("DeviceId: %d", v.DeviceId))
|
|
return "XinputDeviceKeyRelease {" + stringsJoin(fieldVals, ", ") + "}"
|
|
}
|
|
|
|
func init() {
|
|
newExtEventFuncs["XInputExtension"][2] = NewXinputDeviceKeyReleaseEvent
|
|
}
|
|
|
|
// EventCopy definition XinputDeviceButtonPress (3)
|
|
|
|
const XinputDeviceButtonPress = 3
|
|
|
|
type XinputDeviceButtonPressEvent XinputDeviceKeyPressEvent
|
|
|
|
func NewXinputDeviceButtonPressEvent(buf []byte) Event {
|
|
return XinputDeviceButtonPressEvent(NewXinputDeviceKeyPressEvent(buf).(XinputDeviceKeyPressEvent))
|
|
}
|
|
|
|
func (v XinputDeviceButtonPressEvent) Bytes() []byte {
|
|
return XinputDeviceKeyPressEvent(v).Bytes()
|
|
}
|
|
|
|
func (v XinputDeviceButtonPressEvent) ImplementsEvent() {}
|
|
|
|
func (v XinputDeviceButtonPressEvent) SequenceId() uint16 {
|
|
return v.Sequence
|
|
}
|
|
|
|
func (v XinputDeviceButtonPressEvent) String() string {
|
|
fieldVals := make([]string, 0, 12)
|
|
fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
|
|
fieldVals = append(fieldVals, sprintf("Detail: %d", v.Detail))
|
|
fieldVals = append(fieldVals, sprintf("Time: %d", v.Time))
|
|
fieldVals = append(fieldVals, sprintf("Root: %d", v.Root))
|
|
fieldVals = append(fieldVals, sprintf("Event: %d", v.Event))
|
|
fieldVals = append(fieldVals, sprintf("Child: %d", v.Child))
|
|
fieldVals = append(fieldVals, sprintf("RootX: %d", v.RootX))
|
|
fieldVals = append(fieldVals, sprintf("RootY: %d", v.RootY))
|
|
fieldVals = append(fieldVals, sprintf("EventX: %d", v.EventX))
|
|
fieldVals = append(fieldVals, sprintf("EventY: %d", v.EventY))
|
|
fieldVals = append(fieldVals, sprintf("State: %d", v.State))
|
|
fieldVals = append(fieldVals, sprintf("SameScreen: %t", v.SameScreen))
|
|
fieldVals = append(fieldVals, sprintf("DeviceId: %d", v.DeviceId))
|
|
return "XinputDeviceButtonPress {" + stringsJoin(fieldVals, ", ") + "}"
|
|
}
|
|
|
|
func init() {
|
|
newExtEventFuncs["XInputExtension"][3] = NewXinputDeviceButtonPressEvent
|
|
}
|
|
|
|
// EventCopy definition XinputDeviceButtonRelease (4)
|
|
|
|
const XinputDeviceButtonRelease = 4
|
|
|
|
type XinputDeviceButtonReleaseEvent XinputDeviceKeyPressEvent
|
|
|
|
func NewXinputDeviceButtonReleaseEvent(buf []byte) Event {
|
|
return XinputDeviceButtonReleaseEvent(NewXinputDeviceKeyPressEvent(buf).(XinputDeviceKeyPressEvent))
|
|
}
|
|
|
|
func (v XinputDeviceButtonReleaseEvent) Bytes() []byte {
|
|
return XinputDeviceKeyPressEvent(v).Bytes()
|
|
}
|
|
|
|
func (v XinputDeviceButtonReleaseEvent) ImplementsEvent() {}
|
|
|
|
func (v XinputDeviceButtonReleaseEvent) SequenceId() uint16 {
|
|
return v.Sequence
|
|
}
|
|
|
|
func (v XinputDeviceButtonReleaseEvent) String() string {
|
|
fieldVals := make([]string, 0, 12)
|
|
fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
|
|
fieldVals = append(fieldVals, sprintf("Detail: %d", v.Detail))
|
|
fieldVals = append(fieldVals, sprintf("Time: %d", v.Time))
|
|
fieldVals = append(fieldVals, sprintf("Root: %d", v.Root))
|
|
fieldVals = append(fieldVals, sprintf("Event: %d", v.Event))
|
|
fieldVals = append(fieldVals, sprintf("Child: %d", v.Child))
|
|
fieldVals = append(fieldVals, sprintf("RootX: %d", v.RootX))
|
|
fieldVals = append(fieldVals, sprintf("RootY: %d", v.RootY))
|
|
fieldVals = append(fieldVals, sprintf("EventX: %d", v.EventX))
|
|
fieldVals = append(fieldVals, sprintf("EventY: %d", v.EventY))
|
|
fieldVals = append(fieldVals, sprintf("State: %d", v.State))
|
|
fieldVals = append(fieldVals, sprintf("SameScreen: %t", v.SameScreen))
|
|
fieldVals = append(fieldVals, sprintf("DeviceId: %d", v.DeviceId))
|
|
return "XinputDeviceButtonRelease {" + stringsJoin(fieldVals, ", ") + "}"
|
|
}
|
|
|
|
func init() {
|
|
newExtEventFuncs["XInputExtension"][4] = NewXinputDeviceButtonReleaseEvent
|
|
}
|
|
|
|
// EventCopy definition XinputDeviceMotionNotify (5)
|
|
|
|
const XinputDeviceMotionNotify = 5
|
|
|
|
type XinputDeviceMotionNotifyEvent XinputDeviceKeyPressEvent
|
|
|
|
func NewXinputDeviceMotionNotifyEvent(buf []byte) Event {
|
|
return XinputDeviceMotionNotifyEvent(NewXinputDeviceKeyPressEvent(buf).(XinputDeviceKeyPressEvent))
|
|
}
|
|
|
|
func (v XinputDeviceMotionNotifyEvent) Bytes() []byte {
|
|
return XinputDeviceKeyPressEvent(v).Bytes()
|
|
}
|
|
|
|
func (v XinputDeviceMotionNotifyEvent) ImplementsEvent() {}
|
|
|
|
func (v XinputDeviceMotionNotifyEvent) SequenceId() uint16 {
|
|
return v.Sequence
|
|
}
|
|
|
|
func (v XinputDeviceMotionNotifyEvent) String() string {
|
|
fieldVals := make([]string, 0, 12)
|
|
fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
|
|
fieldVals = append(fieldVals, sprintf("Detail: %d", v.Detail))
|
|
fieldVals = append(fieldVals, sprintf("Time: %d", v.Time))
|
|
fieldVals = append(fieldVals, sprintf("Root: %d", v.Root))
|
|
fieldVals = append(fieldVals, sprintf("Event: %d", v.Event))
|
|
fieldVals = append(fieldVals, sprintf("Child: %d", v.Child))
|
|
fieldVals = append(fieldVals, sprintf("RootX: %d", v.RootX))
|
|
fieldVals = append(fieldVals, sprintf("RootY: %d", v.RootY))
|
|
fieldVals = append(fieldVals, sprintf("EventX: %d", v.EventX))
|
|
fieldVals = append(fieldVals, sprintf("EventY: %d", v.EventY))
|
|
fieldVals = append(fieldVals, sprintf("State: %d", v.State))
|
|
fieldVals = append(fieldVals, sprintf("SameScreen: %t", v.SameScreen))
|
|
fieldVals = append(fieldVals, sprintf("DeviceId: %d", v.DeviceId))
|
|
return "XinputDeviceMotionNotify {" + stringsJoin(fieldVals, ", ") + "}"
|
|
}
|
|
|
|
func init() {
|
|
newExtEventFuncs["XInputExtension"][5] = NewXinputDeviceMotionNotifyEvent
|
|
}
|
|
|
|
// EventCopy definition XinputProximityIn (8)
|
|
|
|
const XinputProximityIn = 8
|
|
|
|
type XinputProximityInEvent XinputDeviceKeyPressEvent
|
|
|
|
func NewXinputProximityInEvent(buf []byte) Event {
|
|
return XinputProximityInEvent(NewXinputDeviceKeyPressEvent(buf).(XinputDeviceKeyPressEvent))
|
|
}
|
|
|
|
func (v XinputProximityInEvent) Bytes() []byte {
|
|
return XinputDeviceKeyPressEvent(v).Bytes()
|
|
}
|
|
|
|
func (v XinputProximityInEvent) ImplementsEvent() {}
|
|
|
|
func (v XinputProximityInEvent) SequenceId() uint16 {
|
|
return v.Sequence
|
|
}
|
|
|
|
func (v XinputProximityInEvent) String() string {
|
|
fieldVals := make([]string, 0, 12)
|
|
fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
|
|
fieldVals = append(fieldVals, sprintf("Detail: %d", v.Detail))
|
|
fieldVals = append(fieldVals, sprintf("Time: %d", v.Time))
|
|
fieldVals = append(fieldVals, sprintf("Root: %d", v.Root))
|
|
fieldVals = append(fieldVals, sprintf("Event: %d", v.Event))
|
|
fieldVals = append(fieldVals, sprintf("Child: %d", v.Child))
|
|
fieldVals = append(fieldVals, sprintf("RootX: %d", v.RootX))
|
|
fieldVals = append(fieldVals, sprintf("RootY: %d", v.RootY))
|
|
fieldVals = append(fieldVals, sprintf("EventX: %d", v.EventX))
|
|
fieldVals = append(fieldVals, sprintf("EventY: %d", v.EventY))
|
|
fieldVals = append(fieldVals, sprintf("State: %d", v.State))
|
|
fieldVals = append(fieldVals, sprintf("SameScreen: %t", v.SameScreen))
|
|
fieldVals = append(fieldVals, sprintf("DeviceId: %d", v.DeviceId))
|
|
return "XinputProximityIn {" + stringsJoin(fieldVals, ", ") + "}"
|
|
}
|
|
|
|
func init() {
|
|
newExtEventFuncs["XInputExtension"][8] = NewXinputProximityInEvent
|
|
}
|
|
|
|
// EventCopy definition XinputProximityOut (9)
|
|
|
|
const XinputProximityOut = 9
|
|
|
|
type XinputProximityOutEvent XinputDeviceKeyPressEvent
|
|
|
|
func NewXinputProximityOutEvent(buf []byte) Event {
|
|
return XinputProximityOutEvent(NewXinputDeviceKeyPressEvent(buf).(XinputDeviceKeyPressEvent))
|
|
}
|
|
|
|
func (v XinputProximityOutEvent) Bytes() []byte {
|
|
return XinputDeviceKeyPressEvent(v).Bytes()
|
|
}
|
|
|
|
func (v XinputProximityOutEvent) ImplementsEvent() {}
|
|
|
|
func (v XinputProximityOutEvent) SequenceId() uint16 {
|
|
return v.Sequence
|
|
}
|
|
|
|
func (v XinputProximityOutEvent) String() string {
|
|
fieldVals := make([]string, 0, 12)
|
|
fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
|
|
fieldVals = append(fieldVals, sprintf("Detail: %d", v.Detail))
|
|
fieldVals = append(fieldVals, sprintf("Time: %d", v.Time))
|
|
fieldVals = append(fieldVals, sprintf("Root: %d", v.Root))
|
|
fieldVals = append(fieldVals, sprintf("Event: %d", v.Event))
|
|
fieldVals = append(fieldVals, sprintf("Child: %d", v.Child))
|
|
fieldVals = append(fieldVals, sprintf("RootX: %d", v.RootX))
|
|
fieldVals = append(fieldVals, sprintf("RootY: %d", v.RootY))
|
|
fieldVals = append(fieldVals, sprintf("EventX: %d", v.EventX))
|
|
fieldVals = append(fieldVals, sprintf("EventY: %d", v.EventY))
|
|
fieldVals = append(fieldVals, sprintf("State: %d", v.State))
|
|
fieldVals = append(fieldVals, sprintf("SameScreen: %t", v.SameScreen))
|
|
fieldVals = append(fieldVals, sprintf("DeviceId: %d", v.DeviceId))
|
|
return "XinputProximityOut {" + stringsJoin(fieldVals, ", ") + "}"
|
|
}
|
|
|
|
func init() {
|
|
newExtEventFuncs["XInputExtension"][9] = NewXinputProximityOutEvent
|
|
}
|
|
|
|
// EventCopy definition XinputFocusOut (7)
|
|
|
|
const XinputFocusOut = 7
|
|
|
|
type XinputFocusOutEvent XinputFocusInEvent
|
|
|
|
func NewXinputFocusOutEvent(buf []byte) Event {
|
|
return XinputFocusOutEvent(NewXinputFocusInEvent(buf).(XinputFocusInEvent))
|
|
}
|
|
|
|
func (v XinputFocusOutEvent) Bytes() []byte {
|
|
return XinputFocusInEvent(v).Bytes()
|
|
}
|
|
|
|
func (v XinputFocusOutEvent) ImplementsEvent() {}
|
|
|
|
func (v XinputFocusOutEvent) SequenceId() uint16 {
|
|
return v.Sequence
|
|
}
|
|
|
|
func (v XinputFocusOutEvent) String() string {
|
|
fieldVals := make([]string, 0, 6)
|
|
fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
|
|
fieldVals = append(fieldVals, sprintf("Detail: %d", v.Detail))
|
|
fieldVals = append(fieldVals, sprintf("Time: %d", v.Time))
|
|
fieldVals = append(fieldVals, sprintf("Window: %d", v.Window))
|
|
fieldVals = append(fieldVals, sprintf("Mode: %d", v.Mode))
|
|
fieldVals = append(fieldVals, sprintf("DeviceId: %d", v.DeviceId))
|
|
return "XinputFocusOut {" + stringsJoin(fieldVals, ", ") + "}"
|
|
}
|
|
|
|
func init() {
|
|
newExtEventFuncs["XInputExtension"][7] = NewXinputFocusOutEvent
|
|
}
|
|
|
|
// Error definition XinputDevice (0)
|
|
// Size: 32
|
|
|
|
const BadXinputDevice = 0
|
|
|
|
type XinputDeviceError struct {
|
|
Sequence uint16
|
|
NiceName string
|
|
}
|
|
|
|
// Error read XinputDevice
|
|
func NewXinputDeviceError(buf []byte) Error {
|
|
v := XinputDeviceError{}
|
|
v.NiceName = "XinputDevice"
|
|
|
|
b := 1 // skip error determinant
|
|
b += 1 // don't read error number
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
return v
|
|
}
|
|
|
|
func (err XinputDeviceError) ImplementsError() {}
|
|
|
|
func (err XinputDeviceError) SequenceId() uint16 {
|
|
return err.Sequence
|
|
}
|
|
|
|
func (err XinputDeviceError) BadId() Id {
|
|
return 0
|
|
}
|
|
|
|
func (err XinputDeviceError) Error() string {
|
|
fieldVals := make([]string, 0, 0)
|
|
fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
|
|
fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
|
|
return "BadXinputDevice {" + stringsJoin(fieldVals, ", ") + "}"
|
|
}
|
|
|
|
func init() {
|
|
newErrorFuncs[0] = NewXinputDeviceError
|
|
}
|
|
|
|
// Error definition XinputEvent (1)
|
|
// Size: 32
|
|
|
|
const BadXinputEvent = 1
|
|
|
|
type XinputEventError struct {
|
|
Sequence uint16
|
|
NiceName string
|
|
}
|
|
|
|
// Error read XinputEvent
|
|
func NewXinputEventError(buf []byte) Error {
|
|
v := XinputEventError{}
|
|
v.NiceName = "XinputEvent"
|
|
|
|
b := 1 // skip error determinant
|
|
b += 1 // don't read error number
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
return v
|
|
}
|
|
|
|
func (err XinputEventError) ImplementsError() {}
|
|
|
|
func (err XinputEventError) SequenceId() uint16 {
|
|
return err.Sequence
|
|
}
|
|
|
|
func (err XinputEventError) BadId() Id {
|
|
return 0
|
|
}
|
|
|
|
func (err XinputEventError) Error() string {
|
|
fieldVals := make([]string, 0, 0)
|
|
fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
|
|
fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
|
|
return "BadXinputEvent {" + stringsJoin(fieldVals, ", ") + "}"
|
|
}
|
|
|
|
func init() {
|
|
newErrorFuncs[1] = NewXinputEventError
|
|
}
|
|
|
|
// Error definition XinputMode (2)
|
|
// Size: 32
|
|
|
|
const BadXinputMode = 2
|
|
|
|
type XinputModeError struct {
|
|
Sequence uint16
|
|
NiceName string
|
|
}
|
|
|
|
// Error read XinputMode
|
|
func NewXinputModeError(buf []byte) Error {
|
|
v := XinputModeError{}
|
|
v.NiceName = "XinputMode"
|
|
|
|
b := 1 // skip error determinant
|
|
b += 1 // don't read error number
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
return v
|
|
}
|
|
|
|
func (err XinputModeError) ImplementsError() {}
|
|
|
|
func (err XinputModeError) SequenceId() uint16 {
|
|
return err.Sequence
|
|
}
|
|
|
|
func (err XinputModeError) BadId() Id {
|
|
return 0
|
|
}
|
|
|
|
func (err XinputModeError) Error() string {
|
|
fieldVals := make([]string, 0, 0)
|
|
fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
|
|
fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
|
|
return "BadXinputMode {" + stringsJoin(fieldVals, ", ") + "}"
|
|
}
|
|
|
|
func init() {
|
|
newErrorFuncs[2] = NewXinputModeError
|
|
}
|
|
|
|
// Error definition XinputDeviceBusy (3)
|
|
// Size: 32
|
|
|
|
const BadXinputDeviceBusy = 3
|
|
|
|
type XinputDeviceBusyError struct {
|
|
Sequence uint16
|
|
NiceName string
|
|
}
|
|
|
|
// Error read XinputDeviceBusy
|
|
func NewXinputDeviceBusyError(buf []byte) Error {
|
|
v := XinputDeviceBusyError{}
|
|
v.NiceName = "XinputDeviceBusy"
|
|
|
|
b := 1 // skip error determinant
|
|
b += 1 // don't read error number
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
return v
|
|
}
|
|
|
|
func (err XinputDeviceBusyError) ImplementsError() {}
|
|
|
|
func (err XinputDeviceBusyError) SequenceId() uint16 {
|
|
return err.Sequence
|
|
}
|
|
|
|
func (err XinputDeviceBusyError) BadId() Id {
|
|
return 0
|
|
}
|
|
|
|
func (err XinputDeviceBusyError) Error() string {
|
|
fieldVals := make([]string, 0, 0)
|
|
fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
|
|
fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
|
|
return "BadXinputDeviceBusy {" + stringsJoin(fieldVals, ", ") + "}"
|
|
}
|
|
|
|
func init() {
|
|
newErrorFuncs[3] = NewXinputDeviceBusyError
|
|
}
|
|
|
|
// Error definition XinputClass (4)
|
|
// Size: 32
|
|
|
|
const BadXinputClass = 4
|
|
|
|
type XinputClassError struct {
|
|
Sequence uint16
|
|
NiceName string
|
|
}
|
|
|
|
// Error read XinputClass
|
|
func NewXinputClassError(buf []byte) Error {
|
|
v := XinputClassError{}
|
|
v.NiceName = "XinputClass"
|
|
|
|
b := 1 // skip error determinant
|
|
b += 1 // don't read error number
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
return v
|
|
}
|
|
|
|
func (err XinputClassError) ImplementsError() {}
|
|
|
|
func (err XinputClassError) SequenceId() uint16 {
|
|
return err.Sequence
|
|
}
|
|
|
|
func (err XinputClassError) BadId() Id {
|
|
return 0
|
|
}
|
|
|
|
func (err XinputClassError) Error() string {
|
|
fieldVals := make([]string, 0, 0)
|
|
fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
|
|
fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
|
|
return "BadXinputClass {" + stringsJoin(fieldVals, ", ") + "}"
|
|
}
|
|
|
|
func init() {
|
|
newErrorFuncs[4] = NewXinputClassError
|
|
}
|
|
|
|
// Request XinputGetExtensionVersion
|
|
// size: pad((8 + pad((int(NameLen) * 1))))
|
|
type XinputGetExtensionVersionCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
func (c *Conn) XinputGetExtensionVersion(NameLen uint16, Name string) XinputGetExtensionVersionCookie {
|
|
cookie := c.newCookie(true, true)
|
|
c.newRequest(c.xinputGetExtensionVersionRequest(NameLen, Name), cookie)
|
|
return XinputGetExtensionVersionCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XinputGetExtensionVersionUnchecked(NameLen uint16, Name string) XinputGetExtensionVersionCookie {
|
|
cookie := c.newCookie(false, true)
|
|
c.newRequest(c.xinputGetExtensionVersionRequest(NameLen, Name), cookie)
|
|
return XinputGetExtensionVersionCookie{cookie}
|
|
}
|
|
|
|
// Request reply for XinputGetExtensionVersion
|
|
// size: 32
|
|
type XinputGetExtensionVersionReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
ServerMajor uint16
|
|
ServerMinor uint16
|
|
Present bool
|
|
// padding: 19 bytes
|
|
}
|
|
|
|
// Waits and reads reply data from request XinputGetExtensionVersion
|
|
func (cook XinputGetExtensionVersionCookie) Reply() (*XinputGetExtensionVersionReply, error) {
|
|
buf, err := cook.reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return xinputGetExtensionVersionReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for XinputGetExtensionVersion
|
|
func xinputGetExtensionVersionReply(buf []byte) *XinputGetExtensionVersionReply {
|
|
v := new(XinputGetExtensionVersionReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.ServerMajor = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.ServerMinor = Get16(buf[b:])
|
|
b += 2
|
|
|
|
if buf[b] == 1 {
|
|
v.Present = true
|
|
} else {
|
|
v.Present = false
|
|
}
|
|
b += 1
|
|
|
|
b += 19 // padding
|
|
|
|
return v
|
|
}
|
|
|
|
func (cook XinputGetExtensionVersionCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XinputGetExtensionVersion
|
|
func (c *Conn) xinputGetExtensionVersionRequest(NameLen uint16, Name string) []byte {
|
|
size := pad((8 + pad((int(NameLen) * 1))))
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINPUTEXTENSION"]
|
|
b += 1
|
|
|
|
buf[b] = 1 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
Put16(buf[b:], NameLen)
|
|
b += 2
|
|
|
|
b += 2 // padding
|
|
|
|
copy(buf[b:], Name[:NameLen])
|
|
b += pad(int(NameLen))
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XinputListInputDevices
|
|
// size: 4
|
|
type XinputListInputDevicesCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
func (c *Conn) XinputListInputDevices() XinputListInputDevicesCookie {
|
|
cookie := c.newCookie(true, true)
|
|
c.newRequest(c.xinputListInputDevicesRequest(), cookie)
|
|
return XinputListInputDevicesCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XinputListInputDevicesUnchecked() XinputListInputDevicesCookie {
|
|
cookie := c.newCookie(false, true)
|
|
c.newRequest(c.xinputListInputDevicesRequest(), cookie)
|
|
return XinputListInputDevicesCookie{cookie}
|
|
}
|
|
|
|
// Request reply for XinputListInputDevices
|
|
// size: (32 + pad((int(DevicesLen) * 8)))
|
|
type XinputListInputDevicesReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
DevicesLen byte
|
|
// padding: 23 bytes
|
|
Devices []XinputDeviceInfo // size: pad((int(DevicesLen) * 8))
|
|
}
|
|
|
|
// Waits and reads reply data from request XinputListInputDevices
|
|
func (cook XinputListInputDevicesCookie) Reply() (*XinputListInputDevicesReply, error) {
|
|
buf, err := cook.reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return xinputListInputDevicesReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for XinputListInputDevices
|
|
func xinputListInputDevicesReply(buf []byte) *XinputListInputDevicesReply {
|
|
v := new(XinputListInputDevicesReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.DevicesLen = buf[b]
|
|
b += 1
|
|
|
|
b += 23 // padding
|
|
|
|
v.Devices = make([]XinputDeviceInfo, v.DevicesLen)
|
|
b += ReadXinputDeviceInfoList(buf[b:], v.Devices)
|
|
|
|
return v
|
|
}
|
|
|
|
func (cook XinputListInputDevicesCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XinputListInputDevices
|
|
func (c *Conn) xinputListInputDevicesRequest() []byte {
|
|
size := 4
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINPUTEXTENSION"]
|
|
b += 1
|
|
|
|
buf[b] = 2 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XinputOpenDevice
|
|
// size: 8
|
|
type XinputOpenDeviceCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
func (c *Conn) XinputOpenDevice(DeviceId byte) XinputOpenDeviceCookie {
|
|
cookie := c.newCookie(true, true)
|
|
c.newRequest(c.xinputOpenDeviceRequest(DeviceId), cookie)
|
|
return XinputOpenDeviceCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XinputOpenDeviceUnchecked(DeviceId byte) XinputOpenDeviceCookie {
|
|
cookie := c.newCookie(false, true)
|
|
c.newRequest(c.xinputOpenDeviceRequest(DeviceId), cookie)
|
|
return XinputOpenDeviceCookie{cookie}
|
|
}
|
|
|
|
// Request reply for XinputOpenDevice
|
|
// size: (32 + pad((int(NumClasses) * 2)))
|
|
type XinputOpenDeviceReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
NumClasses byte
|
|
// padding: 23 bytes
|
|
ClassInfo []XinputInputClassInfo // size: pad((int(NumClasses) * 2))
|
|
}
|
|
|
|
// Waits and reads reply data from request XinputOpenDevice
|
|
func (cook XinputOpenDeviceCookie) Reply() (*XinputOpenDeviceReply, error) {
|
|
buf, err := cook.reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return xinputOpenDeviceReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for XinputOpenDevice
|
|
func xinputOpenDeviceReply(buf []byte) *XinputOpenDeviceReply {
|
|
v := new(XinputOpenDeviceReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.NumClasses = buf[b]
|
|
b += 1
|
|
|
|
b += 23 // padding
|
|
|
|
v.ClassInfo = make([]XinputInputClassInfo, v.NumClasses)
|
|
b += ReadXinputInputClassInfoList(buf[b:], v.ClassInfo)
|
|
|
|
return v
|
|
}
|
|
|
|
func (cook XinputOpenDeviceCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XinputOpenDevice
|
|
func (c *Conn) xinputOpenDeviceRequest(DeviceId byte) []byte {
|
|
size := 8
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINPUTEXTENSION"]
|
|
b += 1
|
|
|
|
buf[b] = 3 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
buf[b] = DeviceId
|
|
b += 1
|
|
|
|
b += 3 // padding
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XinputCloseDevice
|
|
// size: 8
|
|
type XinputCloseDeviceCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
// Write request to wire for XinputCloseDevice
|
|
func (c *Conn) XinputCloseDevice(DeviceId byte) XinputCloseDeviceCookie {
|
|
cookie := c.newCookie(false, false)
|
|
c.newRequest(c.xinputCloseDeviceRequest(DeviceId), cookie)
|
|
return XinputCloseDeviceCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XinputCloseDeviceChecked(DeviceId byte) XinputCloseDeviceCookie {
|
|
cookie := c.newCookie(true, false)
|
|
c.newRequest(c.xinputCloseDeviceRequest(DeviceId), cookie)
|
|
return XinputCloseDeviceCookie{cookie}
|
|
}
|
|
|
|
func (cook XinputCloseDeviceCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XinputCloseDevice
|
|
func (c *Conn) xinputCloseDeviceRequest(DeviceId byte) []byte {
|
|
size := 8
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINPUTEXTENSION"]
|
|
b += 1
|
|
|
|
buf[b] = 4 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
buf[b] = DeviceId
|
|
b += 1
|
|
|
|
b += 3 // padding
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XinputSetDeviceMode
|
|
// size: 8
|
|
type XinputSetDeviceModeCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
func (c *Conn) XinputSetDeviceMode(DeviceId byte, Mode byte) XinputSetDeviceModeCookie {
|
|
cookie := c.newCookie(true, true)
|
|
c.newRequest(c.xinputSetDeviceModeRequest(DeviceId, Mode), cookie)
|
|
return XinputSetDeviceModeCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XinputSetDeviceModeUnchecked(DeviceId byte, Mode byte) XinputSetDeviceModeCookie {
|
|
cookie := c.newCookie(false, true)
|
|
c.newRequest(c.xinputSetDeviceModeRequest(DeviceId, Mode), cookie)
|
|
return XinputSetDeviceModeCookie{cookie}
|
|
}
|
|
|
|
// Request reply for XinputSetDeviceMode
|
|
// size: 32
|
|
type XinputSetDeviceModeReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
Status byte
|
|
// padding: 23 bytes
|
|
}
|
|
|
|
// Waits and reads reply data from request XinputSetDeviceMode
|
|
func (cook XinputSetDeviceModeCookie) Reply() (*XinputSetDeviceModeReply, error) {
|
|
buf, err := cook.reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return xinputSetDeviceModeReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for XinputSetDeviceMode
|
|
func xinputSetDeviceModeReply(buf []byte) *XinputSetDeviceModeReply {
|
|
v := new(XinputSetDeviceModeReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.Status = buf[b]
|
|
b += 1
|
|
|
|
b += 23 // padding
|
|
|
|
return v
|
|
}
|
|
|
|
func (cook XinputSetDeviceModeCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XinputSetDeviceMode
|
|
func (c *Conn) xinputSetDeviceModeRequest(DeviceId byte, Mode byte) []byte {
|
|
size := 8
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINPUTEXTENSION"]
|
|
b += 1
|
|
|
|
buf[b] = 5 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
buf[b] = DeviceId
|
|
b += 1
|
|
|
|
buf[b] = Mode
|
|
b += 1
|
|
|
|
b += 2 // padding
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XinputSelectExtensionEvent
|
|
// size: pad((12 + pad((int(NumClasses) * 4))))
|
|
type XinputSelectExtensionEventCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
// Write request to wire for XinputSelectExtensionEvent
|
|
func (c *Conn) XinputSelectExtensionEvent(Window Id, NumClasses uint16, Classes []XinputEventClass) XinputSelectExtensionEventCookie {
|
|
cookie := c.newCookie(false, false)
|
|
c.newRequest(c.xinputSelectExtensionEventRequest(Window, NumClasses, Classes), cookie)
|
|
return XinputSelectExtensionEventCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XinputSelectExtensionEventChecked(Window Id, NumClasses uint16, Classes []XinputEventClass) XinputSelectExtensionEventCookie {
|
|
cookie := c.newCookie(true, false)
|
|
c.newRequest(c.xinputSelectExtensionEventRequest(Window, NumClasses, Classes), cookie)
|
|
return XinputSelectExtensionEventCookie{cookie}
|
|
}
|
|
|
|
func (cook XinputSelectExtensionEventCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XinputSelectExtensionEvent
|
|
func (c *Conn) xinputSelectExtensionEventRequest(Window Id, NumClasses uint16, Classes []XinputEventClass) []byte {
|
|
size := pad((12 + pad((int(NumClasses) * 4))))
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINPUTEXTENSION"]
|
|
b += 1
|
|
|
|
buf[b] = 6 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
Put32(buf[b:], uint32(Window))
|
|
b += 4
|
|
|
|
Put16(buf[b:], NumClasses)
|
|
b += 2
|
|
|
|
b += 2 // padding
|
|
|
|
for i := 0; i < int(NumClasses); i++ {
|
|
Put32(buf[b:], uint32(Classes[i]))
|
|
b += 4
|
|
}
|
|
b = pad(b)
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XinputGetSelectedExtensionEvents
|
|
// size: 8
|
|
type XinputGetSelectedExtensionEventsCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
func (c *Conn) XinputGetSelectedExtensionEvents(Window Id) XinputGetSelectedExtensionEventsCookie {
|
|
cookie := c.newCookie(true, true)
|
|
c.newRequest(c.xinputGetSelectedExtensionEventsRequest(Window), cookie)
|
|
return XinputGetSelectedExtensionEventsCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XinputGetSelectedExtensionEventsUnchecked(Window Id) XinputGetSelectedExtensionEventsCookie {
|
|
cookie := c.newCookie(false, true)
|
|
c.newRequest(c.xinputGetSelectedExtensionEventsRequest(Window), cookie)
|
|
return XinputGetSelectedExtensionEventsCookie{cookie}
|
|
}
|
|
|
|
// Request reply for XinputGetSelectedExtensionEvents
|
|
// size: ((32 + pad((int(NumThisClasses) * 4))) + pad((int(NumAllClasses) * 4)))
|
|
type XinputGetSelectedExtensionEventsReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
NumThisClasses uint16
|
|
NumAllClasses uint16
|
|
// padding: 20 bytes
|
|
ThisClasses []XinputEventClass // size: pad((int(NumThisClasses) * 4))
|
|
AllClasses []XinputEventClass // size: pad((int(NumAllClasses) * 4))
|
|
}
|
|
|
|
// Waits and reads reply data from request XinputGetSelectedExtensionEvents
|
|
func (cook XinputGetSelectedExtensionEventsCookie) Reply() (*XinputGetSelectedExtensionEventsReply, error) {
|
|
buf, err := cook.reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return xinputGetSelectedExtensionEventsReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for XinputGetSelectedExtensionEvents
|
|
func xinputGetSelectedExtensionEventsReply(buf []byte) *XinputGetSelectedExtensionEventsReply {
|
|
v := new(XinputGetSelectedExtensionEventsReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.NumThisClasses = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.NumAllClasses = Get16(buf[b:])
|
|
b += 2
|
|
|
|
b += 20 // padding
|
|
|
|
v.ThisClasses = make([]XinputEventClass, v.NumThisClasses)
|
|
for i := 0; i < int(v.NumThisClasses); i++ {
|
|
v.ThisClasses[i] = XinputEventClass(Get32(buf[b:]))
|
|
b += 4
|
|
}
|
|
b = pad(b)
|
|
|
|
v.AllClasses = make([]XinputEventClass, v.NumAllClasses)
|
|
for i := 0; i < int(v.NumAllClasses); i++ {
|
|
v.AllClasses[i] = XinputEventClass(Get32(buf[b:]))
|
|
b += 4
|
|
}
|
|
b = pad(b)
|
|
|
|
return v
|
|
}
|
|
|
|
func (cook XinputGetSelectedExtensionEventsCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XinputGetSelectedExtensionEvents
|
|
func (c *Conn) xinputGetSelectedExtensionEventsRequest(Window Id) []byte {
|
|
size := 8
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINPUTEXTENSION"]
|
|
b += 1
|
|
|
|
buf[b] = 7 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
Put32(buf[b:], uint32(Window))
|
|
b += 4
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XinputChangeDeviceDontPropagateList
|
|
// size: pad((12 + pad((int(NumClasses) * 4))))
|
|
type XinputChangeDeviceDontPropagateListCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
// Write request to wire for XinputChangeDeviceDontPropagateList
|
|
func (c *Conn) XinputChangeDeviceDontPropagateList(Window Id, NumClasses uint16, Mode byte, Classes []XinputEventClass) XinputChangeDeviceDontPropagateListCookie {
|
|
cookie := c.newCookie(false, false)
|
|
c.newRequest(c.xinputChangeDeviceDontPropagateListRequest(Window, NumClasses, Mode, Classes), cookie)
|
|
return XinputChangeDeviceDontPropagateListCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XinputChangeDeviceDontPropagateListChecked(Window Id, NumClasses uint16, Mode byte, Classes []XinputEventClass) XinputChangeDeviceDontPropagateListCookie {
|
|
cookie := c.newCookie(true, false)
|
|
c.newRequest(c.xinputChangeDeviceDontPropagateListRequest(Window, NumClasses, Mode, Classes), cookie)
|
|
return XinputChangeDeviceDontPropagateListCookie{cookie}
|
|
}
|
|
|
|
func (cook XinputChangeDeviceDontPropagateListCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XinputChangeDeviceDontPropagateList
|
|
func (c *Conn) xinputChangeDeviceDontPropagateListRequest(Window Id, NumClasses uint16, Mode byte, Classes []XinputEventClass) []byte {
|
|
size := pad((12 + pad((int(NumClasses) * 4))))
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINPUTEXTENSION"]
|
|
b += 1
|
|
|
|
buf[b] = 8 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
Put32(buf[b:], uint32(Window))
|
|
b += 4
|
|
|
|
Put16(buf[b:], NumClasses)
|
|
b += 2
|
|
|
|
buf[b] = Mode
|
|
b += 1
|
|
|
|
b += 1 // padding
|
|
|
|
for i := 0; i < int(NumClasses); i++ {
|
|
Put32(buf[b:], uint32(Classes[i]))
|
|
b += 4
|
|
}
|
|
b = pad(b)
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XinputGetDeviceDontPropagateList
|
|
// size: 8
|
|
type XinputGetDeviceDontPropagateListCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
func (c *Conn) XinputGetDeviceDontPropagateList(Window Id) XinputGetDeviceDontPropagateListCookie {
|
|
cookie := c.newCookie(true, true)
|
|
c.newRequest(c.xinputGetDeviceDontPropagateListRequest(Window), cookie)
|
|
return XinputGetDeviceDontPropagateListCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XinputGetDeviceDontPropagateListUnchecked(Window Id) XinputGetDeviceDontPropagateListCookie {
|
|
cookie := c.newCookie(false, true)
|
|
c.newRequest(c.xinputGetDeviceDontPropagateListRequest(Window), cookie)
|
|
return XinputGetDeviceDontPropagateListCookie{cookie}
|
|
}
|
|
|
|
// Request reply for XinputGetDeviceDontPropagateList
|
|
// size: (32 + pad((int(NumClasses) * 4)))
|
|
type XinputGetDeviceDontPropagateListReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
NumClasses uint16
|
|
// padding: 22 bytes
|
|
Classes []XinputEventClass // size: pad((int(NumClasses) * 4))
|
|
}
|
|
|
|
// Waits and reads reply data from request XinputGetDeviceDontPropagateList
|
|
func (cook XinputGetDeviceDontPropagateListCookie) Reply() (*XinputGetDeviceDontPropagateListReply, error) {
|
|
buf, err := cook.reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return xinputGetDeviceDontPropagateListReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for XinputGetDeviceDontPropagateList
|
|
func xinputGetDeviceDontPropagateListReply(buf []byte) *XinputGetDeviceDontPropagateListReply {
|
|
v := new(XinputGetDeviceDontPropagateListReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.NumClasses = Get16(buf[b:])
|
|
b += 2
|
|
|
|
b += 22 // padding
|
|
|
|
v.Classes = make([]XinputEventClass, v.NumClasses)
|
|
for i := 0; i < int(v.NumClasses); i++ {
|
|
v.Classes[i] = XinputEventClass(Get32(buf[b:]))
|
|
b += 4
|
|
}
|
|
b = pad(b)
|
|
|
|
return v
|
|
}
|
|
|
|
func (cook XinputGetDeviceDontPropagateListCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XinputGetDeviceDontPropagateList
|
|
func (c *Conn) xinputGetDeviceDontPropagateListRequest(Window Id) []byte {
|
|
size := 8
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINPUTEXTENSION"]
|
|
b += 1
|
|
|
|
buf[b] = 9 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
Put32(buf[b:], uint32(Window))
|
|
b += 4
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XinputGetDeviceMotionEvents
|
|
// size: 16
|
|
type XinputGetDeviceMotionEventsCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
func (c *Conn) XinputGetDeviceMotionEvents(Start Timestamp, Stop Timestamp, DeviceId byte) XinputGetDeviceMotionEventsCookie {
|
|
cookie := c.newCookie(true, true)
|
|
c.newRequest(c.xinputGetDeviceMotionEventsRequest(Start, Stop, DeviceId), cookie)
|
|
return XinputGetDeviceMotionEventsCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XinputGetDeviceMotionEventsUnchecked(Start Timestamp, Stop Timestamp, DeviceId byte) XinputGetDeviceMotionEventsCookie {
|
|
cookie := c.newCookie(false, true)
|
|
c.newRequest(c.xinputGetDeviceMotionEventsRequest(Start, Stop, DeviceId), cookie)
|
|
return XinputGetDeviceMotionEventsCookie{cookie}
|
|
}
|
|
|
|
// Request reply for XinputGetDeviceMotionEvents
|
|
// size: 32
|
|
type XinputGetDeviceMotionEventsReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
NumCoords uint32
|
|
NumAxes byte
|
|
DeviceMode byte
|
|
// padding: 18 bytes
|
|
}
|
|
|
|
// Waits and reads reply data from request XinputGetDeviceMotionEvents
|
|
func (cook XinputGetDeviceMotionEventsCookie) Reply() (*XinputGetDeviceMotionEventsReply, error) {
|
|
buf, err := cook.reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return xinputGetDeviceMotionEventsReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for XinputGetDeviceMotionEvents
|
|
func xinputGetDeviceMotionEventsReply(buf []byte) *XinputGetDeviceMotionEventsReply {
|
|
v := new(XinputGetDeviceMotionEventsReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.NumCoords = Get32(buf[b:])
|
|
b += 4
|
|
|
|
v.NumAxes = buf[b]
|
|
b += 1
|
|
|
|
v.DeviceMode = buf[b]
|
|
b += 1
|
|
|
|
b += 18 // padding
|
|
|
|
return v
|
|
}
|
|
|
|
func (cook XinputGetDeviceMotionEventsCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XinputGetDeviceMotionEvents
|
|
func (c *Conn) xinputGetDeviceMotionEventsRequest(Start Timestamp, Stop Timestamp, DeviceId byte) []byte {
|
|
size := 16
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINPUTEXTENSION"]
|
|
b += 1
|
|
|
|
buf[b] = 10 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
Put32(buf[b:], uint32(Start))
|
|
b += 4
|
|
|
|
Put32(buf[b:], uint32(Stop))
|
|
b += 4
|
|
|
|
buf[b] = DeviceId
|
|
b += 1
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XinputChangeKeyboardDevice
|
|
// size: 8
|
|
type XinputChangeKeyboardDeviceCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
func (c *Conn) XinputChangeKeyboardDevice(DeviceId byte) XinputChangeKeyboardDeviceCookie {
|
|
cookie := c.newCookie(true, true)
|
|
c.newRequest(c.xinputChangeKeyboardDeviceRequest(DeviceId), cookie)
|
|
return XinputChangeKeyboardDeviceCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XinputChangeKeyboardDeviceUnchecked(DeviceId byte) XinputChangeKeyboardDeviceCookie {
|
|
cookie := c.newCookie(false, true)
|
|
c.newRequest(c.xinputChangeKeyboardDeviceRequest(DeviceId), cookie)
|
|
return XinputChangeKeyboardDeviceCookie{cookie}
|
|
}
|
|
|
|
// Request reply for XinputChangeKeyboardDevice
|
|
// size: 32
|
|
type XinputChangeKeyboardDeviceReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
Status byte
|
|
// padding: 23 bytes
|
|
}
|
|
|
|
// Waits and reads reply data from request XinputChangeKeyboardDevice
|
|
func (cook XinputChangeKeyboardDeviceCookie) Reply() (*XinputChangeKeyboardDeviceReply, error) {
|
|
buf, err := cook.reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return xinputChangeKeyboardDeviceReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for XinputChangeKeyboardDevice
|
|
func xinputChangeKeyboardDeviceReply(buf []byte) *XinputChangeKeyboardDeviceReply {
|
|
v := new(XinputChangeKeyboardDeviceReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.Status = buf[b]
|
|
b += 1
|
|
|
|
b += 23 // padding
|
|
|
|
return v
|
|
}
|
|
|
|
func (cook XinputChangeKeyboardDeviceCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XinputChangeKeyboardDevice
|
|
func (c *Conn) xinputChangeKeyboardDeviceRequest(DeviceId byte) []byte {
|
|
size := 8
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINPUTEXTENSION"]
|
|
b += 1
|
|
|
|
buf[b] = 11 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
buf[b] = DeviceId
|
|
b += 1
|
|
|
|
b += 3 // padding
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XinputChangePointerDevice
|
|
// size: 8
|
|
type XinputChangePointerDeviceCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
func (c *Conn) XinputChangePointerDevice(XAxis byte, YAxis byte, DeviceId byte) XinputChangePointerDeviceCookie {
|
|
cookie := c.newCookie(true, true)
|
|
c.newRequest(c.xinputChangePointerDeviceRequest(XAxis, YAxis, DeviceId), cookie)
|
|
return XinputChangePointerDeviceCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XinputChangePointerDeviceUnchecked(XAxis byte, YAxis byte, DeviceId byte) XinputChangePointerDeviceCookie {
|
|
cookie := c.newCookie(false, true)
|
|
c.newRequest(c.xinputChangePointerDeviceRequest(XAxis, YAxis, DeviceId), cookie)
|
|
return XinputChangePointerDeviceCookie{cookie}
|
|
}
|
|
|
|
// Request reply for XinputChangePointerDevice
|
|
// size: 32
|
|
type XinputChangePointerDeviceReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
Status byte
|
|
// padding: 23 bytes
|
|
}
|
|
|
|
// Waits and reads reply data from request XinputChangePointerDevice
|
|
func (cook XinputChangePointerDeviceCookie) Reply() (*XinputChangePointerDeviceReply, error) {
|
|
buf, err := cook.reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return xinputChangePointerDeviceReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for XinputChangePointerDevice
|
|
func xinputChangePointerDeviceReply(buf []byte) *XinputChangePointerDeviceReply {
|
|
v := new(XinputChangePointerDeviceReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.Status = buf[b]
|
|
b += 1
|
|
|
|
b += 23 // padding
|
|
|
|
return v
|
|
}
|
|
|
|
func (cook XinputChangePointerDeviceCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XinputChangePointerDevice
|
|
func (c *Conn) xinputChangePointerDeviceRequest(XAxis byte, YAxis byte, DeviceId byte) []byte {
|
|
size := 8
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINPUTEXTENSION"]
|
|
b += 1
|
|
|
|
buf[b] = 12 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
buf[b] = XAxis
|
|
b += 1
|
|
|
|
buf[b] = YAxis
|
|
b += 1
|
|
|
|
buf[b] = DeviceId
|
|
b += 1
|
|
|
|
b += 1 // padding
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XinputGrabDevice
|
|
// size: pad((20 + pad((int(NumClasses) * 4))))
|
|
type XinputGrabDeviceCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
func (c *Conn) XinputGrabDevice(GrabWindow Id, Time Timestamp, NumClasses uint16, ThisDeviceMode byte, OtherDeviceMode byte, OwnerEvents bool, DeviceId byte, Classes []XinputEventClass) XinputGrabDeviceCookie {
|
|
cookie := c.newCookie(true, true)
|
|
c.newRequest(c.xinputGrabDeviceRequest(GrabWindow, Time, NumClasses, ThisDeviceMode, OtherDeviceMode, OwnerEvents, DeviceId, Classes), cookie)
|
|
return XinputGrabDeviceCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XinputGrabDeviceUnchecked(GrabWindow Id, Time Timestamp, NumClasses uint16, ThisDeviceMode byte, OtherDeviceMode byte, OwnerEvents bool, DeviceId byte, Classes []XinputEventClass) XinputGrabDeviceCookie {
|
|
cookie := c.newCookie(false, true)
|
|
c.newRequest(c.xinputGrabDeviceRequest(GrabWindow, Time, NumClasses, ThisDeviceMode, OtherDeviceMode, OwnerEvents, DeviceId, Classes), cookie)
|
|
return XinputGrabDeviceCookie{cookie}
|
|
}
|
|
|
|
// Request reply for XinputGrabDevice
|
|
// size: 32
|
|
type XinputGrabDeviceReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
Status byte
|
|
// padding: 23 bytes
|
|
}
|
|
|
|
// Waits and reads reply data from request XinputGrabDevice
|
|
func (cook XinputGrabDeviceCookie) Reply() (*XinputGrabDeviceReply, error) {
|
|
buf, err := cook.reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return xinputGrabDeviceReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for XinputGrabDevice
|
|
func xinputGrabDeviceReply(buf []byte) *XinputGrabDeviceReply {
|
|
v := new(XinputGrabDeviceReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.Status = buf[b]
|
|
b += 1
|
|
|
|
b += 23 // padding
|
|
|
|
return v
|
|
}
|
|
|
|
func (cook XinputGrabDeviceCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XinputGrabDevice
|
|
func (c *Conn) xinputGrabDeviceRequest(GrabWindow Id, Time Timestamp, NumClasses uint16, ThisDeviceMode byte, OtherDeviceMode byte, OwnerEvents bool, DeviceId byte, Classes []XinputEventClass) []byte {
|
|
size := pad((20 + pad((int(NumClasses) * 4))))
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINPUTEXTENSION"]
|
|
b += 1
|
|
|
|
buf[b] = 13 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
Put32(buf[b:], uint32(GrabWindow))
|
|
b += 4
|
|
|
|
Put32(buf[b:], uint32(Time))
|
|
b += 4
|
|
|
|
Put16(buf[b:], NumClasses)
|
|
b += 2
|
|
|
|
buf[b] = ThisDeviceMode
|
|
b += 1
|
|
|
|
buf[b] = OtherDeviceMode
|
|
b += 1
|
|
|
|
if OwnerEvents {
|
|
buf[b] = 1
|
|
} else {
|
|
buf[b] = 0
|
|
}
|
|
b += 1
|
|
|
|
buf[b] = DeviceId
|
|
b += 1
|
|
|
|
b += 2 // padding
|
|
|
|
for i := 0; i < int(NumClasses); i++ {
|
|
Put32(buf[b:], uint32(Classes[i]))
|
|
b += 4
|
|
}
|
|
b = pad(b)
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XinputUngrabDevice
|
|
// size: 12
|
|
type XinputUngrabDeviceCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
// Write request to wire for XinputUngrabDevice
|
|
func (c *Conn) XinputUngrabDevice(Time Timestamp, DeviceId byte) XinputUngrabDeviceCookie {
|
|
cookie := c.newCookie(false, false)
|
|
c.newRequest(c.xinputUngrabDeviceRequest(Time, DeviceId), cookie)
|
|
return XinputUngrabDeviceCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XinputUngrabDeviceChecked(Time Timestamp, DeviceId byte) XinputUngrabDeviceCookie {
|
|
cookie := c.newCookie(true, false)
|
|
c.newRequest(c.xinputUngrabDeviceRequest(Time, DeviceId), cookie)
|
|
return XinputUngrabDeviceCookie{cookie}
|
|
}
|
|
|
|
func (cook XinputUngrabDeviceCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XinputUngrabDevice
|
|
func (c *Conn) xinputUngrabDeviceRequest(Time Timestamp, DeviceId byte) []byte {
|
|
size := 12
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINPUTEXTENSION"]
|
|
b += 1
|
|
|
|
buf[b] = 14 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
Put32(buf[b:], uint32(Time))
|
|
b += 4
|
|
|
|
buf[b] = DeviceId
|
|
b += 1
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XinputGrabDeviceKey
|
|
// size: pad((20 + pad((int(NumClasses) * 4))))
|
|
type XinputGrabDeviceKeyCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
// Write request to wire for XinputGrabDeviceKey
|
|
func (c *Conn) XinputGrabDeviceKey(GrabWindow Id, NumClasses uint16, Modifiers uint16, ModifierDevice byte, GrabbedDevice byte, Key byte, ThisDeviceMode byte, OtherDeviceMode byte, OwnerEvents bool, Classes []XinputEventClass) XinputGrabDeviceKeyCookie {
|
|
cookie := c.newCookie(false, false)
|
|
c.newRequest(c.xinputGrabDeviceKeyRequest(GrabWindow, NumClasses, Modifiers, ModifierDevice, GrabbedDevice, Key, ThisDeviceMode, OtherDeviceMode, OwnerEvents, Classes), cookie)
|
|
return XinputGrabDeviceKeyCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XinputGrabDeviceKeyChecked(GrabWindow Id, NumClasses uint16, Modifiers uint16, ModifierDevice byte, GrabbedDevice byte, Key byte, ThisDeviceMode byte, OtherDeviceMode byte, OwnerEvents bool, Classes []XinputEventClass) XinputGrabDeviceKeyCookie {
|
|
cookie := c.newCookie(true, false)
|
|
c.newRequest(c.xinputGrabDeviceKeyRequest(GrabWindow, NumClasses, Modifiers, ModifierDevice, GrabbedDevice, Key, ThisDeviceMode, OtherDeviceMode, OwnerEvents, Classes), cookie)
|
|
return XinputGrabDeviceKeyCookie{cookie}
|
|
}
|
|
|
|
func (cook XinputGrabDeviceKeyCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XinputGrabDeviceKey
|
|
func (c *Conn) xinputGrabDeviceKeyRequest(GrabWindow Id, NumClasses uint16, Modifiers uint16, ModifierDevice byte, GrabbedDevice byte, Key byte, ThisDeviceMode byte, OtherDeviceMode byte, OwnerEvents bool, Classes []XinputEventClass) []byte {
|
|
size := pad((20 + pad((int(NumClasses) * 4))))
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINPUTEXTENSION"]
|
|
b += 1
|
|
|
|
buf[b] = 15 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
Put32(buf[b:], uint32(GrabWindow))
|
|
b += 4
|
|
|
|
Put16(buf[b:], NumClasses)
|
|
b += 2
|
|
|
|
Put16(buf[b:], Modifiers)
|
|
b += 2
|
|
|
|
buf[b] = ModifierDevice
|
|
b += 1
|
|
|
|
buf[b] = GrabbedDevice
|
|
b += 1
|
|
|
|
buf[b] = Key
|
|
b += 1
|
|
|
|
buf[b] = ThisDeviceMode
|
|
b += 1
|
|
|
|
buf[b] = OtherDeviceMode
|
|
b += 1
|
|
|
|
if OwnerEvents {
|
|
buf[b] = 1
|
|
} else {
|
|
buf[b] = 0
|
|
}
|
|
b += 1
|
|
|
|
b += 2 // padding
|
|
|
|
for i := 0; i < int(NumClasses); i++ {
|
|
Put32(buf[b:], uint32(Classes[i]))
|
|
b += 4
|
|
}
|
|
b = pad(b)
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XinputUngrabDeviceKey
|
|
// size: 16
|
|
type XinputUngrabDeviceKeyCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
// Write request to wire for XinputUngrabDeviceKey
|
|
func (c *Conn) XinputUngrabDeviceKey(GrabWindow Id, Modifiers uint16, ModifierDevice byte, Key byte, GrabbedDevice byte) XinputUngrabDeviceKeyCookie {
|
|
cookie := c.newCookie(false, false)
|
|
c.newRequest(c.xinputUngrabDeviceKeyRequest(GrabWindow, Modifiers, ModifierDevice, Key, GrabbedDevice), cookie)
|
|
return XinputUngrabDeviceKeyCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XinputUngrabDeviceKeyChecked(GrabWindow Id, Modifiers uint16, ModifierDevice byte, Key byte, GrabbedDevice byte) XinputUngrabDeviceKeyCookie {
|
|
cookie := c.newCookie(true, false)
|
|
c.newRequest(c.xinputUngrabDeviceKeyRequest(GrabWindow, Modifiers, ModifierDevice, Key, GrabbedDevice), cookie)
|
|
return XinputUngrabDeviceKeyCookie{cookie}
|
|
}
|
|
|
|
func (cook XinputUngrabDeviceKeyCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XinputUngrabDeviceKey
|
|
func (c *Conn) xinputUngrabDeviceKeyRequest(GrabWindow Id, Modifiers uint16, ModifierDevice byte, Key byte, GrabbedDevice byte) []byte {
|
|
size := 16
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINPUTEXTENSION"]
|
|
b += 1
|
|
|
|
buf[b] = 16 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
Put32(buf[b:], uint32(GrabWindow))
|
|
b += 4
|
|
|
|
Put16(buf[b:], Modifiers)
|
|
b += 2
|
|
|
|
buf[b] = ModifierDevice
|
|
b += 1
|
|
|
|
buf[b] = Key
|
|
b += 1
|
|
|
|
buf[b] = GrabbedDevice
|
|
b += 1
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XinputGrabDeviceButton
|
|
// size: pad((20 + pad((int(NumClasses) * 4))))
|
|
type XinputGrabDeviceButtonCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
// Write request to wire for XinputGrabDeviceButton
|
|
func (c *Conn) XinputGrabDeviceButton(GrabWindow Id, GrabbedDevice byte, ModifierDevice byte, NumClasses uint16, Modifiers uint16, ThisDeviceMode byte, OtherDeviceMode byte, Button byte, OwnerEvents byte, Classes []XinputEventClass) XinputGrabDeviceButtonCookie {
|
|
cookie := c.newCookie(false, false)
|
|
c.newRequest(c.xinputGrabDeviceButtonRequest(GrabWindow, GrabbedDevice, ModifierDevice, NumClasses, Modifiers, ThisDeviceMode, OtherDeviceMode, Button, OwnerEvents, Classes), cookie)
|
|
return XinputGrabDeviceButtonCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XinputGrabDeviceButtonChecked(GrabWindow Id, GrabbedDevice byte, ModifierDevice byte, NumClasses uint16, Modifiers uint16, ThisDeviceMode byte, OtherDeviceMode byte, Button byte, OwnerEvents byte, Classes []XinputEventClass) XinputGrabDeviceButtonCookie {
|
|
cookie := c.newCookie(true, false)
|
|
c.newRequest(c.xinputGrabDeviceButtonRequest(GrabWindow, GrabbedDevice, ModifierDevice, NumClasses, Modifiers, ThisDeviceMode, OtherDeviceMode, Button, OwnerEvents, Classes), cookie)
|
|
return XinputGrabDeviceButtonCookie{cookie}
|
|
}
|
|
|
|
func (cook XinputGrabDeviceButtonCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XinputGrabDeviceButton
|
|
func (c *Conn) xinputGrabDeviceButtonRequest(GrabWindow Id, GrabbedDevice byte, ModifierDevice byte, NumClasses uint16, Modifiers uint16, ThisDeviceMode byte, OtherDeviceMode byte, Button byte, OwnerEvents byte, Classes []XinputEventClass) []byte {
|
|
size := pad((20 + pad((int(NumClasses) * 4))))
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINPUTEXTENSION"]
|
|
b += 1
|
|
|
|
buf[b] = 17 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
Put32(buf[b:], uint32(GrabWindow))
|
|
b += 4
|
|
|
|
buf[b] = GrabbedDevice
|
|
b += 1
|
|
|
|
buf[b] = ModifierDevice
|
|
b += 1
|
|
|
|
Put16(buf[b:], NumClasses)
|
|
b += 2
|
|
|
|
Put16(buf[b:], Modifiers)
|
|
b += 2
|
|
|
|
buf[b] = ThisDeviceMode
|
|
b += 1
|
|
|
|
buf[b] = OtherDeviceMode
|
|
b += 1
|
|
|
|
buf[b] = Button
|
|
b += 1
|
|
|
|
buf[b] = OwnerEvents
|
|
b += 1
|
|
|
|
b += 2 // padding
|
|
|
|
for i := 0; i < int(NumClasses); i++ {
|
|
Put32(buf[b:], uint32(Classes[i]))
|
|
b += 4
|
|
}
|
|
b = pad(b)
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XinputUngrabDeviceButton
|
|
// size: 16
|
|
type XinputUngrabDeviceButtonCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
// Write request to wire for XinputUngrabDeviceButton
|
|
func (c *Conn) XinputUngrabDeviceButton(GrabWindow Id, Modifiers uint16, ModifierDevice byte, Button byte, GrabbedDevice byte) XinputUngrabDeviceButtonCookie {
|
|
cookie := c.newCookie(false, false)
|
|
c.newRequest(c.xinputUngrabDeviceButtonRequest(GrabWindow, Modifiers, ModifierDevice, Button, GrabbedDevice), cookie)
|
|
return XinputUngrabDeviceButtonCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XinputUngrabDeviceButtonChecked(GrabWindow Id, Modifiers uint16, ModifierDevice byte, Button byte, GrabbedDevice byte) XinputUngrabDeviceButtonCookie {
|
|
cookie := c.newCookie(true, false)
|
|
c.newRequest(c.xinputUngrabDeviceButtonRequest(GrabWindow, Modifiers, ModifierDevice, Button, GrabbedDevice), cookie)
|
|
return XinputUngrabDeviceButtonCookie{cookie}
|
|
}
|
|
|
|
func (cook XinputUngrabDeviceButtonCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XinputUngrabDeviceButton
|
|
func (c *Conn) xinputUngrabDeviceButtonRequest(GrabWindow Id, Modifiers uint16, ModifierDevice byte, Button byte, GrabbedDevice byte) []byte {
|
|
size := 16
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINPUTEXTENSION"]
|
|
b += 1
|
|
|
|
buf[b] = 18 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
Put32(buf[b:], uint32(GrabWindow))
|
|
b += 4
|
|
|
|
Put16(buf[b:], Modifiers)
|
|
b += 2
|
|
|
|
buf[b] = ModifierDevice
|
|
b += 1
|
|
|
|
buf[b] = Button
|
|
b += 1
|
|
|
|
buf[b] = GrabbedDevice
|
|
b += 1
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XinputAllowDeviceEvents
|
|
// size: 12
|
|
type XinputAllowDeviceEventsCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
// Write request to wire for XinputAllowDeviceEvents
|
|
func (c *Conn) XinputAllowDeviceEvents(Time Timestamp, Mode byte, DeviceId byte) XinputAllowDeviceEventsCookie {
|
|
cookie := c.newCookie(false, false)
|
|
c.newRequest(c.xinputAllowDeviceEventsRequest(Time, Mode, DeviceId), cookie)
|
|
return XinputAllowDeviceEventsCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XinputAllowDeviceEventsChecked(Time Timestamp, Mode byte, DeviceId byte) XinputAllowDeviceEventsCookie {
|
|
cookie := c.newCookie(true, false)
|
|
c.newRequest(c.xinputAllowDeviceEventsRequest(Time, Mode, DeviceId), cookie)
|
|
return XinputAllowDeviceEventsCookie{cookie}
|
|
}
|
|
|
|
func (cook XinputAllowDeviceEventsCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XinputAllowDeviceEvents
|
|
func (c *Conn) xinputAllowDeviceEventsRequest(Time Timestamp, Mode byte, DeviceId byte) []byte {
|
|
size := 12
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINPUTEXTENSION"]
|
|
b += 1
|
|
|
|
buf[b] = 19 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
Put32(buf[b:], uint32(Time))
|
|
b += 4
|
|
|
|
buf[b] = Mode
|
|
b += 1
|
|
|
|
buf[b] = DeviceId
|
|
b += 1
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XinputGetDeviceFocus
|
|
// size: 8
|
|
type XinputGetDeviceFocusCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
func (c *Conn) XinputGetDeviceFocus(DeviceId byte) XinputGetDeviceFocusCookie {
|
|
cookie := c.newCookie(true, true)
|
|
c.newRequest(c.xinputGetDeviceFocusRequest(DeviceId), cookie)
|
|
return XinputGetDeviceFocusCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XinputGetDeviceFocusUnchecked(DeviceId byte) XinputGetDeviceFocusCookie {
|
|
cookie := c.newCookie(false, true)
|
|
c.newRequest(c.xinputGetDeviceFocusRequest(DeviceId), cookie)
|
|
return XinputGetDeviceFocusCookie{cookie}
|
|
}
|
|
|
|
// Request reply for XinputGetDeviceFocus
|
|
// size: 32
|
|
type XinputGetDeviceFocusReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
Focus Id
|
|
Time Timestamp
|
|
RevertTo byte
|
|
// padding: 15 bytes
|
|
}
|
|
|
|
// Waits and reads reply data from request XinputGetDeviceFocus
|
|
func (cook XinputGetDeviceFocusCookie) Reply() (*XinputGetDeviceFocusReply, error) {
|
|
buf, err := cook.reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return xinputGetDeviceFocusReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for XinputGetDeviceFocus
|
|
func xinputGetDeviceFocusReply(buf []byte) *XinputGetDeviceFocusReply {
|
|
v := new(XinputGetDeviceFocusReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.Focus = Id(Get32(buf[b:]))
|
|
b += 4
|
|
|
|
v.Time = Timestamp(Get32(buf[b:]))
|
|
b += 4
|
|
|
|
v.RevertTo = buf[b]
|
|
b += 1
|
|
|
|
b += 15 // padding
|
|
|
|
return v
|
|
}
|
|
|
|
func (cook XinputGetDeviceFocusCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XinputGetDeviceFocus
|
|
func (c *Conn) xinputGetDeviceFocusRequest(DeviceId byte) []byte {
|
|
size := 8
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINPUTEXTENSION"]
|
|
b += 1
|
|
|
|
buf[b] = 20 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
buf[b] = DeviceId
|
|
b += 1
|
|
|
|
b += 3 // padding
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XinputSetDeviceFocus
|
|
// size: 16
|
|
type XinputSetDeviceFocusCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
// Write request to wire for XinputSetDeviceFocus
|
|
func (c *Conn) XinputSetDeviceFocus(Focus Id, Time Timestamp, RevertTo byte, DeviceId byte) XinputSetDeviceFocusCookie {
|
|
cookie := c.newCookie(false, false)
|
|
c.newRequest(c.xinputSetDeviceFocusRequest(Focus, Time, RevertTo, DeviceId), cookie)
|
|
return XinputSetDeviceFocusCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XinputSetDeviceFocusChecked(Focus Id, Time Timestamp, RevertTo byte, DeviceId byte) XinputSetDeviceFocusCookie {
|
|
cookie := c.newCookie(true, false)
|
|
c.newRequest(c.xinputSetDeviceFocusRequest(Focus, Time, RevertTo, DeviceId), cookie)
|
|
return XinputSetDeviceFocusCookie{cookie}
|
|
}
|
|
|
|
func (cook XinputSetDeviceFocusCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XinputSetDeviceFocus
|
|
func (c *Conn) xinputSetDeviceFocusRequest(Focus Id, Time Timestamp, RevertTo byte, DeviceId byte) []byte {
|
|
size := 16
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINPUTEXTENSION"]
|
|
b += 1
|
|
|
|
buf[b] = 21 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
Put32(buf[b:], uint32(Focus))
|
|
b += 4
|
|
|
|
Put32(buf[b:], uint32(Time))
|
|
b += 4
|
|
|
|
buf[b] = RevertTo
|
|
b += 1
|
|
|
|
buf[b] = DeviceId
|
|
b += 1
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XinputGetFeedbackControl
|
|
// size: 8
|
|
type XinputGetFeedbackControlCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
func (c *Conn) XinputGetFeedbackControl(DeviceId byte) XinputGetFeedbackControlCookie {
|
|
cookie := c.newCookie(true, true)
|
|
c.newRequest(c.xinputGetFeedbackControlRequest(DeviceId), cookie)
|
|
return XinputGetFeedbackControlCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XinputGetFeedbackControlUnchecked(DeviceId byte) XinputGetFeedbackControlCookie {
|
|
cookie := c.newCookie(false, true)
|
|
c.newRequest(c.xinputGetFeedbackControlRequest(DeviceId), cookie)
|
|
return XinputGetFeedbackControlCookie{cookie}
|
|
}
|
|
|
|
// Request reply for XinputGetFeedbackControl
|
|
// size: 32
|
|
type XinputGetFeedbackControlReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
NumFeedback uint16
|
|
// padding: 22 bytes
|
|
}
|
|
|
|
// Waits and reads reply data from request XinputGetFeedbackControl
|
|
func (cook XinputGetFeedbackControlCookie) Reply() (*XinputGetFeedbackControlReply, error) {
|
|
buf, err := cook.reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return xinputGetFeedbackControlReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for XinputGetFeedbackControl
|
|
func xinputGetFeedbackControlReply(buf []byte) *XinputGetFeedbackControlReply {
|
|
v := new(XinputGetFeedbackControlReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.NumFeedback = Get16(buf[b:])
|
|
b += 2
|
|
|
|
b += 22 // padding
|
|
|
|
return v
|
|
}
|
|
|
|
func (cook XinputGetFeedbackControlCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XinputGetFeedbackControl
|
|
func (c *Conn) xinputGetFeedbackControlRequest(DeviceId byte) []byte {
|
|
size := 8
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINPUTEXTENSION"]
|
|
b += 1
|
|
|
|
buf[b] = 22 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
buf[b] = DeviceId
|
|
b += 1
|
|
|
|
b += 3 // padding
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XinputGetDeviceKeyMapping
|
|
// size: 8
|
|
type XinputGetDeviceKeyMappingCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
func (c *Conn) XinputGetDeviceKeyMapping(DeviceId byte, FirstKeycode XinputKeyCode, Count byte) XinputGetDeviceKeyMappingCookie {
|
|
cookie := c.newCookie(true, true)
|
|
c.newRequest(c.xinputGetDeviceKeyMappingRequest(DeviceId, FirstKeycode, Count), cookie)
|
|
return XinputGetDeviceKeyMappingCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XinputGetDeviceKeyMappingUnchecked(DeviceId byte, FirstKeycode XinputKeyCode, Count byte) XinputGetDeviceKeyMappingCookie {
|
|
cookie := c.newCookie(false, true)
|
|
c.newRequest(c.xinputGetDeviceKeyMappingRequest(DeviceId, FirstKeycode, Count), cookie)
|
|
return XinputGetDeviceKeyMappingCookie{cookie}
|
|
}
|
|
|
|
// Request reply for XinputGetDeviceKeyMapping
|
|
// size: (32 + pad((int(Length) * 4)))
|
|
type XinputGetDeviceKeyMappingReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
KeysymsPerKeycode byte
|
|
// padding: 23 bytes
|
|
Keysyms []Keysym // size: pad((int(Length) * 4))
|
|
}
|
|
|
|
// Waits and reads reply data from request XinputGetDeviceKeyMapping
|
|
func (cook XinputGetDeviceKeyMappingCookie) Reply() (*XinputGetDeviceKeyMappingReply, error) {
|
|
buf, err := cook.reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return xinputGetDeviceKeyMappingReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for XinputGetDeviceKeyMapping
|
|
func xinputGetDeviceKeyMappingReply(buf []byte) *XinputGetDeviceKeyMappingReply {
|
|
v := new(XinputGetDeviceKeyMappingReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.KeysymsPerKeycode = buf[b]
|
|
b += 1
|
|
|
|
b += 23 // padding
|
|
|
|
v.Keysyms = make([]Keysym, v.Length)
|
|
for i := 0; i < int(v.Length); i++ {
|
|
v.Keysyms[i] = Keysym(Get32(buf[b:]))
|
|
b += 4
|
|
}
|
|
b = pad(b)
|
|
|
|
return v
|
|
}
|
|
|
|
func (cook XinputGetDeviceKeyMappingCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XinputGetDeviceKeyMapping
|
|
func (c *Conn) xinputGetDeviceKeyMappingRequest(DeviceId byte, FirstKeycode XinputKeyCode, Count byte) []byte {
|
|
size := 8
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINPUTEXTENSION"]
|
|
b += 1
|
|
|
|
buf[b] = 24 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
buf[b] = DeviceId
|
|
b += 1
|
|
|
|
buf[b] = byte(FirstKeycode)
|
|
b += 1
|
|
|
|
buf[b] = Count
|
|
b += 1
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XinputChangeDeviceKeyMapping
|
|
// size: pad((8 + pad(((int(KeycodeCount) * int(KeysymsPerKeycode)) * 4))))
|
|
type XinputChangeDeviceKeyMappingCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
// Write request to wire for XinputChangeDeviceKeyMapping
|
|
func (c *Conn) XinputChangeDeviceKeyMapping(DeviceId byte, FirstKeycode XinputKeyCode, KeysymsPerKeycode byte, KeycodeCount byte, Keysyms []Keysym) XinputChangeDeviceKeyMappingCookie {
|
|
cookie := c.newCookie(false, false)
|
|
c.newRequest(c.xinputChangeDeviceKeyMappingRequest(DeviceId, FirstKeycode, KeysymsPerKeycode, KeycodeCount, Keysyms), cookie)
|
|
return XinputChangeDeviceKeyMappingCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XinputChangeDeviceKeyMappingChecked(DeviceId byte, FirstKeycode XinputKeyCode, KeysymsPerKeycode byte, KeycodeCount byte, Keysyms []Keysym) XinputChangeDeviceKeyMappingCookie {
|
|
cookie := c.newCookie(true, false)
|
|
c.newRequest(c.xinputChangeDeviceKeyMappingRequest(DeviceId, FirstKeycode, KeysymsPerKeycode, KeycodeCount, Keysyms), cookie)
|
|
return XinputChangeDeviceKeyMappingCookie{cookie}
|
|
}
|
|
|
|
func (cook XinputChangeDeviceKeyMappingCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XinputChangeDeviceKeyMapping
|
|
func (c *Conn) xinputChangeDeviceKeyMappingRequest(DeviceId byte, FirstKeycode XinputKeyCode, KeysymsPerKeycode byte, KeycodeCount byte, Keysyms []Keysym) []byte {
|
|
size := pad((8 + pad(((int(KeycodeCount) * int(KeysymsPerKeycode)) * 4))))
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINPUTEXTENSION"]
|
|
b += 1
|
|
|
|
buf[b] = 25 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
buf[b] = DeviceId
|
|
b += 1
|
|
|
|
buf[b] = byte(FirstKeycode)
|
|
b += 1
|
|
|
|
buf[b] = KeysymsPerKeycode
|
|
b += 1
|
|
|
|
buf[b] = KeycodeCount
|
|
b += 1
|
|
|
|
for i := 0; i < int((int(KeycodeCount) * int(KeysymsPerKeycode))); i++ {
|
|
Put32(buf[b:], uint32(Keysyms[i]))
|
|
b += 4
|
|
}
|
|
b = pad(b)
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XinputGetDeviceModifierMapping
|
|
// size: 8
|
|
type XinputGetDeviceModifierMappingCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
func (c *Conn) XinputGetDeviceModifierMapping(DeviceId byte) XinputGetDeviceModifierMappingCookie {
|
|
cookie := c.newCookie(true, true)
|
|
c.newRequest(c.xinputGetDeviceModifierMappingRequest(DeviceId), cookie)
|
|
return XinputGetDeviceModifierMappingCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XinputGetDeviceModifierMappingUnchecked(DeviceId byte) XinputGetDeviceModifierMappingCookie {
|
|
cookie := c.newCookie(false, true)
|
|
c.newRequest(c.xinputGetDeviceModifierMappingRequest(DeviceId), cookie)
|
|
return XinputGetDeviceModifierMappingCookie{cookie}
|
|
}
|
|
|
|
// Request reply for XinputGetDeviceModifierMapping
|
|
// size: (32 + pad(((int(KeycodesPerModifier) * 8) * 1)))
|
|
type XinputGetDeviceModifierMappingReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
KeycodesPerModifier byte
|
|
// padding: 23 bytes
|
|
Keymaps []byte // size: pad(((int(KeycodesPerModifier) * 8) * 1))
|
|
}
|
|
|
|
// Waits and reads reply data from request XinputGetDeviceModifierMapping
|
|
func (cook XinputGetDeviceModifierMappingCookie) Reply() (*XinputGetDeviceModifierMappingReply, error) {
|
|
buf, err := cook.reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return xinputGetDeviceModifierMappingReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for XinputGetDeviceModifierMapping
|
|
func xinputGetDeviceModifierMappingReply(buf []byte) *XinputGetDeviceModifierMappingReply {
|
|
v := new(XinputGetDeviceModifierMappingReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.KeycodesPerModifier = buf[b]
|
|
b += 1
|
|
|
|
b += 23 // padding
|
|
|
|
v.Keymaps = make([]byte, (int(v.KeycodesPerModifier) * 8))
|
|
copy(v.Keymaps[:(int(v.KeycodesPerModifier)*8)], buf[b:])
|
|
b += pad(int((int(v.KeycodesPerModifier) * 8)))
|
|
|
|
return v
|
|
}
|
|
|
|
func (cook XinputGetDeviceModifierMappingCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XinputGetDeviceModifierMapping
|
|
func (c *Conn) xinputGetDeviceModifierMappingRequest(DeviceId byte) []byte {
|
|
size := 8
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINPUTEXTENSION"]
|
|
b += 1
|
|
|
|
buf[b] = 26 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
buf[b] = DeviceId
|
|
b += 1
|
|
|
|
b += 3 // padding
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XinputSetDeviceModifierMapping
|
|
// size: pad((7 + pad(((int(KeycodesPerModifier) * 8) * 1))))
|
|
type XinputSetDeviceModifierMappingCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
func (c *Conn) XinputSetDeviceModifierMapping(DeviceId byte, KeycodesPerModifier byte, Keymaps []byte) XinputSetDeviceModifierMappingCookie {
|
|
cookie := c.newCookie(true, true)
|
|
c.newRequest(c.xinputSetDeviceModifierMappingRequest(DeviceId, KeycodesPerModifier, Keymaps), cookie)
|
|
return XinputSetDeviceModifierMappingCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XinputSetDeviceModifierMappingUnchecked(DeviceId byte, KeycodesPerModifier byte, Keymaps []byte) XinputSetDeviceModifierMappingCookie {
|
|
cookie := c.newCookie(false, true)
|
|
c.newRequest(c.xinputSetDeviceModifierMappingRequest(DeviceId, KeycodesPerModifier, Keymaps), cookie)
|
|
return XinputSetDeviceModifierMappingCookie{cookie}
|
|
}
|
|
|
|
// Request reply for XinputSetDeviceModifierMapping
|
|
// size: 32
|
|
type XinputSetDeviceModifierMappingReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
Status byte
|
|
// padding: 23 bytes
|
|
}
|
|
|
|
// Waits and reads reply data from request XinputSetDeviceModifierMapping
|
|
func (cook XinputSetDeviceModifierMappingCookie) Reply() (*XinputSetDeviceModifierMappingReply, error) {
|
|
buf, err := cook.reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return xinputSetDeviceModifierMappingReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for XinputSetDeviceModifierMapping
|
|
func xinputSetDeviceModifierMappingReply(buf []byte) *XinputSetDeviceModifierMappingReply {
|
|
v := new(XinputSetDeviceModifierMappingReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.Status = buf[b]
|
|
b += 1
|
|
|
|
b += 23 // padding
|
|
|
|
return v
|
|
}
|
|
|
|
func (cook XinputSetDeviceModifierMappingCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XinputSetDeviceModifierMapping
|
|
func (c *Conn) xinputSetDeviceModifierMappingRequest(DeviceId byte, KeycodesPerModifier byte, Keymaps []byte) []byte {
|
|
size := pad((7 + pad(((int(KeycodesPerModifier) * 8) * 1))))
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINPUTEXTENSION"]
|
|
b += 1
|
|
|
|
buf[b] = 27 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
buf[b] = DeviceId
|
|
b += 1
|
|
|
|
buf[b] = KeycodesPerModifier
|
|
b += 1
|
|
|
|
b += 1 // padding
|
|
|
|
copy(buf[b:], Keymaps[:(int(KeycodesPerModifier)*8)])
|
|
b += pad(int((int(KeycodesPerModifier) * 8)))
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XinputGetDeviceButtonMapping
|
|
// size: 8
|
|
type XinputGetDeviceButtonMappingCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
func (c *Conn) XinputGetDeviceButtonMapping(DeviceId byte) XinputGetDeviceButtonMappingCookie {
|
|
cookie := c.newCookie(true, true)
|
|
c.newRequest(c.xinputGetDeviceButtonMappingRequest(DeviceId), cookie)
|
|
return XinputGetDeviceButtonMappingCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XinputGetDeviceButtonMappingUnchecked(DeviceId byte) XinputGetDeviceButtonMappingCookie {
|
|
cookie := c.newCookie(false, true)
|
|
c.newRequest(c.xinputGetDeviceButtonMappingRequest(DeviceId), cookie)
|
|
return XinputGetDeviceButtonMappingCookie{cookie}
|
|
}
|
|
|
|
// Request reply for XinputGetDeviceButtonMapping
|
|
// size: (32 + pad((int(MapSize) * 1)))
|
|
type XinputGetDeviceButtonMappingReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
MapSize byte
|
|
// padding: 23 bytes
|
|
Map []byte // size: pad((int(MapSize) * 1))
|
|
}
|
|
|
|
// Waits and reads reply data from request XinputGetDeviceButtonMapping
|
|
func (cook XinputGetDeviceButtonMappingCookie) Reply() (*XinputGetDeviceButtonMappingReply, error) {
|
|
buf, err := cook.reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return xinputGetDeviceButtonMappingReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for XinputGetDeviceButtonMapping
|
|
func xinputGetDeviceButtonMappingReply(buf []byte) *XinputGetDeviceButtonMappingReply {
|
|
v := new(XinputGetDeviceButtonMappingReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.MapSize = buf[b]
|
|
b += 1
|
|
|
|
b += 23 // padding
|
|
|
|
v.Map = make([]byte, v.MapSize)
|
|
copy(v.Map[:v.MapSize], buf[b:])
|
|
b += pad(int(v.MapSize))
|
|
|
|
return v
|
|
}
|
|
|
|
func (cook XinputGetDeviceButtonMappingCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XinputGetDeviceButtonMapping
|
|
func (c *Conn) xinputGetDeviceButtonMappingRequest(DeviceId byte) []byte {
|
|
size := 8
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINPUTEXTENSION"]
|
|
b += 1
|
|
|
|
buf[b] = 28 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
buf[b] = DeviceId
|
|
b += 1
|
|
|
|
b += 3 // padding
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XinputSetDeviceButtonMapping
|
|
// size: pad((8 + pad((int(MapSize) * 1))))
|
|
type XinputSetDeviceButtonMappingCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
func (c *Conn) XinputSetDeviceButtonMapping(DeviceId byte, MapSize byte, Map []byte) XinputSetDeviceButtonMappingCookie {
|
|
cookie := c.newCookie(true, true)
|
|
c.newRequest(c.xinputSetDeviceButtonMappingRequest(DeviceId, MapSize, Map), cookie)
|
|
return XinputSetDeviceButtonMappingCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XinputSetDeviceButtonMappingUnchecked(DeviceId byte, MapSize byte, Map []byte) XinputSetDeviceButtonMappingCookie {
|
|
cookie := c.newCookie(false, true)
|
|
c.newRequest(c.xinputSetDeviceButtonMappingRequest(DeviceId, MapSize, Map), cookie)
|
|
return XinputSetDeviceButtonMappingCookie{cookie}
|
|
}
|
|
|
|
// Request reply for XinputSetDeviceButtonMapping
|
|
// size: 32
|
|
type XinputSetDeviceButtonMappingReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
Status byte
|
|
// padding: 23 bytes
|
|
}
|
|
|
|
// Waits and reads reply data from request XinputSetDeviceButtonMapping
|
|
func (cook XinputSetDeviceButtonMappingCookie) Reply() (*XinputSetDeviceButtonMappingReply, error) {
|
|
buf, err := cook.reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return xinputSetDeviceButtonMappingReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for XinputSetDeviceButtonMapping
|
|
func xinputSetDeviceButtonMappingReply(buf []byte) *XinputSetDeviceButtonMappingReply {
|
|
v := new(XinputSetDeviceButtonMappingReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.Status = buf[b]
|
|
b += 1
|
|
|
|
b += 23 // padding
|
|
|
|
return v
|
|
}
|
|
|
|
func (cook XinputSetDeviceButtonMappingCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XinputSetDeviceButtonMapping
|
|
func (c *Conn) xinputSetDeviceButtonMappingRequest(DeviceId byte, MapSize byte, Map []byte) []byte {
|
|
size := pad((8 + pad((int(MapSize) * 1))))
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINPUTEXTENSION"]
|
|
b += 1
|
|
|
|
buf[b] = 29 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
buf[b] = DeviceId
|
|
b += 1
|
|
|
|
buf[b] = MapSize
|
|
b += 1
|
|
|
|
b += 2 // padding
|
|
|
|
copy(buf[b:], Map[:MapSize])
|
|
b += pad(int(MapSize))
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XinputQueryDeviceState
|
|
// size: 8
|
|
type XinputQueryDeviceStateCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
func (c *Conn) XinputQueryDeviceState(DeviceId byte) XinputQueryDeviceStateCookie {
|
|
cookie := c.newCookie(true, true)
|
|
c.newRequest(c.xinputQueryDeviceStateRequest(DeviceId), cookie)
|
|
return XinputQueryDeviceStateCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XinputQueryDeviceStateUnchecked(DeviceId byte) XinputQueryDeviceStateCookie {
|
|
cookie := c.newCookie(false, true)
|
|
c.newRequest(c.xinputQueryDeviceStateRequest(DeviceId), cookie)
|
|
return XinputQueryDeviceStateCookie{cookie}
|
|
}
|
|
|
|
// Request reply for XinputQueryDeviceState
|
|
// size: 32
|
|
type XinputQueryDeviceStateReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
NumClasses byte
|
|
// padding: 23 bytes
|
|
}
|
|
|
|
// Waits and reads reply data from request XinputQueryDeviceState
|
|
func (cook XinputQueryDeviceStateCookie) Reply() (*XinputQueryDeviceStateReply, error) {
|
|
buf, err := cook.reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return xinputQueryDeviceStateReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for XinputQueryDeviceState
|
|
func xinputQueryDeviceStateReply(buf []byte) *XinputQueryDeviceStateReply {
|
|
v := new(XinputQueryDeviceStateReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.NumClasses = buf[b]
|
|
b += 1
|
|
|
|
b += 23 // padding
|
|
|
|
return v
|
|
}
|
|
|
|
func (cook XinputQueryDeviceStateCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XinputQueryDeviceState
|
|
func (c *Conn) xinputQueryDeviceStateRequest(DeviceId byte) []byte {
|
|
size := 8
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINPUTEXTENSION"]
|
|
b += 1
|
|
|
|
buf[b] = 30 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
buf[b] = DeviceId
|
|
b += 1
|
|
|
|
b += 3 // padding
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XinputSendExtensionEvent
|
|
// size: pad(((16 + pad(((int(NumEvents) * 32) * 1))) + pad((int(NumClasses) * 4))))
|
|
type XinputSendExtensionEventCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
// Write request to wire for XinputSendExtensionEvent
|
|
func (c *Conn) XinputSendExtensionEvent(Destination Id, DeviceId byte, Propagate bool, NumClasses uint16, NumEvents byte, Events string, Classes []XinputEventClass) XinputSendExtensionEventCookie {
|
|
cookie := c.newCookie(false, false)
|
|
c.newRequest(c.xinputSendExtensionEventRequest(Destination, DeviceId, Propagate, NumClasses, NumEvents, Events, Classes), cookie)
|
|
return XinputSendExtensionEventCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XinputSendExtensionEventChecked(Destination Id, DeviceId byte, Propagate bool, NumClasses uint16, NumEvents byte, Events string, Classes []XinputEventClass) XinputSendExtensionEventCookie {
|
|
cookie := c.newCookie(true, false)
|
|
c.newRequest(c.xinputSendExtensionEventRequest(Destination, DeviceId, Propagate, NumClasses, NumEvents, Events, Classes), cookie)
|
|
return XinputSendExtensionEventCookie{cookie}
|
|
}
|
|
|
|
func (cook XinputSendExtensionEventCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XinputSendExtensionEvent
|
|
func (c *Conn) xinputSendExtensionEventRequest(Destination Id, DeviceId byte, Propagate bool, NumClasses uint16, NumEvents byte, Events string, Classes []XinputEventClass) []byte {
|
|
size := pad(((16 + pad(((int(NumEvents) * 32) * 1))) + pad((int(NumClasses) * 4))))
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINPUTEXTENSION"]
|
|
b += 1
|
|
|
|
buf[b] = 31 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
Put32(buf[b:], uint32(Destination))
|
|
b += 4
|
|
|
|
buf[b] = DeviceId
|
|
b += 1
|
|
|
|
if Propagate {
|
|
buf[b] = 1
|
|
} else {
|
|
buf[b] = 0
|
|
}
|
|
b += 1
|
|
|
|
Put16(buf[b:], NumClasses)
|
|
b += 2
|
|
|
|
buf[b] = NumEvents
|
|
b += 1
|
|
|
|
b += 3 // padding
|
|
|
|
copy(buf[b:], Events[:(int(NumEvents)*32)])
|
|
b += pad(int((int(NumEvents) * 32)))
|
|
|
|
for i := 0; i < int(NumClasses); i++ {
|
|
Put32(buf[b:], uint32(Classes[i]))
|
|
b += 4
|
|
}
|
|
b = pad(b)
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XinputDeviceBell
|
|
// size: 8
|
|
type XinputDeviceBellCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
// Write request to wire for XinputDeviceBell
|
|
func (c *Conn) XinputDeviceBell(DeviceId byte, FeedbackId byte, FeedbackClass byte, Percent int8) XinputDeviceBellCookie {
|
|
cookie := c.newCookie(false, false)
|
|
c.newRequest(c.xinputDeviceBellRequest(DeviceId, FeedbackId, FeedbackClass, Percent), cookie)
|
|
return XinputDeviceBellCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XinputDeviceBellChecked(DeviceId byte, FeedbackId byte, FeedbackClass byte, Percent int8) XinputDeviceBellCookie {
|
|
cookie := c.newCookie(true, false)
|
|
c.newRequest(c.xinputDeviceBellRequest(DeviceId, FeedbackId, FeedbackClass, Percent), cookie)
|
|
return XinputDeviceBellCookie{cookie}
|
|
}
|
|
|
|
func (cook XinputDeviceBellCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XinputDeviceBell
|
|
func (c *Conn) xinputDeviceBellRequest(DeviceId byte, FeedbackId byte, FeedbackClass byte, Percent int8) []byte {
|
|
size := 8
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINPUTEXTENSION"]
|
|
b += 1
|
|
|
|
buf[b] = 32 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
buf[b] = DeviceId
|
|
b += 1
|
|
|
|
buf[b] = FeedbackId
|
|
b += 1
|
|
|
|
buf[b] = FeedbackClass
|
|
b += 1
|
|
|
|
buf[b] = byte(Percent)
|
|
b += 1
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XinputSetDeviceValuators
|
|
// size: pad((8 + pad((int(NumValuators) * 4))))
|
|
type XinputSetDeviceValuatorsCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
func (c *Conn) XinputSetDeviceValuators(DeviceId byte, FirstValuator byte, NumValuators byte, Valuators []int32) XinputSetDeviceValuatorsCookie {
|
|
cookie := c.newCookie(true, true)
|
|
c.newRequest(c.xinputSetDeviceValuatorsRequest(DeviceId, FirstValuator, NumValuators, Valuators), cookie)
|
|
return XinputSetDeviceValuatorsCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XinputSetDeviceValuatorsUnchecked(DeviceId byte, FirstValuator byte, NumValuators byte, Valuators []int32) XinputSetDeviceValuatorsCookie {
|
|
cookie := c.newCookie(false, true)
|
|
c.newRequest(c.xinputSetDeviceValuatorsRequest(DeviceId, FirstValuator, NumValuators, Valuators), cookie)
|
|
return XinputSetDeviceValuatorsCookie{cookie}
|
|
}
|
|
|
|
// Request reply for XinputSetDeviceValuators
|
|
// size: 32
|
|
type XinputSetDeviceValuatorsReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
Status byte
|
|
// padding: 23 bytes
|
|
}
|
|
|
|
// Waits and reads reply data from request XinputSetDeviceValuators
|
|
func (cook XinputSetDeviceValuatorsCookie) Reply() (*XinputSetDeviceValuatorsReply, error) {
|
|
buf, err := cook.reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return xinputSetDeviceValuatorsReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for XinputSetDeviceValuators
|
|
func xinputSetDeviceValuatorsReply(buf []byte) *XinputSetDeviceValuatorsReply {
|
|
v := new(XinputSetDeviceValuatorsReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.Status = buf[b]
|
|
b += 1
|
|
|
|
b += 23 // padding
|
|
|
|
return v
|
|
}
|
|
|
|
func (cook XinputSetDeviceValuatorsCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XinputSetDeviceValuators
|
|
func (c *Conn) xinputSetDeviceValuatorsRequest(DeviceId byte, FirstValuator byte, NumValuators byte, Valuators []int32) []byte {
|
|
size := pad((8 + pad((int(NumValuators) * 4))))
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINPUTEXTENSION"]
|
|
b += 1
|
|
|
|
buf[b] = 33 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
buf[b] = DeviceId
|
|
b += 1
|
|
|
|
buf[b] = FirstValuator
|
|
b += 1
|
|
|
|
buf[b] = NumValuators
|
|
b += 1
|
|
|
|
b += 1 // padding
|
|
|
|
for i := 0; i < int(NumValuators); i++ {
|
|
Put32(buf[b:], uint32(Valuators[i]))
|
|
b += 4
|
|
}
|
|
b = pad(b)
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XinputGetDeviceControl
|
|
// size: 8
|
|
type XinputGetDeviceControlCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
func (c *Conn) XinputGetDeviceControl(ControlId uint16, DeviceId byte) XinputGetDeviceControlCookie {
|
|
cookie := c.newCookie(true, true)
|
|
c.newRequest(c.xinputGetDeviceControlRequest(ControlId, DeviceId), cookie)
|
|
return XinputGetDeviceControlCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XinputGetDeviceControlUnchecked(ControlId uint16, DeviceId byte) XinputGetDeviceControlCookie {
|
|
cookie := c.newCookie(false, true)
|
|
c.newRequest(c.xinputGetDeviceControlRequest(ControlId, DeviceId), cookie)
|
|
return XinputGetDeviceControlCookie{cookie}
|
|
}
|
|
|
|
// Request reply for XinputGetDeviceControl
|
|
// size: 32
|
|
type XinputGetDeviceControlReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
Status byte
|
|
// padding: 23 bytes
|
|
}
|
|
|
|
// Waits and reads reply data from request XinputGetDeviceControl
|
|
func (cook XinputGetDeviceControlCookie) Reply() (*XinputGetDeviceControlReply, error) {
|
|
buf, err := cook.reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return xinputGetDeviceControlReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for XinputGetDeviceControl
|
|
func xinputGetDeviceControlReply(buf []byte) *XinputGetDeviceControlReply {
|
|
v := new(XinputGetDeviceControlReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.Status = buf[b]
|
|
b += 1
|
|
|
|
b += 23 // padding
|
|
|
|
return v
|
|
}
|
|
|
|
func (cook XinputGetDeviceControlCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XinputGetDeviceControl
|
|
func (c *Conn) xinputGetDeviceControlRequest(ControlId uint16, DeviceId byte) []byte {
|
|
size := 8
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINPUTEXTENSION"]
|
|
b += 1
|
|
|
|
buf[b] = 34 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
Put16(buf[b:], ControlId)
|
|
b += 2
|
|
|
|
buf[b] = DeviceId
|
|
b += 1
|
|
|
|
b += 1 // padding
|
|
|
|
return buf
|
|
}
|