aboutsummaryrefslogtreecommitdiff
path: root/nexgb/auto_xinput.go
diff options
context:
space:
mode:
Diffstat (limited to 'nexgb/auto_xinput.go')
-rw-r--r--nexgb/auto_xinput.go7271
1 files changed, 7271 insertions, 0 deletions
diff --git a/nexgb/auto_xinput.go b/nexgb/auto_xinput.go
new file mode 100644
index 0000000..d300bca
--- /dev/null
+++ b/nexgb/auto_xinput.go
@@ -0,0 +1,7271 @@
+package xgb
+
+/*
+ This file was generated by xinput.xml on May 6 2012 3:00:45am 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"
+
+// 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'
+
+// 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'
+
+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() {
+ newEventFuncs[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() {
+ newEventFuncs[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() {
+ newEventFuncs[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() {
+ newEventFuncs[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() {
+ newEventFuncs[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() {
+ newEventFuncs[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() {
+ newEventFuncs[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() {
+ newEventFuncs[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() {
+ newEventFuncs[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() {
+ newEventFuncs[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() {
+ newEventFuncs[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() {
+ newEventFuncs[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() {
+ newEventFuncs[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() {
+ newEventFuncs[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() {
+ newEventFuncs[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() {
+ newEventFuncs[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
+}