diff options
Diffstat (limited to 'nexgb/auto_xinput.go')
| -rw-r--r-- | nexgb/auto_xinput.go | 7271 |
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 +} |