haven/nexgb/xinput/xinput.go

// Package xinput is the X client API for the XInputExtension extension.
package xinput

/*
	This file was generated by xinput.xml on May 10 2012 8:04:32pm EDT.
	This file is automatically generated. Edit at your peril!
*/

import (
	"github.com/BurntSushi/xgb"

	"github.com/BurntSushi/xgb/xproto"
)

// Init must be called before using the XInputExtension extension.
func Init(c *xgb.Conn) error {
	reply, err := xproto.QueryExtension(c, 15, "XInputExtension").Reply()
	switch {
	case err != nil:
		return err
	case !reply.Present:
		return xgb.Errorf("No extension named XInputExtension could be found on on the server.")
	}

	xgb.ExtLock.Lock()
	c.Extensions["XInputExtension"] = reply.MajorOpcode
	for evNum, fun := range xgb.NewExtEventFuncs["XInputExtension"] {
		xgb.NewEventFuncs[int(reply.FirstEvent)+evNum] = fun
	}
	for errNum, fun := range xgb.NewExtErrorFuncs["XInputExtension"] {
		xgb.NewErrorFuncs[int(reply.FirstError)+errNum] = fun
	}
	xgb.ExtLock.Unlock()

	return nil
}

func init() {
	xgb.NewExtEventFuncs["XInputExtension"] = make(map[int]xgb.NewEventFun)
	xgb.NewExtErrorFuncs["XInputExtension"] = make(map[int]xgb.NewErrorFun)
}

// 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'

// Skipping definition for base type 'Float'

const (
	ValuatorModeRelative = 0
	ValuatorModeAbsolute = 1
)

const (
	PropagateModeAddToList      = 0
	PropagateModeDeleteFromList = 1
)

const (
	DeviceUseIsXPointer           = 0
	DeviceUseIsXKeyboard          = 1
	DeviceUseIsXExtensionDevice   = 2
	DeviceUseIsXExtensionKeyboard = 3
	DeviceUseIsXExtensionPointer  = 4
)

const (
	InputClassKey       = 0
	InputClassButton    = 1
	InputClassValuator  = 2
	InputClassFeedback  = 3
	InputClassProximity = 4
	InputClassFocus     = 5
	InputClassOther     = 6
)

const (
	DeviceInputModeAsyncThisDevice   = 0
	DeviceInputModeSyncThisDevice    = 1
	DeviceInputModeReplayThisDevice  = 2
	DeviceInputModeAsyncOtherDevices = 3
	DeviceInputModeAsyncAll          = 4
	DeviceInputModeSyncAll           = 5
)

const (
	FeedbackClassKeyboard = 0
	FeedbackClassPointer  = 1
	FeedbackClassString   = 2
	FeedbackClassInteger  = 3
	FeedbackClassLed      = 4
	FeedbackClassBell     = 5
)

type KeyCode byte

type EventClass uint32

// 'DeviceInfo' struct definition
// Size: 8
type DeviceInfo struct {
	DeviceType   xproto.Atom
	DeviceId     byte
	NumClassInfo byte
	DeviceUse    byte
	// padding: 1 bytes
}

// Struct read DeviceInfo
func DeviceInfoRead(buf []byte, v *DeviceInfo) int {
	b := 0

	v.DeviceType = xproto.Atom(xgb.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 DeviceInfo
func DeviceInfoReadList(buf []byte, dest []DeviceInfo) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = DeviceInfo{}
		b += DeviceInfoRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write DeviceInfo
func (v DeviceInfo) Bytes() []byte {
	buf := make([]byte, 8)
	b := 0

	xgb.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 DeviceInfo
func DeviceInfoListBytes(buf []byte, list []DeviceInfo) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// 'InputInfo' struct definition
// Size: 2
type InputInfo struct {
	ClassId byte
	Len     byte
}

// Struct read InputInfo
func InputInfoRead(buf []byte, v *InputInfo) int {
	b := 0

	v.ClassId = buf[b]
	b += 1

	v.Len = buf[b]
	b += 1

	return b
}

// Struct list read InputInfo
func InputInfoReadList(buf []byte, dest []InputInfo) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = InputInfo{}
		b += InputInfoRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write InputInfo
func (v InputInfo) 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 InputInfo
func InputInfoListBytes(buf []byte, list []InputInfo) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// 'KeyInfo' struct definition
// Size: 8
type KeyInfo struct {
	ClassId    byte
	Len        byte
	MinKeycode KeyCode
	MaxKeycode KeyCode
	NumKeys    uint16
	// padding: 2 bytes
}

// Struct read KeyInfo
func KeyInfoRead(buf []byte, v *KeyInfo) int {
	b := 0

	v.ClassId = buf[b]
	b += 1

	v.Len = buf[b]
	b += 1

	v.MinKeycode = KeyCode(buf[b])
	b += 1

	v.MaxKeycode = KeyCode(buf[b])
	b += 1

	v.NumKeys = xgb.Get16(buf[b:])
	b += 2

	b += 2 // padding

	return b
}

// Struct list read KeyInfo
func KeyInfoReadList(buf []byte, dest []KeyInfo) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = KeyInfo{}
		b += KeyInfoRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write KeyInfo
func (v KeyInfo) 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

	xgb.Put16(buf[b:], v.NumKeys)
	b += 2

	b += 2 // padding

	return buf
}

// Write struct list KeyInfo
func KeyInfoListBytes(buf []byte, list []KeyInfo) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// 'ButtonInfo' struct definition
// Size: 4
type ButtonInfo struct {
	ClassId    byte
	Len        byte
	NumButtons uint16
}

// Struct read ButtonInfo
func ButtonInfoRead(buf []byte, v *ButtonInfo) int {
	b := 0

	v.ClassId = buf[b]
	b += 1

	v.Len = buf[b]
	b += 1

	v.NumButtons = xgb.Get16(buf[b:])
	b += 2

	return b
}

// Struct list read ButtonInfo
func ButtonInfoReadList(buf []byte, dest []ButtonInfo) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = ButtonInfo{}
		b += ButtonInfoRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write ButtonInfo
func (v ButtonInfo) Bytes() []byte {
	buf := make([]byte, 4)
	b := 0

	buf[b] = v.ClassId
	b += 1

	buf[b] = v.Len
	b += 1

	xgb.Put16(buf[b:], v.NumButtons)
	b += 2

	return buf
}

// Write struct list ButtonInfo
func ButtonInfoListBytes(buf []byte, list []ButtonInfo) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// 'AxisInfo' struct definition
// Size: 12
type AxisInfo struct {
	Resolution uint32
	Minimum    int32
	Maximum    int32
}

// Struct read AxisInfo
func AxisInfoRead(buf []byte, v *AxisInfo) int {
	b := 0

	v.Resolution = xgb.Get32(buf[b:])
	b += 4

	v.Minimum = int32(xgb.Get32(buf[b:]))
	b += 4

	v.Maximum = int32(xgb.Get32(buf[b:]))
	b += 4

	return b
}

// Struct list read AxisInfo
func AxisInfoReadList(buf []byte, dest []AxisInfo) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = AxisInfo{}
		b += AxisInfoRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write AxisInfo
func (v AxisInfo) Bytes() []byte {
	buf := make([]byte, 12)
	b := 0

	xgb.Put32(buf[b:], v.Resolution)
	b += 4

	xgb.Put32(buf[b:], uint32(v.Minimum))
	b += 4

	xgb.Put32(buf[b:], uint32(v.Maximum))
	b += 4

	return buf
}

// Write struct list AxisInfo
func AxisInfoListBytes(buf []byte, list []AxisInfo) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// 'ValuatorInfo' struct definition
// Size: (8 + xgb.Pad((int(AxesLen) * 12)))
type ValuatorInfo struct {
	ClassId    byte
	Len        byte
	AxesLen    byte
	Mode       byte
	MotionSize uint32
	Axes       []AxisInfo // size: xgb.Pad((int(AxesLen) * 12))
}

// Struct read ValuatorInfo
func ValuatorInfoRead(buf []byte, v *ValuatorInfo) 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 = xgb.Get32(buf[b:])
	b += 4

	v.Axes = make([]AxisInfo, v.AxesLen)
	b += AxisInfoReadList(buf[b:], v.Axes)

	return b
}

// Struct list read ValuatorInfo
func ValuatorInfoReadList(buf []byte, dest []ValuatorInfo) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = ValuatorInfo{}
		b += ValuatorInfoRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write ValuatorInfo
func (v ValuatorInfo) Bytes() []byte {
	buf := make([]byte, (8 + xgb.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

	xgb.Put32(buf[b:], v.MotionSize)
	b += 4

	b += AxisInfoListBytes(buf[b:], v.Axes)

	return buf
}

// Write struct list ValuatorInfo
func ValuatorInfoListBytes(buf []byte, list []ValuatorInfo) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// Struct list size ValuatorInfo
func ValuatorInfoListSize(list []ValuatorInfo) int {
	size := 0
	for _, item := range list {
		size += (8 + xgb.Pad((int(item.AxesLen) * 12)))
	}
	return size
}

// 'InputClassInfo' struct definition
// Size: 2
type InputClassInfo struct {
	ClassId       byte
	EventTypeBase byte
}

// Struct read InputClassInfo
func InputClassInfoRead(buf []byte, v *InputClassInfo) int {
	b := 0

	v.ClassId = buf[b]
	b += 1

	v.EventTypeBase = buf[b]
	b += 1

	return b
}

// Struct list read InputClassInfo
func InputClassInfoReadList(buf []byte, dest []InputClassInfo) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = InputClassInfo{}
		b += InputClassInfoRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write InputClassInfo
func (v InputClassInfo) 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 InputClassInfo
func InputClassInfoListBytes(buf []byte, list []InputClassInfo) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// 'DeviceTimeCoord' struct definition
// Size: 4
type DeviceTimeCoord struct {
	Time xproto.Timestamp
}

// Struct read DeviceTimeCoord
func DeviceTimeCoordRead(buf []byte, v *DeviceTimeCoord) int {
	b := 0

	v.Time = xproto.Timestamp(xgb.Get32(buf[b:]))
	b += 4

	return b
}

// Struct list read DeviceTimeCoord
func DeviceTimeCoordReadList(buf []byte, dest []DeviceTimeCoord) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = DeviceTimeCoord{}
		b += DeviceTimeCoordRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write DeviceTimeCoord
func (v DeviceTimeCoord) Bytes() []byte {
	buf := make([]byte, 4)
	b := 0

	xgb.Put32(buf[b:], uint32(v.Time))
	b += 4

	return buf
}

// Write struct list DeviceTimeCoord
func DeviceTimeCoordListBytes(buf []byte, list []DeviceTimeCoord) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// 'FeedbackState' struct definition
// Size: 4
type FeedbackState struct {
	ClassId byte
	Id      byte
	Len     uint16
}

// Struct read FeedbackState
func FeedbackStateRead(buf []byte, v *FeedbackState) int {
	b := 0

	v.ClassId = buf[b]
	b += 1

	v.Id = buf[b]
	b += 1

	v.Len = xgb.Get16(buf[b:])
	b += 2

	return b
}

// Struct list read FeedbackState
func FeedbackStateReadList(buf []byte, dest []FeedbackState) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = FeedbackState{}
		b += FeedbackStateRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write FeedbackState
func (v FeedbackState) Bytes() []byte {
	buf := make([]byte, 4)
	b := 0

	buf[b] = v.ClassId
	b += 1

	buf[b] = v.Id
	b += 1

	xgb.Put16(buf[b:], v.Len)
	b += 2

	return buf
}

// Write struct list FeedbackState
func FeedbackStateListBytes(buf []byte, list []FeedbackState) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// 'KbdFeedbackState' struct definition
// Size: 52
type KbdFeedbackState 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 KbdFeedbackState
func KbdFeedbackStateRead(buf []byte, v *KbdFeedbackState) int {
	b := 0

	v.ClassId = buf[b]
	b += 1

	v.Id = buf[b]
	b += 1

	v.Len = xgb.Get16(buf[b:])
	b += 2

	v.Pitch = xgb.Get16(buf[b:])
	b += 2

	v.Duration = xgb.Get16(buf[b:])
	b += 2

	v.LedMask = xgb.Get32(buf[b:])
	b += 4

	v.LedValues = xgb.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 += xgb.Pad(int(32))

	return b
}

// Struct list read KbdFeedbackState
func KbdFeedbackStateReadList(buf []byte, dest []KbdFeedbackState) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = KbdFeedbackState{}
		b += KbdFeedbackStateRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write KbdFeedbackState
func (v KbdFeedbackState) Bytes() []byte {
	buf := make([]byte, 52)
	b := 0

	buf[b] = v.ClassId
	b += 1

	buf[b] = v.Id
	b += 1

	xgb.Put16(buf[b:], v.Len)
	b += 2

	xgb.Put16(buf[b:], v.Pitch)
	b += 2

	xgb.Put16(buf[b:], v.Duration)
	b += 2

	xgb.Put32(buf[b:], v.LedMask)
	b += 4

	xgb.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 += xgb.Pad(int(32))

	return buf
}

// Write struct list KbdFeedbackState
func KbdFeedbackStateListBytes(buf []byte, list []KbdFeedbackState) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// Struct list size KbdFeedbackState
func KbdFeedbackStateListSize(list []KbdFeedbackState) int {
	size := 0
	for _ = range list {
		size += 52
	}
	return size
}

// 'PtrFeedbackState' struct definition
// Size: 12
type PtrFeedbackState struct {
	ClassId byte
	Id      byte
	Len     uint16
	// padding: 2 bytes
	AccelNum   uint16
	AccelDenom uint16
	Threshold  uint16
}

// Struct read PtrFeedbackState
func PtrFeedbackStateRead(buf []byte, v *PtrFeedbackState) int {
	b := 0

	v.ClassId = buf[b]
	b += 1

	v.Id = buf[b]
	b += 1

	v.Len = xgb.Get16(buf[b:])
	b += 2

	b += 2 // padding

	v.AccelNum = xgb.Get16(buf[b:])
	b += 2

	v.AccelDenom = xgb.Get16(buf[b:])
	b += 2

	v.Threshold = xgb.Get16(buf[b:])
	b += 2

	return b
}

// Struct list read PtrFeedbackState
func PtrFeedbackStateReadList(buf []byte, dest []PtrFeedbackState) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = PtrFeedbackState{}
		b += PtrFeedbackStateRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write PtrFeedbackState
func (v PtrFeedbackState) Bytes() []byte {
	buf := make([]byte, 12)
	b := 0

	buf[b] = v.ClassId
	b += 1

	buf[b] = v.Id
	b += 1

	xgb.Put16(buf[b:], v.Len)
	b += 2

	b += 2 // padding

	xgb.Put16(buf[b:], v.AccelNum)
	b += 2

	xgb.Put16(buf[b:], v.AccelDenom)
	b += 2

	xgb.Put16(buf[b:], v.Threshold)
	b += 2

	return buf
}

// Write struct list PtrFeedbackState
func PtrFeedbackStateListBytes(buf []byte, list []PtrFeedbackState) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// 'IntegerFeedbackState' struct definition
// Size: 16
type IntegerFeedbackState struct {
	ClassId    byte
	Id         byte
	Len        uint16
	Resolution uint32
	MinValue   int32
	MaxValue   int32
}

// Struct read IntegerFeedbackState
func IntegerFeedbackStateRead(buf []byte, v *IntegerFeedbackState) int {
	b := 0

	v.ClassId = buf[b]
	b += 1

	v.Id = buf[b]
	b += 1

	v.Len = xgb.Get16(buf[b:])
	b += 2

	v.Resolution = xgb.Get32(buf[b:])
	b += 4

	v.MinValue = int32(xgb.Get32(buf[b:]))
	b += 4

	v.MaxValue = int32(xgb.Get32(buf[b:]))
	b += 4

	return b
}

// Struct list read IntegerFeedbackState
func IntegerFeedbackStateReadList(buf []byte, dest []IntegerFeedbackState) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = IntegerFeedbackState{}
		b += IntegerFeedbackStateRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write IntegerFeedbackState
func (v IntegerFeedbackState) Bytes() []byte {
	buf := make([]byte, 16)
	b := 0

	buf[b] = v.ClassId
	b += 1

	buf[b] = v.Id
	b += 1

	xgb.Put16(buf[b:], v.Len)
	b += 2

	xgb.Put32(buf[b:], v.Resolution)
	b += 4

	xgb.Put32(buf[b:], uint32(v.MinValue))
	b += 4

	xgb.Put32(buf[b:], uint32(v.MaxValue))
	b += 4

	return buf
}

// Write struct list IntegerFeedbackState
func IntegerFeedbackStateListBytes(buf []byte, list []IntegerFeedbackState) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// 'StringFeedbackState' struct definition
// Size: (8 + xgb.Pad((int(NumKeysyms) * 4)))
type StringFeedbackState struct {
	ClassId    byte
	Id         byte
	Len        uint16
	MaxSymbols uint16
	NumKeysyms uint16
	Keysyms    []xproto.Keysym // size: xgb.Pad((int(NumKeysyms) * 4))
}

// Struct read StringFeedbackState
func StringFeedbackStateRead(buf []byte, v *StringFeedbackState) int {
	b := 0

	v.ClassId = buf[b]
	b += 1

	v.Id = buf[b]
	b += 1

	v.Len = xgb.Get16(buf[b:])
	b += 2

	v.MaxSymbols = xgb.Get16(buf[b:])
	b += 2

	v.NumKeysyms = xgb.Get16(buf[b:])
	b += 2

	v.Keysyms = make([]xproto.Keysym, v.NumKeysyms)
	for i := 0; i < int(v.NumKeysyms); i++ {
		v.Keysyms[i] = xproto.Keysym(xgb.Get32(buf[b:]))
		b += 4
	}
	b = xgb.Pad(b)

	return b
}

// Struct list read StringFeedbackState
func StringFeedbackStateReadList(buf []byte, dest []StringFeedbackState) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = StringFeedbackState{}
		b += StringFeedbackStateRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write StringFeedbackState
func (v StringFeedbackState) Bytes() []byte {
	buf := make([]byte, (8 + xgb.Pad((int(v.NumKeysyms) * 4))))
	b := 0

	buf[b] = v.ClassId
	b += 1

	buf[b] = v.Id
	b += 1

	xgb.Put16(buf[b:], v.Len)
	b += 2

	xgb.Put16(buf[b:], v.MaxSymbols)
	b += 2

	xgb.Put16(buf[b:], v.NumKeysyms)
	b += 2

	for i := 0; i < int(v.NumKeysyms); i++ {
		xgb.Put32(buf[b:], uint32(v.Keysyms[i]))
		b += 4
	}
	b = xgb.Pad(b)

	return buf
}

// Write struct list StringFeedbackState
func StringFeedbackStateListBytes(buf []byte, list []StringFeedbackState) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// Struct list size StringFeedbackState
func StringFeedbackStateListSize(list []StringFeedbackState) int {
	size := 0
	for _, item := range list {
		size += (8 + xgb.Pad((int(item.NumKeysyms) * 4)))
	}
	return size
}

// 'BellFeedbackState' struct definition
// Size: 12
type BellFeedbackState struct {
	ClassId byte
	Id      byte
	Len     uint16
	Percent byte
	// padding: 3 bytes
	Pitch    uint16
	Duration uint16
}

// Struct read BellFeedbackState
func BellFeedbackStateRead(buf []byte, v *BellFeedbackState) int {
	b := 0

	v.ClassId = buf[b]
	b += 1

	v.Id = buf[b]
	b += 1

	v.Len = xgb.Get16(buf[b:])
	b += 2

	v.Percent = buf[b]
	b += 1

	b += 3 // padding

	v.Pitch = xgb.Get16(buf[b:])
	b += 2

	v.Duration = xgb.Get16(buf[b:])
	b += 2

	return b
}

// Struct list read BellFeedbackState
func BellFeedbackStateReadList(buf []byte, dest []BellFeedbackState) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = BellFeedbackState{}
		b += BellFeedbackStateRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write BellFeedbackState
func (v BellFeedbackState) Bytes() []byte {
	buf := make([]byte, 12)
	b := 0

	buf[b] = v.ClassId
	b += 1

	buf[b] = v.Id
	b += 1

	xgb.Put16(buf[b:], v.Len)
	b += 2

	buf[b] = v.Percent
	b += 1

	b += 3 // padding

	xgb.Put16(buf[b:], v.Pitch)
	b += 2

	xgb.Put16(buf[b:], v.Duration)
	b += 2

	return buf
}

// Write struct list BellFeedbackState
func BellFeedbackStateListBytes(buf []byte, list []BellFeedbackState) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// 'LedFeedbackState' struct definition
// Size: 12
type LedFeedbackState struct {
	ClassId   byte
	Id        byte
	Len       uint16
	LedMask   uint32
	LedValues uint32
}

// Struct read LedFeedbackState
func LedFeedbackStateRead(buf []byte, v *LedFeedbackState) int {
	b := 0

	v.ClassId = buf[b]
	b += 1

	v.Id = buf[b]
	b += 1

	v.Len = xgb.Get16(buf[b:])
	b += 2

	v.LedMask = xgb.Get32(buf[b:])
	b += 4

	v.LedValues = xgb.Get32(buf[b:])
	b += 4

	return b
}

// Struct list read LedFeedbackState
func LedFeedbackStateReadList(buf []byte, dest []LedFeedbackState) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = LedFeedbackState{}
		b += LedFeedbackStateRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write LedFeedbackState
func (v LedFeedbackState) Bytes() []byte {
	buf := make([]byte, 12)
	b := 0

	buf[b] = v.ClassId
	b += 1

	buf[b] = v.Id
	b += 1

	xgb.Put16(buf[b:], v.Len)
	b += 2

	xgb.Put32(buf[b:], v.LedMask)
	b += 4

	xgb.Put32(buf[b:], v.LedValues)
	b += 4

	return buf
}

// Write struct list LedFeedbackState
func LedFeedbackStateListBytes(buf []byte, list []LedFeedbackState) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// 'FeedbackCtl' struct definition
// Size: 4
type FeedbackCtl struct {
	ClassId byte
	Id      byte
	Len     uint16
}

// Struct read FeedbackCtl
func FeedbackCtlRead(buf []byte, v *FeedbackCtl) int {
	b := 0

	v.ClassId = buf[b]
	b += 1

	v.Id = buf[b]
	b += 1

	v.Len = xgb.Get16(buf[b:])
	b += 2

	return b
}

// Struct list read FeedbackCtl
func FeedbackCtlReadList(buf []byte, dest []FeedbackCtl) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = FeedbackCtl{}
		b += FeedbackCtlRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write FeedbackCtl
func (v FeedbackCtl) Bytes() []byte {
	buf := make([]byte, 4)
	b := 0

	buf[b] = v.ClassId
	b += 1

	buf[b] = v.Id
	b += 1

	xgb.Put16(buf[b:], v.Len)
	b += 2

	return buf
}

// Write struct list FeedbackCtl
func FeedbackCtlListBytes(buf []byte, list []FeedbackCtl) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// 'KbdFeedbackCtl' struct definition
// Size: 20
type KbdFeedbackCtl struct {
	ClassId         byte
	Id              byte
	Len             uint16
	Key             KeyCode
	AutoRepeatMode  byte
	KeyClickPercent int8
	BellPercent     int8
	BellPitch       int16
	BellDuration    int16
	LedMask         uint32
	LedValues       uint32
}

// Struct read KbdFeedbackCtl
func KbdFeedbackCtlRead(buf []byte, v *KbdFeedbackCtl) int {
	b := 0

	v.ClassId = buf[b]
	b += 1

	v.Id = buf[b]
	b += 1

	v.Len = xgb.Get16(buf[b:])
	b += 2

	v.Key = KeyCode(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(xgb.Get16(buf[b:]))
	b += 2

	v.BellDuration = int16(xgb.Get16(buf[b:]))
	b += 2

	v.LedMask = xgb.Get32(buf[b:])
	b += 4

	v.LedValues = xgb.Get32(buf[b:])
	b += 4

	return b
}

// Struct list read KbdFeedbackCtl
func KbdFeedbackCtlReadList(buf []byte, dest []KbdFeedbackCtl) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = KbdFeedbackCtl{}
		b += KbdFeedbackCtlRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write KbdFeedbackCtl
func (v KbdFeedbackCtl) Bytes() []byte {
	buf := make([]byte, 20)
	b := 0

	buf[b] = v.ClassId
	b += 1

	buf[b] = v.Id
	b += 1

	xgb.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

	xgb.Put16(buf[b:], uint16(v.BellPitch))
	b += 2

	xgb.Put16(buf[b:], uint16(v.BellDuration))
	b += 2

	xgb.Put32(buf[b:], v.LedMask)
	b += 4

	xgb.Put32(buf[b:], v.LedValues)
	b += 4

	return buf
}

// Write struct list KbdFeedbackCtl
func KbdFeedbackCtlListBytes(buf []byte, list []KbdFeedbackCtl) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// 'PtrFeedbackCtl' struct definition
// Size: 12
type PtrFeedbackCtl struct {
	ClassId byte
	Id      byte
	Len     uint16
	// padding: 2 bytes
	Num       int16
	Denom     int16
	Threshold int16
}

// Struct read PtrFeedbackCtl
func PtrFeedbackCtlRead(buf []byte, v *PtrFeedbackCtl) int {
	b := 0

	v.ClassId = buf[b]
	b += 1

	v.Id = buf[b]
	b += 1

	v.Len = xgb.Get16(buf[b:])
	b += 2

	b += 2 // padding

	v.Num = int16(xgb.Get16(buf[b:]))
	b += 2

	v.Denom = int16(xgb.Get16(buf[b:]))
	b += 2

	v.Threshold = int16(xgb.Get16(buf[b:]))
	b += 2

	return b
}

// Struct list read PtrFeedbackCtl
func PtrFeedbackCtlReadList(buf []byte, dest []PtrFeedbackCtl) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = PtrFeedbackCtl{}
		b += PtrFeedbackCtlRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write PtrFeedbackCtl
func (v PtrFeedbackCtl) Bytes() []byte {
	buf := make([]byte, 12)
	b := 0

	buf[b] = v.ClassId
	b += 1

	buf[b] = v.Id
	b += 1

	xgb.Put16(buf[b:], v.Len)
	b += 2

	b += 2 // padding

	xgb.Put16(buf[b:], uint16(v.Num))
	b += 2

	xgb.Put16(buf[b:], uint16(v.Denom))
	b += 2

	xgb.Put16(buf[b:], uint16(v.Threshold))
	b += 2

	return buf
}

// Write struct list PtrFeedbackCtl
func PtrFeedbackCtlListBytes(buf []byte, list []PtrFeedbackCtl) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// 'IntegerFeedbackCtl' struct definition
// Size: 8
type IntegerFeedbackCtl struct {
	ClassId      byte
	Id           byte
	Len          uint16
	IntToDisplay int32
}

// Struct read IntegerFeedbackCtl
func IntegerFeedbackCtlRead(buf []byte, v *IntegerFeedbackCtl) int {
	b := 0

	v.ClassId = buf[b]
	b += 1

	v.Id = buf[b]
	b += 1

	v.Len = xgb.Get16(buf[b:])
	b += 2

	v.IntToDisplay = int32(xgb.Get32(buf[b:]))
	b += 4

	return b
}

// Struct list read IntegerFeedbackCtl
func IntegerFeedbackCtlReadList(buf []byte, dest []IntegerFeedbackCtl) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = IntegerFeedbackCtl{}
		b += IntegerFeedbackCtlRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write IntegerFeedbackCtl
func (v IntegerFeedbackCtl) Bytes() []byte {
	buf := make([]byte, 8)
	b := 0

	buf[b] = v.ClassId
	b += 1

	buf[b] = v.Id
	b += 1

	xgb.Put16(buf[b:], v.Len)
	b += 2

	xgb.Put32(buf[b:], uint32(v.IntToDisplay))
	b += 4

	return buf
}

// Write struct list IntegerFeedbackCtl
func IntegerFeedbackCtlListBytes(buf []byte, list []IntegerFeedbackCtl) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// 'StringFeedbackCtl' struct definition
// Size: (8 + xgb.Pad((int(NumKeysyms) * 4)))
type StringFeedbackCtl struct {
	ClassId byte
	Id      byte
	Len     uint16
	// padding: 2 bytes
	NumKeysyms uint16
	Keysyms    []xproto.Keysym // size: xgb.Pad((int(NumKeysyms) * 4))
}

// Struct read StringFeedbackCtl
func StringFeedbackCtlRead(buf []byte, v *StringFeedbackCtl) int {
	b := 0

	v.ClassId = buf[b]
	b += 1

	v.Id = buf[b]
	b += 1

	v.Len = xgb.Get16(buf[b:])
	b += 2

	b += 2 // padding

	v.NumKeysyms = xgb.Get16(buf[b:])
	b += 2

	v.Keysyms = make([]xproto.Keysym, v.NumKeysyms)
	for i := 0; i < int(v.NumKeysyms); i++ {
		v.Keysyms[i] = xproto.Keysym(xgb.Get32(buf[b:]))
		b += 4
	}
	b = xgb.Pad(b)

	return b
}

// Struct list read StringFeedbackCtl
func StringFeedbackCtlReadList(buf []byte, dest []StringFeedbackCtl) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = StringFeedbackCtl{}
		b += StringFeedbackCtlRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write StringFeedbackCtl
func (v StringFeedbackCtl) Bytes() []byte {
	buf := make([]byte, (8 + xgb.Pad((int(v.NumKeysyms) * 4))))
	b := 0

	buf[b] = v.ClassId
	b += 1

	buf[b] = v.Id
	b += 1

	xgb.Put16(buf[b:], v.Len)
	b += 2

	b += 2 // padding

	xgb.Put16(buf[b:], v.NumKeysyms)
	b += 2

	for i := 0; i < int(v.NumKeysyms); i++ {
		xgb.Put32(buf[b:], uint32(v.Keysyms[i]))
		b += 4
	}
	b = xgb.Pad(b)

	return buf
}

// Write struct list StringFeedbackCtl
func StringFeedbackCtlListBytes(buf []byte, list []StringFeedbackCtl) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// Struct list size StringFeedbackCtl
func StringFeedbackCtlListSize(list []StringFeedbackCtl) int {
	size := 0
	for _, item := range list {
		size += (8 + xgb.Pad((int(item.NumKeysyms) * 4)))
	}
	return size
}

// 'BellFeedbackCtl' struct definition
// Size: 12
type BellFeedbackCtl struct {
	ClassId byte
	Id      byte
	Len     uint16
	Percent int8
	// padding: 3 bytes
	Pitch    int16
	Duration int16
}

// Struct read BellFeedbackCtl
func BellFeedbackCtlRead(buf []byte, v *BellFeedbackCtl) int {
	b := 0

	v.ClassId = buf[b]
	b += 1

	v.Id = buf[b]
	b += 1

	v.Len = xgb.Get16(buf[b:])
	b += 2

	v.Percent = int8(buf[b])
	b += 1

	b += 3 // padding

	v.Pitch = int16(xgb.Get16(buf[b:]))
	b += 2

	v.Duration = int16(xgb.Get16(buf[b:]))
	b += 2

	return b
}

// Struct list read BellFeedbackCtl
func BellFeedbackCtlReadList(buf []byte, dest []BellFeedbackCtl) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = BellFeedbackCtl{}
		b += BellFeedbackCtlRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write BellFeedbackCtl
func (v BellFeedbackCtl) Bytes() []byte {
	buf := make([]byte, 12)
	b := 0

	buf[b] = v.ClassId
	b += 1

	buf[b] = v.Id
	b += 1

	xgb.Put16(buf[b:], v.Len)
	b += 2

	buf[b] = byte(v.Percent)
	b += 1

	b += 3 // padding

	xgb.Put16(buf[b:], uint16(v.Pitch))
	b += 2

	xgb.Put16(buf[b:], uint16(v.Duration))
	b += 2

	return buf
}

// Write struct list BellFeedbackCtl
func BellFeedbackCtlListBytes(buf []byte, list []BellFeedbackCtl) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// 'LedFeedbackCtl' struct definition
// Size: 12
type LedFeedbackCtl struct {
	ClassId   byte
	Id        byte
	Len       uint16
	LedMask   uint32
	LedValues uint32
}

// Struct read LedFeedbackCtl
func LedFeedbackCtlRead(buf []byte, v *LedFeedbackCtl) int {
	b := 0

	v.ClassId = buf[b]
	b += 1

	v.Id = buf[b]
	b += 1

	v.Len = xgb.Get16(buf[b:])
	b += 2

	v.LedMask = xgb.Get32(buf[b:])
	b += 4

	v.LedValues = xgb.Get32(buf[b:])
	b += 4

	return b
}

// Struct list read LedFeedbackCtl
func LedFeedbackCtlReadList(buf []byte, dest []LedFeedbackCtl) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = LedFeedbackCtl{}
		b += LedFeedbackCtlRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write LedFeedbackCtl
func (v LedFeedbackCtl) Bytes() []byte {
	buf := make([]byte, 12)
	b := 0

	buf[b] = v.ClassId
	b += 1

	buf[b] = v.Id
	b += 1

	xgb.Put16(buf[b:], v.Len)
	b += 2

	xgb.Put32(buf[b:], v.LedMask)
	b += 4

	xgb.Put32(buf[b:], v.LedValues)
	b += 4

	return buf
}

// Write struct list LedFeedbackCtl
func LedFeedbackCtlListBytes(buf []byte, list []LedFeedbackCtl) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// 'InputState' struct definition
// Size: 3
type InputState struct {
	ClassId  byte
	Len      byte
	NumItems byte
}

// Struct read InputState
func InputStateRead(buf []byte, v *InputState) 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 InputState
func InputStateReadList(buf []byte, dest []InputState) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = InputState{}
		b += InputStateRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write InputState
func (v InputState) 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 InputState
func InputStateListBytes(buf []byte, list []InputState) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// 'KeyState' struct definition
// Size: 36
type KeyState struct {
	ClassId byte
	Len     byte
	NumKeys byte
	// padding: 1 bytes
	Keys []byte // size: 32
}

// Struct read KeyState
func KeyStateRead(buf []byte, v *KeyState) 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 += xgb.Pad(int(32))

	return b
}

// Struct list read KeyState
func KeyStateReadList(buf []byte, dest []KeyState) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = KeyState{}
		b += KeyStateRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write KeyState
func (v KeyState) 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 += xgb.Pad(int(32))

	return buf
}

// Write struct list KeyState
func KeyStateListBytes(buf []byte, list []KeyState) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// Struct list size KeyState
func KeyStateListSize(list []KeyState) int {
	size := 0
	for _ = range list {
		size += 36
	}
	return size
}

// 'ButtonState' struct definition
// Size: 36
type ButtonState struct {
	ClassId    byte
	Len        byte
	NumButtons byte
	// padding: 1 bytes
	Buttons []byte // size: 32
}

// Struct read ButtonState
func ButtonStateRead(buf []byte, v *ButtonState) 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 += xgb.Pad(int(32))

	return b
}

// Struct list read ButtonState
func ButtonStateReadList(buf []byte, dest []ButtonState) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = ButtonState{}
		b += ButtonStateRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write ButtonState
func (v ButtonState) 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 += xgb.Pad(int(32))

	return buf
}

// Write struct list ButtonState
func ButtonStateListBytes(buf []byte, list []ButtonState) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// Struct list size ButtonState
func ButtonStateListSize(list []ButtonState) int {
	size := 0
	for _ = range list {
		size += 36
	}
	return size
}

// 'ValuatorState' struct definition
// Size: (4 + xgb.Pad((int(NumValuators) * 4)))
type ValuatorState struct {
	ClassId      byte
	Len          byte
	NumValuators byte
	Mode         byte
	Valuators    []uint32 // size: xgb.Pad((int(NumValuators) * 4))
}

// Struct read ValuatorState
func ValuatorStateRead(buf []byte, v *ValuatorState) 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] = xgb.Get32(buf[b:])
		b += 4
	}
	b = xgb.Pad(b)

	return b
}

// Struct list read ValuatorState
func ValuatorStateReadList(buf []byte, dest []ValuatorState) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = ValuatorState{}
		b += ValuatorStateRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write ValuatorState
func (v ValuatorState) Bytes() []byte {
	buf := make([]byte, (4 + xgb.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++ {
		xgb.Put32(buf[b:], v.Valuators[i])
		b += 4
	}
	b = xgb.Pad(b)

	return buf
}

// Write struct list ValuatorState
func ValuatorStateListBytes(buf []byte, list []ValuatorState) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// Struct list size ValuatorState
func ValuatorStateListSize(list []ValuatorState) int {
	size := 0
	for _, item := range list {
		size += (4 + xgb.Pad((int(item.NumValuators) * 4)))
	}
	return size
}

// 'DeviceState' struct definition
// Size: 4
type DeviceState struct {
	ControlId uint16
	Len       uint16
}

// Struct read DeviceState
func DeviceStateRead(buf []byte, v *DeviceState) int {
	b := 0

	v.ControlId = xgb.Get16(buf[b:])
	b += 2

	v.Len = xgb.Get16(buf[b:])
	b += 2

	return b
}

// Struct list read DeviceState
func DeviceStateReadList(buf []byte, dest []DeviceState) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = DeviceState{}
		b += DeviceStateRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write DeviceState
func (v DeviceState) Bytes() []byte {
	buf := make([]byte, 4)
	b := 0

	xgb.Put16(buf[b:], v.ControlId)
	b += 2

	xgb.Put16(buf[b:], v.Len)
	b += 2

	return buf
}

// Write struct list DeviceState
func DeviceStateListBytes(buf []byte, list []DeviceState) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// 'DeviceResolutionState' struct definition
// Size: (((8 + xgb.Pad((int(NumValuators) * 4))) + xgb.Pad((int(NumValuators) * 4))) + xgb.Pad((int(NumValuators) * 4)))
type DeviceResolutionState struct {
	ControlId        uint16
	Len              uint16
	NumValuators     uint32
	ResolutionValues []uint32 // size: xgb.Pad((int(NumValuators) * 4))
	ResolutionMin    []uint32 // size: xgb.Pad((int(NumValuators) * 4))
	ResolutionMax    []uint32 // size: xgb.Pad((int(NumValuators) * 4))
}

// Struct read DeviceResolutionState
func DeviceResolutionStateRead(buf []byte, v *DeviceResolutionState) int {
	b := 0

	v.ControlId = xgb.Get16(buf[b:])
	b += 2

	v.Len = xgb.Get16(buf[b:])
	b += 2

	v.NumValuators = xgb.Get32(buf[b:])
	b += 4

	v.ResolutionValues = make([]uint32, v.NumValuators)
	for i := 0; i < int(v.NumValuators); i++ {
		v.ResolutionValues[i] = xgb.Get32(buf[b:])
		b += 4
	}
	b = xgb.Pad(b)

	v.ResolutionMin = make([]uint32, v.NumValuators)
	for i := 0; i < int(v.NumValuators); i++ {
		v.ResolutionMin[i] = xgb.Get32(buf[b:])
		b += 4
	}
	b = xgb.Pad(b)

	v.ResolutionMax = make([]uint32, v.NumValuators)
	for i := 0; i < int(v.NumValuators); i++ {
		v.ResolutionMax[i] = xgb.Get32(buf[b:])
		b += 4
	}
	b = xgb.Pad(b)

	return b
}

// Struct list read DeviceResolutionState
func DeviceResolutionStateReadList(buf []byte, dest []DeviceResolutionState) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = DeviceResolutionState{}
		b += DeviceResolutionStateRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write DeviceResolutionState
func (v DeviceResolutionState) Bytes() []byte {
	buf := make([]byte, (((8 + xgb.Pad((int(v.NumValuators) * 4))) + xgb.Pad((int(v.NumValuators) * 4))) + xgb.Pad((int(v.NumValuators) * 4))))
	b := 0

	xgb.Put16(buf[b:], v.ControlId)
	b += 2

	xgb.Put16(buf[b:], v.Len)
	b += 2

	xgb.Put32(buf[b:], v.NumValuators)
	b += 4

	for i := 0; i < int(v.NumValuators); i++ {
		xgb.Put32(buf[b:], v.ResolutionValues[i])
		b += 4
	}
	b = xgb.Pad(b)

	for i := 0; i < int(v.NumValuators); i++ {
		xgb.Put32(buf[b:], v.ResolutionMin[i])
		b += 4
	}
	b = xgb.Pad(b)

	for i := 0; i < int(v.NumValuators); i++ {
		xgb.Put32(buf[b:], v.ResolutionMax[i])
		b += 4
	}
	b = xgb.Pad(b)

	return buf
}

// Write struct list DeviceResolutionState
func DeviceResolutionStateListBytes(buf []byte, list []DeviceResolutionState) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// Struct list size DeviceResolutionState
func DeviceResolutionStateListSize(list []DeviceResolutionState) int {
	size := 0
	for _, item := range list {
		size += (((8 + xgb.Pad((int(item.NumValuators) * 4))) + xgb.Pad((int(item.NumValuators) * 4))) + xgb.Pad((int(item.NumValuators) * 4)))
	}
	return size
}

// 'DeviceAbsCalibState' struct definition
// Size: 36
type DeviceAbsCalibState struct {
	ControlId       uint16
	Len             uint16
	MinX            int32
	MaxX            int32
	MinY            int32
	MaxY            int32
	FlipX           uint32
	FlipY           uint32
	Rotation        uint32
	ButtonThreshold uint32
}

// Struct read DeviceAbsCalibState
func DeviceAbsCalibStateRead(buf []byte, v *DeviceAbsCalibState) int {
	b := 0

	v.ControlId = xgb.Get16(buf[b:])
	b += 2

	v.Len = xgb.Get16(buf[b:])
	b += 2

	v.MinX = int32(xgb.Get32(buf[b:]))
	b += 4

	v.MaxX = int32(xgb.Get32(buf[b:]))
	b += 4

	v.MinY = int32(xgb.Get32(buf[b:]))
	b += 4

	v.MaxY = int32(xgb.Get32(buf[b:]))
	b += 4

	v.FlipX = xgb.Get32(buf[b:])
	b += 4

	v.FlipY = xgb.Get32(buf[b:])
	b += 4

	v.Rotation = xgb.Get32(buf[b:])
	b += 4

	v.ButtonThreshold = xgb.Get32(buf[b:])
	b += 4

	return b
}

// Struct list read DeviceAbsCalibState
func DeviceAbsCalibStateReadList(buf []byte, dest []DeviceAbsCalibState) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = DeviceAbsCalibState{}
		b += DeviceAbsCalibStateRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write DeviceAbsCalibState
func (v DeviceAbsCalibState) Bytes() []byte {
	buf := make([]byte, 36)
	b := 0

	xgb.Put16(buf[b:], v.ControlId)
	b += 2

	xgb.Put16(buf[b:], v.Len)
	b += 2

	xgb.Put32(buf[b:], uint32(v.MinX))
	b += 4

	xgb.Put32(buf[b:], uint32(v.MaxX))
	b += 4

	xgb.Put32(buf[b:], uint32(v.MinY))
	b += 4

	xgb.Put32(buf[b:], uint32(v.MaxY))
	b += 4

	xgb.Put32(buf[b:], v.FlipX)
	b += 4

	xgb.Put32(buf[b:], v.FlipY)
	b += 4

	xgb.Put32(buf[b:], v.Rotation)
	b += 4

	xgb.Put32(buf[b:], v.ButtonThreshold)
	b += 4

	return buf
}

// Write struct list DeviceAbsCalibState
func DeviceAbsCalibStateListBytes(buf []byte, list []DeviceAbsCalibState) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// 'DeviceAbsAreaState' struct definition
// Size: 28
type DeviceAbsAreaState struct {
	ControlId uint16
	Len       uint16
	OffsetX   uint32
	OffsetY   uint32
	Width     uint32
	Height    uint32
	Screen    uint32
	Following uint32
}

// Struct read DeviceAbsAreaState
func DeviceAbsAreaStateRead(buf []byte, v *DeviceAbsAreaState) int {
	b := 0

	v.ControlId = xgb.Get16(buf[b:])
	b += 2

	v.Len = xgb.Get16(buf[b:])
	b += 2

	v.OffsetX = xgb.Get32(buf[b:])
	b += 4

	v.OffsetY = xgb.Get32(buf[b:])
	b += 4

	v.Width = xgb.Get32(buf[b:])
	b += 4

	v.Height = xgb.Get32(buf[b:])
	b += 4

	v.Screen = xgb.Get32(buf[b:])
	b += 4

	v.Following = xgb.Get32(buf[b:])
	b += 4

	return b
}

// Struct list read DeviceAbsAreaState
func DeviceAbsAreaStateReadList(buf []byte, dest []DeviceAbsAreaState) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = DeviceAbsAreaState{}
		b += DeviceAbsAreaStateRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write DeviceAbsAreaState
func (v DeviceAbsAreaState) Bytes() []byte {
	buf := make([]byte, 28)
	b := 0

	xgb.Put16(buf[b:], v.ControlId)
	b += 2

	xgb.Put16(buf[b:], v.Len)
	b += 2

	xgb.Put32(buf[b:], v.OffsetX)
	b += 4

	xgb.Put32(buf[b:], v.OffsetY)
	b += 4

	xgb.Put32(buf[b:], v.Width)
	b += 4

	xgb.Put32(buf[b:], v.Height)
	b += 4

	xgb.Put32(buf[b:], v.Screen)
	b += 4

	xgb.Put32(buf[b:], v.Following)
	b += 4

	return buf
}

// Write struct list DeviceAbsAreaState
func DeviceAbsAreaStateListBytes(buf []byte, list []DeviceAbsAreaState) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// 'DeviceCoreState' struct definition
// Size: 8
type DeviceCoreState struct {
	ControlId uint16
	Len       uint16
	Status    byte
	Iscore    byte
	// padding: 2 bytes
}

// Struct read DeviceCoreState
func DeviceCoreStateRead(buf []byte, v *DeviceCoreState) int {
	b := 0

	v.ControlId = xgb.Get16(buf[b:])
	b += 2

	v.Len = xgb.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 DeviceCoreState
func DeviceCoreStateReadList(buf []byte, dest []DeviceCoreState) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = DeviceCoreState{}
		b += DeviceCoreStateRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write DeviceCoreState
func (v DeviceCoreState) Bytes() []byte {
	buf := make([]byte, 8)
	b := 0

	xgb.Put16(buf[b:], v.ControlId)
	b += 2

	xgb.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 DeviceCoreState
func DeviceCoreStateListBytes(buf []byte, list []DeviceCoreState) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// 'DeviceEnableState' struct definition
// Size: 8
type DeviceEnableState struct {
	ControlId uint16
	Len       uint16
	Enable    byte
	// padding: 3 bytes
}

// Struct read DeviceEnableState
func DeviceEnableStateRead(buf []byte, v *DeviceEnableState) int {
	b := 0

	v.ControlId = xgb.Get16(buf[b:])
	b += 2

	v.Len = xgb.Get16(buf[b:])
	b += 2

	v.Enable = buf[b]
	b += 1

	b += 3 // padding

	return b
}

// Struct list read DeviceEnableState
func DeviceEnableStateReadList(buf []byte, dest []DeviceEnableState) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = DeviceEnableState{}
		b += DeviceEnableStateRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write DeviceEnableState
func (v DeviceEnableState) Bytes() []byte {
	buf := make([]byte, 8)
	b := 0

	xgb.Put16(buf[b:], v.ControlId)
	b += 2

	xgb.Put16(buf[b:], v.Len)
	b += 2

	buf[b] = v.Enable
	b += 1

	b += 3 // padding

	return buf
}

// Write struct list DeviceEnableState
func DeviceEnableStateListBytes(buf []byte, list []DeviceEnableState) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// 'DeviceCtl' struct definition
// Size: 4
type DeviceCtl struct {
	ControlId uint16
	Len       uint16
}

// Struct read DeviceCtl
func DeviceCtlRead(buf []byte, v *DeviceCtl) int {
	b := 0

	v.ControlId = xgb.Get16(buf[b:])
	b += 2

	v.Len = xgb.Get16(buf[b:])
	b += 2

	return b
}

// Struct list read DeviceCtl
func DeviceCtlReadList(buf []byte, dest []DeviceCtl) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = DeviceCtl{}
		b += DeviceCtlRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write DeviceCtl
func (v DeviceCtl) Bytes() []byte {
	buf := make([]byte, 4)
	b := 0

	xgb.Put16(buf[b:], v.ControlId)
	b += 2

	xgb.Put16(buf[b:], v.Len)
	b += 2

	return buf
}

// Write struct list DeviceCtl
func DeviceCtlListBytes(buf []byte, list []DeviceCtl) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// 'DeviceResolutionCtl' struct definition
// Size: (6 + xgb.Pad((int(NumValuators) * 4)))
type DeviceResolutionCtl struct {
	ControlId        uint16
	Len              uint16
	FirstValuator    byte
	NumValuators     byte
	ResolutionValues []uint32 // size: xgb.Pad((int(NumValuators) * 4))
}

// Struct read DeviceResolutionCtl
func DeviceResolutionCtlRead(buf []byte, v *DeviceResolutionCtl) int {
	b := 0

	v.ControlId = xgb.Get16(buf[b:])
	b += 2

	v.Len = xgb.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] = xgb.Get32(buf[b:])
		b += 4
	}
	b = xgb.Pad(b)

	return b
}

// Struct list read DeviceResolutionCtl
func DeviceResolutionCtlReadList(buf []byte, dest []DeviceResolutionCtl) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = DeviceResolutionCtl{}
		b += DeviceResolutionCtlRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write DeviceResolutionCtl
func (v DeviceResolutionCtl) Bytes() []byte {
	buf := make([]byte, (6 + xgb.Pad((int(v.NumValuators) * 4))))
	b := 0

	xgb.Put16(buf[b:], v.ControlId)
	b += 2

	xgb.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++ {
		xgb.Put32(buf[b:], v.ResolutionValues[i])
		b += 4
	}
	b = xgb.Pad(b)

	return buf
}

// Write struct list DeviceResolutionCtl
func DeviceResolutionCtlListBytes(buf []byte, list []DeviceResolutionCtl) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// Struct list size DeviceResolutionCtl
func DeviceResolutionCtlListSize(list []DeviceResolutionCtl) int {
	size := 0
	for _, item := range list {
		size += (6 + xgb.Pad((int(item.NumValuators) * 4)))
	}
	return size
}

// 'DeviceAbsCalibCtl' struct definition
// Size: 36
type DeviceAbsCalibCtl struct {
	ControlId       uint16
	Len             uint16
	MinX            int32
	MaxX            int32
	MinY            int32
	MaxY            int32
	FlipX           uint32
	FlipY           uint32
	Rotation        uint32
	ButtonThreshold uint32
}

// Struct read DeviceAbsCalibCtl
func DeviceAbsCalibCtlRead(buf []byte, v *DeviceAbsCalibCtl) int {
	b := 0

	v.ControlId = xgb.Get16(buf[b:])
	b += 2

	v.Len = xgb.Get16(buf[b:])
	b += 2

	v.MinX = int32(xgb.Get32(buf[b:]))
	b += 4

	v.MaxX = int32(xgb.Get32(buf[b:]))
	b += 4

	v.MinY = int32(xgb.Get32(buf[b:]))
	b += 4

	v.MaxY = int32(xgb.Get32(buf[b:]))
	b += 4

	v.FlipX = xgb.Get32(buf[b:])
	b += 4

	v.FlipY = xgb.Get32(buf[b:])
	b += 4

	v.Rotation = xgb.Get32(buf[b:])
	b += 4

	v.ButtonThreshold = xgb.Get32(buf[b:])
	b += 4

	return b
}

// Struct list read DeviceAbsCalibCtl
func DeviceAbsCalibCtlReadList(buf []byte, dest []DeviceAbsCalibCtl) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = DeviceAbsCalibCtl{}
		b += DeviceAbsCalibCtlRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write DeviceAbsCalibCtl
func (v DeviceAbsCalibCtl) Bytes() []byte {
	buf := make([]byte, 36)
	b := 0

	xgb.Put16(buf[b:], v.ControlId)
	b += 2

	xgb.Put16(buf[b:], v.Len)
	b += 2

	xgb.Put32(buf[b:], uint32(v.MinX))
	b += 4

	xgb.Put32(buf[b:], uint32(v.MaxX))
	b += 4

	xgb.Put32(buf[b:], uint32(v.MinY))
	b += 4

	xgb.Put32(buf[b:], uint32(v.MaxY))
	b += 4

	xgb.Put32(buf[b:], v.FlipX)
	b += 4

	xgb.Put32(buf[b:], v.FlipY)
	b += 4

	xgb.Put32(buf[b:], v.Rotation)
	b += 4

	xgb.Put32(buf[b:], v.ButtonThreshold)
	b += 4

	return buf
}

// Write struct list DeviceAbsCalibCtl
func DeviceAbsCalibCtlListBytes(buf []byte, list []DeviceAbsCalibCtl) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// 'DeviceAbsAreaCtrl' struct definition
// Size: 28
type DeviceAbsAreaCtrl struct {
	ControlId uint16
	Len       uint16
	OffsetX   uint32
	OffsetY   uint32
	Width     int32
	Height    int32
	Screen    int32
	Following uint32
}

// Struct read DeviceAbsAreaCtrl
func DeviceAbsAreaCtrlRead(buf []byte, v *DeviceAbsAreaCtrl) int {
	b := 0

	v.ControlId = xgb.Get16(buf[b:])
	b += 2

	v.Len = xgb.Get16(buf[b:])
	b += 2

	v.OffsetX = xgb.Get32(buf[b:])
	b += 4

	v.OffsetY = xgb.Get32(buf[b:])
	b += 4

	v.Width = int32(xgb.Get32(buf[b:]))
	b += 4

	v.Height = int32(xgb.Get32(buf[b:]))
	b += 4

	v.Screen = int32(xgb.Get32(buf[b:]))
	b += 4

	v.Following = xgb.Get32(buf[b:])
	b += 4

	return b
}

// Struct list read DeviceAbsAreaCtrl
func DeviceAbsAreaCtrlReadList(buf []byte, dest []DeviceAbsAreaCtrl) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = DeviceAbsAreaCtrl{}
		b += DeviceAbsAreaCtrlRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write DeviceAbsAreaCtrl
func (v DeviceAbsAreaCtrl) Bytes() []byte {
	buf := make([]byte, 28)
	b := 0

	xgb.Put16(buf[b:], v.ControlId)
	b += 2

	xgb.Put16(buf[b:], v.Len)
	b += 2

	xgb.Put32(buf[b:], v.OffsetX)
	b += 4

	xgb.Put32(buf[b:], v.OffsetY)
	b += 4

	xgb.Put32(buf[b:], uint32(v.Width))
	b += 4

	xgb.Put32(buf[b:], uint32(v.Height))
	b += 4

	xgb.Put32(buf[b:], uint32(v.Screen))
	b += 4

	xgb.Put32(buf[b:], v.Following)
	b += 4

	return buf
}

// Write struct list DeviceAbsAreaCtrl
func DeviceAbsAreaCtrlListBytes(buf []byte, list []DeviceAbsAreaCtrl) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// 'DeviceCoreCtrl' struct definition
// Size: 8
type DeviceCoreCtrl struct {
	ControlId uint16
	Len       uint16
	Status    byte
	// padding: 3 bytes
}

// Struct read DeviceCoreCtrl
func DeviceCoreCtrlRead(buf []byte, v *DeviceCoreCtrl) int {
	b := 0

	v.ControlId = xgb.Get16(buf[b:])
	b += 2

	v.Len = xgb.Get16(buf[b:])
	b += 2

	v.Status = buf[b]
	b += 1

	b += 3 // padding

	return b
}

// Struct list read DeviceCoreCtrl
func DeviceCoreCtrlReadList(buf []byte, dest []DeviceCoreCtrl) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = DeviceCoreCtrl{}
		b += DeviceCoreCtrlRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write DeviceCoreCtrl
func (v DeviceCoreCtrl) Bytes() []byte {
	buf := make([]byte, 8)
	b := 0

	xgb.Put16(buf[b:], v.ControlId)
	b += 2

	xgb.Put16(buf[b:], v.Len)
	b += 2

	buf[b] = v.Status
	b += 1

	b += 3 // padding

	return buf
}

// Write struct list DeviceCoreCtrl
func DeviceCoreCtrlListBytes(buf []byte, list []DeviceCoreCtrl) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// 'DeviceEnableCtrl' struct definition
// Size: 8
type DeviceEnableCtrl struct {
	ControlId uint16
	Len       uint16
	Enable    byte
	// padding: 3 bytes
}

// Struct read DeviceEnableCtrl
func DeviceEnableCtrlRead(buf []byte, v *DeviceEnableCtrl) int {
	b := 0

	v.ControlId = xgb.Get16(buf[b:])
	b += 2

	v.Len = xgb.Get16(buf[b:])
	b += 2

	v.Enable = buf[b]
	b += 1

	b += 3 // padding

	return b
}

// Struct list read DeviceEnableCtrl
func DeviceEnableCtrlReadList(buf []byte, dest []DeviceEnableCtrl) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = DeviceEnableCtrl{}
		b += DeviceEnableCtrlRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Struct write DeviceEnableCtrl
func (v DeviceEnableCtrl) Bytes() []byte {
	buf := make([]byte, 8)
	b := 0

	xgb.Put16(buf[b:], v.ControlId)
	b += 2

	xgb.Put16(buf[b:], v.Len)
	b += 2

	buf[b] = v.Enable
	b += 1

	b += 3 // padding

	return buf
}

// Write struct list DeviceEnableCtrl
func DeviceEnableCtrlListBytes(buf []byte, list []DeviceEnableCtrl) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}
	return b
}

// Event definition DeviceValuator (0)
// Size: 32

const DeviceValuator = 0

type DeviceValuatorEvent struct {
	Sequence      uint16
	DeviceId      byte
	DeviceState   uint16
	NumValuators  byte
	FirstValuator byte
	Valuators     []int32 // size: 24
}

// Event read DeviceValuator
func DeviceValuatorEventNew(buf []byte) xgb.Event {
	v := DeviceValuatorEvent{}
	b := 1 // don't read event number

	v.DeviceId = buf[b]
	b += 1

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.DeviceState = xgb.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(xgb.Get32(buf[b:]))
		b += 4
	}
	b = xgb.Pad(b)

	return v
}

// Event write DeviceValuator
func (v DeviceValuatorEvent) 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

	xgb.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++ {
		xgb.Put32(buf[b:], uint32(v.Valuators[i]))
		b += 4
	}
	b = xgb.Pad(b)

	return buf
}

func (v DeviceValuatorEvent) ImplementsEvent() {}

func (v DeviceValuatorEvent) SequenceId() uint16 {
	return v.Sequence
}

func (v DeviceValuatorEvent) String() string {
	fieldVals := make([]string, 0, 5)
	fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", v.Sequence))
	fieldVals = append(fieldVals, xgb.Sprintf("DeviceId: %d", v.DeviceId))
	fieldVals = append(fieldVals, xgb.Sprintf("DeviceState: %d", v.DeviceState))
	fieldVals = append(fieldVals, xgb.Sprintf("NumValuators: %d", v.NumValuators))
	fieldVals = append(fieldVals, xgb.Sprintf("FirstValuator: %d", v.FirstValuator))
	return "DeviceValuator {" + xgb.StringsJoin(fieldVals, ", ") + "}"
}

func init() {
	xgb.NewExtEventFuncs["XInputExtension"][0] = DeviceValuatorEventNew
}

// Event definition DeviceKeyPress (1)
// Size: 32

const DeviceKeyPress = 1

type DeviceKeyPressEvent struct {
	Sequence   uint16
	Detail     byte
	Time       xproto.Timestamp
	Root       xproto.Window
	Event      xproto.Window
	Child      xproto.Window
	RootX      int16
	RootY      int16
	EventX     int16
	EventY     int16
	State      uint16
	SameScreen bool
	DeviceId   byte
}

// Event read DeviceKeyPress
func DeviceKeyPressEventNew(buf []byte) xgb.Event {
	v := DeviceKeyPressEvent{}
	b := 1 // don't read event number

	v.Detail = buf[b]
	b += 1

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Time = xproto.Timestamp(xgb.Get32(buf[b:]))
	b += 4

	v.Root = xproto.Window(xgb.Get32(buf[b:]))
	b += 4

	v.Event = xproto.Window(xgb.Get32(buf[b:]))
	b += 4

	v.Child = xproto.Window(xgb.Get32(buf[b:]))
	b += 4

	v.RootX = int16(xgb.Get16(buf[b:]))
	b += 2

	v.RootY = int16(xgb.Get16(buf[b:]))
	b += 2

	v.EventX = int16(xgb.Get16(buf[b:]))
	b += 2

	v.EventY = int16(xgb.Get16(buf[b:]))
	b += 2

	v.State = xgb.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 DeviceKeyPress
func (v DeviceKeyPressEvent) 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

	xgb.Put32(buf[b:], uint32(v.Time))
	b += 4

	xgb.Put32(buf[b:], uint32(v.Root))
	b += 4

	xgb.Put32(buf[b:], uint32(v.Event))
	b += 4

	xgb.Put32(buf[b:], uint32(v.Child))
	b += 4

	xgb.Put16(buf[b:], uint16(v.RootX))
	b += 2

	xgb.Put16(buf[b:], uint16(v.RootY))
	b += 2

	xgb.Put16(buf[b:], uint16(v.EventX))
	b += 2

	xgb.Put16(buf[b:], uint16(v.EventY))
	b += 2

	xgb.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 DeviceKeyPressEvent) ImplementsEvent() {}

func (v DeviceKeyPressEvent) SequenceId() uint16 {
	return v.Sequence
}

func (v DeviceKeyPressEvent) String() string {
	fieldVals := make([]string, 0, 12)
	fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", v.Sequence))
	fieldVals = append(fieldVals, xgb.Sprintf("Detail: %d", v.Detail))
	fieldVals = append(fieldVals, xgb.Sprintf("Time: %d", v.Time))
	fieldVals = append(fieldVals, xgb.Sprintf("Root: %d", v.Root))
	fieldVals = append(fieldVals, xgb.Sprintf("Event: %d", v.Event))
	fieldVals = append(fieldVals, xgb.Sprintf("Child: %d", v.Child))
	fieldVals = append(fieldVals, xgb.Sprintf("RootX: %d", v.RootX))
	fieldVals = append(fieldVals, xgb.Sprintf("RootY: %d", v.RootY))
	fieldVals = append(fieldVals, xgb.Sprintf("EventX: %d", v.EventX))
	fieldVals = append(fieldVals, xgb.Sprintf("EventY: %d", v.EventY))
	fieldVals = append(fieldVals, xgb.Sprintf("State: %d", v.State))
	fieldVals = append(fieldVals, xgb.Sprintf("SameScreen: %t", v.SameScreen))
	fieldVals = append(fieldVals, xgb.Sprintf("DeviceId: %d", v.DeviceId))
	return "DeviceKeyPress {" + xgb.StringsJoin(fieldVals, ", ") + "}"
}

func init() {
	xgb.NewExtEventFuncs["XInputExtension"][1] = DeviceKeyPressEventNew
}

// Event definition FocusIn (6)
// Size: 32

const FocusIn = 6

type FocusInEvent struct {
	Sequence uint16
	Detail   byte
	Time     xproto.Timestamp
	Window   xproto.Window
	Mode     byte
	DeviceId byte
	// padding: 18 bytes
}

// Event read FocusIn
func FocusInEventNew(buf []byte) xgb.Event {
	v := FocusInEvent{}
	b := 1 // don't read event number

	v.Detail = buf[b]
	b += 1

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Time = xproto.Timestamp(xgb.Get32(buf[b:]))
	b += 4

	v.Window = xproto.Window(xgb.Get32(buf[b:]))
	b += 4

	v.Mode = buf[b]
	b += 1

	v.DeviceId = buf[b]
	b += 1

	b += 18 // padding

	return v
}

// Event write FocusIn
func (v FocusInEvent) 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

	xgb.Put32(buf[b:], uint32(v.Time))
	b += 4

	xgb.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 FocusInEvent) ImplementsEvent() {}

func (v FocusInEvent) SequenceId() uint16 {
	return v.Sequence
}

func (v FocusInEvent) String() string {
	fieldVals := make([]string, 0, 6)
	fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", v.Sequence))
	fieldVals = append(fieldVals, xgb.Sprintf("Detail: %d", v.Detail))
	fieldVals = append(fieldVals, xgb.Sprintf("Time: %d", v.Time))
	fieldVals = append(fieldVals, xgb.Sprintf("Window: %d", v.Window))
	fieldVals = append(fieldVals, xgb.Sprintf("Mode: %d", v.Mode))
	fieldVals = append(fieldVals, xgb.Sprintf("DeviceId: %d", v.DeviceId))
	return "FocusIn {" + xgb.StringsJoin(fieldVals, ", ") + "}"
}

func init() {
	xgb.NewExtEventFuncs["XInputExtension"][6] = FocusInEventNew
}

// Event definition DeviceStateNotify (10)
// Size: 32

const DeviceStateNotify = 10

type DeviceStateNotifyEvent struct {
	Sequence        uint16
	DeviceId        byte
	Time            xproto.Timestamp
	NumKeys         byte
	NumButtons      byte
	NumValuators    byte
	ClassesReported byte
	Buttons         []byte   // size: 4
	Keys            []byte   // size: 4
	Valuators       []uint32 // size: 12
}

// Event read DeviceStateNotify
func DeviceStateNotifyEventNew(buf []byte) xgb.Event {
	v := DeviceStateNotifyEvent{}
	b := 1 // don't read event number

	v.DeviceId = buf[b]
	b += 1

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Time = xproto.Timestamp(xgb.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 += xgb.Pad(int(4))

	v.Keys = make([]byte, 4)
	copy(v.Keys[:4], buf[b:])
	b += xgb.Pad(int(4))

	v.Valuators = make([]uint32, 3)
	for i := 0; i < int(3); i++ {
		v.Valuators[i] = xgb.Get32(buf[b:])
		b += 4
	}
	b = xgb.Pad(b)

	return v
}

// Event write DeviceStateNotify
func (v DeviceStateNotifyEvent) 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

	xgb.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 += xgb.Pad(int(4))

	copy(buf[b:], v.Keys[:4])
	b += xgb.Pad(int(4))

	for i := 0; i < int(3); i++ {
		xgb.Put32(buf[b:], v.Valuators[i])
		b += 4
	}
	b = xgb.Pad(b)

	return buf
}

func (v DeviceStateNotifyEvent) ImplementsEvent() {}

func (v DeviceStateNotifyEvent) SequenceId() uint16 {
	return v.Sequence
}

func (v DeviceStateNotifyEvent) String() string {
	fieldVals := make([]string, 0, 9)
	fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", v.Sequence))
	fieldVals = append(fieldVals, xgb.Sprintf("DeviceId: %d", v.DeviceId))
	fieldVals = append(fieldVals, xgb.Sprintf("Time: %d", v.Time))
	fieldVals = append(fieldVals, xgb.Sprintf("NumKeys: %d", v.NumKeys))
	fieldVals = append(fieldVals, xgb.Sprintf("NumButtons: %d", v.NumButtons))
	fieldVals = append(fieldVals, xgb.Sprintf("NumValuators: %d", v.NumValuators))
	fieldVals = append(fieldVals, xgb.Sprintf("ClassesReported: %d", v.ClassesReported))
	return "DeviceStateNotify {" + xgb.StringsJoin(fieldVals, ", ") + "}"
}

func init() {
	xgb.NewExtEventFuncs["XInputExtension"][10] = DeviceStateNotifyEventNew
}

// Event definition DeviceMappingNotify (11)
// Size: 32

const DeviceMappingNotify = 11

type DeviceMappingNotifyEvent struct {
	Sequence     uint16
	DeviceId     byte
	Request      byte
	FirstKeycode KeyCode
	Count        byte
	// padding: 1 bytes
	Time xproto.Timestamp
	// padding: 20 bytes
}

// Event read DeviceMappingNotify
func DeviceMappingNotifyEventNew(buf []byte) xgb.Event {
	v := DeviceMappingNotifyEvent{}
	b := 1 // don't read event number

	v.DeviceId = buf[b]
	b += 1

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Request = buf[b]
	b += 1

	v.FirstKeycode = KeyCode(buf[b])
	b += 1

	v.Count = buf[b]
	b += 1

	b += 1 // padding

	v.Time = xproto.Timestamp(xgb.Get32(buf[b:]))
	b += 4

	b += 20 // padding

	return v
}

// Event write DeviceMappingNotify
func (v DeviceMappingNotifyEvent) 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

	xgb.Put32(buf[b:], uint32(v.Time))
	b += 4

	b += 20 // padding

	return buf
}

func (v DeviceMappingNotifyEvent) ImplementsEvent() {}

func (v DeviceMappingNotifyEvent) SequenceId() uint16 {
	return v.Sequence
}

func (v DeviceMappingNotifyEvent) String() string {
	fieldVals := make([]string, 0, 7)
	fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", v.Sequence))
	fieldVals = append(fieldVals, xgb.Sprintf("DeviceId: %d", v.DeviceId))
	fieldVals = append(fieldVals, xgb.Sprintf("Request: %d", v.Request))
	fieldVals = append(fieldVals, xgb.Sprintf("FirstKeycode: %d", v.FirstKeycode))
	fieldVals = append(fieldVals, xgb.Sprintf("Count: %d", v.Count))
	fieldVals = append(fieldVals, xgb.Sprintf("Time: %d", v.Time))
	return "DeviceMappingNotify {" + xgb.StringsJoin(fieldVals, ", ") + "}"
}

func init() {
	xgb.NewExtEventFuncs["XInputExtension"][11] = DeviceMappingNotifyEventNew
}

// Event definition ChangeDeviceNotify (12)
// Size: 32

const ChangeDeviceNotify = 12

type ChangeDeviceNotifyEvent struct {
	Sequence uint16
	DeviceId byte
	Time     xproto.Timestamp
	Request  byte
	// padding: 23 bytes
}

// Event read ChangeDeviceNotify
func ChangeDeviceNotifyEventNew(buf []byte) xgb.Event {
	v := ChangeDeviceNotifyEvent{}
	b := 1 // don't read event number

	v.DeviceId = buf[b]
	b += 1

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Time = xproto.Timestamp(xgb.Get32(buf[b:]))
	b += 4

	v.Request = buf[b]
	b += 1

	b += 23 // padding

	return v
}

// Event write ChangeDeviceNotify
func (v ChangeDeviceNotifyEvent) 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

	xgb.Put32(buf[b:], uint32(v.Time))
	b += 4

	buf[b] = v.Request
	b += 1

	b += 23 // padding

	return buf
}

func (v ChangeDeviceNotifyEvent) ImplementsEvent() {}

func (v ChangeDeviceNotifyEvent) SequenceId() uint16 {
	return v.Sequence
}

func (v ChangeDeviceNotifyEvent) String() string {
	fieldVals := make([]string, 0, 4)
	fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", v.Sequence))
	fieldVals = append(fieldVals, xgb.Sprintf("DeviceId: %d", v.DeviceId))
	fieldVals = append(fieldVals, xgb.Sprintf("Time: %d", v.Time))
	fieldVals = append(fieldVals, xgb.Sprintf("Request: %d", v.Request))
	return "ChangeDeviceNotify {" + xgb.StringsJoin(fieldVals, ", ") + "}"
}

func init() {
	xgb.NewExtEventFuncs["XInputExtension"][12] = ChangeDeviceNotifyEventNew
}

// Event definition DeviceKeyStateNotify (13)
// Size: 32

const DeviceKeyStateNotify = 13

type DeviceKeyStateNotifyEvent struct {
	Sequence uint16
	DeviceId byte
	Keys     []byte // size: 28
}

// Event read DeviceKeyStateNotify
func DeviceKeyStateNotifyEventNew(buf []byte) xgb.Event {
	v := DeviceKeyStateNotifyEvent{}
	b := 1 // don't read event number

	v.DeviceId = buf[b]
	b += 1

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Keys = make([]byte, 28)
	copy(v.Keys[:28], buf[b:])
	b += xgb.Pad(int(28))

	return v
}

// Event write DeviceKeyStateNotify
func (v DeviceKeyStateNotifyEvent) 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 += xgb.Pad(int(28))

	return buf
}

func (v DeviceKeyStateNotifyEvent) ImplementsEvent() {}

func (v DeviceKeyStateNotifyEvent) SequenceId() uint16 {
	return v.Sequence
}

func (v DeviceKeyStateNotifyEvent) String() string {
	fieldVals := make([]string, 0, 2)
	fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", v.Sequence))
	fieldVals = append(fieldVals, xgb.Sprintf("DeviceId: %d", v.DeviceId))
	return "DeviceKeyStateNotify {" + xgb.StringsJoin(fieldVals, ", ") + "}"
}

func init() {
	xgb.NewExtEventFuncs["XInputExtension"][13] = DeviceKeyStateNotifyEventNew
}

// Event definition DeviceButtonStateNotify (14)
// Size: 32

const DeviceButtonStateNotify = 14

type DeviceButtonStateNotifyEvent struct {
	Sequence uint16
	DeviceId byte
	Buttons  []byte // size: 28
}

// Event read DeviceButtonStateNotify
func DeviceButtonStateNotifyEventNew(buf []byte) xgb.Event {
	v := DeviceButtonStateNotifyEvent{}
	b := 1 // don't read event number

	v.DeviceId = buf[b]
	b += 1

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Buttons = make([]byte, 28)
	copy(v.Buttons[:28], buf[b:])
	b += xgb.Pad(int(28))

	return v
}

// Event write DeviceButtonStateNotify
func (v DeviceButtonStateNotifyEvent) 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 += xgb.Pad(int(28))

	return buf
}

func (v DeviceButtonStateNotifyEvent) ImplementsEvent() {}

func (v DeviceButtonStateNotifyEvent) SequenceId() uint16 {
	return v.Sequence
}

func (v DeviceButtonStateNotifyEvent) String() string {
	fieldVals := make([]string, 0, 2)
	fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", v.Sequence))
	fieldVals = append(fieldVals, xgb.Sprintf("DeviceId: %d", v.DeviceId))
	return "DeviceButtonStateNotify {" + xgb.StringsJoin(fieldVals, ", ") + "}"
}

func init() {
	xgb.NewExtEventFuncs["XInputExtension"][14] = DeviceButtonStateNotifyEventNew
}

// Event definition DevicePresenceNotify (15)
// Size: 32

const DevicePresenceNotify = 15

type DevicePresenceNotifyEvent struct {
	Sequence uint16
	// padding: 1 bytes
	Time      xproto.Timestamp
	Devchange byte
	DeviceId  byte
	Control   uint16
	// padding: 20 bytes
}

// Event read DevicePresenceNotify
func DevicePresenceNotifyEventNew(buf []byte) xgb.Event {
	v := DevicePresenceNotifyEvent{}
	b := 1 // don't read event number

	b += 1 // padding

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Time = xproto.Timestamp(xgb.Get32(buf[b:]))
	b += 4

	v.Devchange = buf[b]
	b += 1

	v.DeviceId = buf[b]
	b += 1

	v.Control = xgb.Get16(buf[b:])
	b += 2

	b += 20 // padding

	return v
}

// Event write DevicePresenceNotify
func (v DevicePresenceNotifyEvent) Bytes() []byte {
	buf := make([]byte, 32)
	b := 0

	// write event number
	buf[b] = 15
	b += 1

	b += 1 // padding

	b += 2 // skip sequence number

	xgb.Put32(buf[b:], uint32(v.Time))
	b += 4

	buf[b] = v.Devchange
	b += 1

	buf[b] = v.DeviceId
	b += 1

	xgb.Put16(buf[b:], v.Control)
	b += 2

	b += 20 // padding

	return buf
}

func (v DevicePresenceNotifyEvent) ImplementsEvent() {}

func (v DevicePresenceNotifyEvent) SequenceId() uint16 {
	return v.Sequence
}

func (v DevicePresenceNotifyEvent) String() string {
	fieldVals := make([]string, 0, 6)
	fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", v.Sequence))
	fieldVals = append(fieldVals, xgb.Sprintf("Time: %d", v.Time))
	fieldVals = append(fieldVals, xgb.Sprintf("Devchange: %d", v.Devchange))
	fieldVals = append(fieldVals, xgb.Sprintf("DeviceId: %d", v.DeviceId))
	fieldVals = append(fieldVals, xgb.Sprintf("Control: %d", v.Control))
	return "DevicePresenceNotify {" + xgb.StringsJoin(fieldVals, ", ") + "}"
}

func init() {
	xgb.NewExtEventFuncs["XInputExtension"][15] = DevicePresenceNotifyEventNew
}

// EventCopy definition DeviceKeyRelease (2)

const DeviceKeyRelease = 2

type DeviceKeyReleaseEvent DeviceKeyPressEvent

func DeviceKeyReleaseEventNew(buf []byte) xgb.Event {
	return DeviceKeyReleaseEvent(DeviceKeyPressEventNew(buf).(DeviceKeyPressEvent))
}

func (v DeviceKeyReleaseEvent) Bytes() []byte {
	return DeviceKeyPressEvent(v).Bytes()
}

func (v DeviceKeyReleaseEvent) ImplementsEvent() {}

func (v DeviceKeyReleaseEvent) SequenceId() uint16 {
	return v.Sequence
}

func (v DeviceKeyReleaseEvent) String() string {
	fieldVals := make([]string, 0, 12)
	fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", v.Sequence))
	fieldVals = append(fieldVals, xgb.Sprintf("Detail: %d", v.Detail))
	fieldVals = append(fieldVals, xgb.Sprintf("Time: %d", v.Time))
	fieldVals = append(fieldVals, xgb.Sprintf("Root: %d", v.Root))
	fieldVals = append(fieldVals, xgb.Sprintf("Event: %d", v.Event))
	fieldVals = append(fieldVals, xgb.Sprintf("Child: %d", v.Child))
	fieldVals = append(fieldVals, xgb.Sprintf("RootX: %d", v.RootX))
	fieldVals = append(fieldVals, xgb.Sprintf("RootY: %d", v.RootY))
	fieldVals = append(fieldVals, xgb.Sprintf("EventX: %d", v.EventX))
	fieldVals = append(fieldVals, xgb.Sprintf("EventY: %d", v.EventY))
	fieldVals = append(fieldVals, xgb.Sprintf("State: %d", v.State))
	fieldVals = append(fieldVals, xgb.Sprintf("SameScreen: %t", v.SameScreen))
	fieldVals = append(fieldVals, xgb.Sprintf("DeviceId: %d", v.DeviceId))
	return "DeviceKeyRelease {" + xgb.StringsJoin(fieldVals, ", ") + "}"
}

func init() {
	xgb.NewExtEventFuncs["XInputExtension"][2] = DeviceKeyReleaseEventNew
}

// EventCopy definition DeviceButtonPress (3)

const DeviceButtonPress = 3

type DeviceButtonPressEvent DeviceKeyPressEvent

func DeviceButtonPressEventNew(buf []byte) xgb.Event {
	return DeviceButtonPressEvent(DeviceKeyPressEventNew(buf).(DeviceKeyPressEvent))
}

func (v DeviceButtonPressEvent) Bytes() []byte {
	return DeviceKeyPressEvent(v).Bytes()
}

func (v DeviceButtonPressEvent) ImplementsEvent() {}

func (v DeviceButtonPressEvent) SequenceId() uint16 {
	return v.Sequence
}

func (v DeviceButtonPressEvent) String() string {
	fieldVals := make([]string, 0, 12)
	fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", v.Sequence))
	fieldVals = append(fieldVals, xgb.Sprintf("Detail: %d", v.Detail))
	fieldVals = append(fieldVals, xgb.Sprintf("Time: %d", v.Time))
	fieldVals = append(fieldVals, xgb.Sprintf("Root: %d", v.Root))
	fieldVals = append(fieldVals, xgb.Sprintf("Event: %d", v.Event))
	fieldVals = append(fieldVals, xgb.Sprintf("Child: %d", v.Child))
	fieldVals = append(fieldVals, xgb.Sprintf("RootX: %d", v.RootX))
	fieldVals = append(fieldVals, xgb.Sprintf("RootY: %d", v.RootY))
	fieldVals = append(fieldVals, xgb.Sprintf("EventX: %d", v.EventX))
	fieldVals = append(fieldVals, xgb.Sprintf("EventY: %d", v.EventY))
	fieldVals = append(fieldVals, xgb.Sprintf("State: %d", v.State))
	fieldVals = append(fieldVals, xgb.Sprintf("SameScreen: %t", v.SameScreen))
	fieldVals = append(fieldVals, xgb.Sprintf("DeviceId: %d", v.DeviceId))
	return "DeviceButtonPress {" + xgb.StringsJoin(fieldVals, ", ") + "}"
}

func init() {
	xgb.NewExtEventFuncs["XInputExtension"][3] = DeviceButtonPressEventNew
}

// EventCopy definition DeviceButtonRelease (4)

const DeviceButtonRelease = 4

type DeviceButtonReleaseEvent DeviceKeyPressEvent

func DeviceButtonReleaseEventNew(buf []byte) xgb.Event {
	return DeviceButtonReleaseEvent(DeviceKeyPressEventNew(buf).(DeviceKeyPressEvent))
}

func (v DeviceButtonReleaseEvent) Bytes() []byte {
	return DeviceKeyPressEvent(v).Bytes()
}

func (v DeviceButtonReleaseEvent) ImplementsEvent() {}

func (v DeviceButtonReleaseEvent) SequenceId() uint16 {
	return v.Sequence
}

func (v DeviceButtonReleaseEvent) String() string {
	fieldVals := make([]string, 0, 12)
	fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", v.Sequence))
	fieldVals = append(fieldVals, xgb.Sprintf("Detail: %d", v.Detail))
	fieldVals = append(fieldVals, xgb.Sprintf("Time: %d", v.Time))
	fieldVals = append(fieldVals, xgb.Sprintf("Root: %d", v.Root))
	fieldVals = append(fieldVals, xgb.Sprintf("Event: %d", v.Event))
	fieldVals = append(fieldVals, xgb.Sprintf("Child: %d", v.Child))
	fieldVals = append(fieldVals, xgb.Sprintf("RootX: %d", v.RootX))
	fieldVals = append(fieldVals, xgb.Sprintf("RootY: %d", v.RootY))
	fieldVals = append(fieldVals, xgb.Sprintf("EventX: %d", v.EventX))
	fieldVals = append(fieldVals, xgb.Sprintf("EventY: %d", v.EventY))
	fieldVals = append(fieldVals, xgb.Sprintf("State: %d", v.State))
	fieldVals = append(fieldVals, xgb.Sprintf("SameScreen: %t", v.SameScreen))
	fieldVals = append(fieldVals, xgb.Sprintf("DeviceId: %d", v.DeviceId))
	return "DeviceButtonRelease {" + xgb.StringsJoin(fieldVals, ", ") + "}"
}

func init() {
	xgb.NewExtEventFuncs["XInputExtension"][4] = DeviceButtonReleaseEventNew
}

// EventCopy definition DeviceMotionNotify (5)

const DeviceMotionNotify = 5

type DeviceMotionNotifyEvent DeviceKeyPressEvent

func DeviceMotionNotifyEventNew(buf []byte) xgb.Event {
	return DeviceMotionNotifyEvent(DeviceKeyPressEventNew(buf).(DeviceKeyPressEvent))
}

func (v DeviceMotionNotifyEvent) Bytes() []byte {
	return DeviceKeyPressEvent(v).Bytes()
}

func (v DeviceMotionNotifyEvent) ImplementsEvent() {}

func (v DeviceMotionNotifyEvent) SequenceId() uint16 {
	return v.Sequence
}

func (v DeviceMotionNotifyEvent) String() string {
	fieldVals := make([]string, 0, 12)
	fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", v.Sequence))
	fieldVals = append(fieldVals, xgb.Sprintf("Detail: %d", v.Detail))
	fieldVals = append(fieldVals, xgb.Sprintf("Time: %d", v.Time))
	fieldVals = append(fieldVals, xgb.Sprintf("Root: %d", v.Root))
	fieldVals = append(fieldVals, xgb.Sprintf("Event: %d", v.Event))
	fieldVals = append(fieldVals, xgb.Sprintf("Child: %d", v.Child))
	fieldVals = append(fieldVals, xgb.Sprintf("RootX: %d", v.RootX))
	fieldVals = append(fieldVals, xgb.Sprintf("RootY: %d", v.RootY))
	fieldVals = append(fieldVals, xgb.Sprintf("EventX: %d", v.EventX))
	fieldVals = append(fieldVals, xgb.Sprintf("EventY: %d", v.EventY))
	fieldVals = append(fieldVals, xgb.Sprintf("State: %d", v.State))
	fieldVals = append(fieldVals, xgb.Sprintf("SameScreen: %t", v.SameScreen))
	fieldVals = append(fieldVals, xgb.Sprintf("DeviceId: %d", v.DeviceId))
	return "DeviceMotionNotify {" + xgb.StringsJoin(fieldVals, ", ") + "}"
}

func init() {
	xgb.NewExtEventFuncs["XInputExtension"][5] = DeviceMotionNotifyEventNew
}

// EventCopy definition ProximityIn (8)

const ProximityIn = 8

type ProximityInEvent DeviceKeyPressEvent

func ProximityInEventNew(buf []byte) xgb.Event {
	return ProximityInEvent(DeviceKeyPressEventNew(buf).(DeviceKeyPressEvent))
}

func (v ProximityInEvent) Bytes() []byte {
	return DeviceKeyPressEvent(v).Bytes()
}

func (v ProximityInEvent) ImplementsEvent() {}

func (v ProximityInEvent) SequenceId() uint16 {
	return v.Sequence
}

func (v ProximityInEvent) String() string {
	fieldVals := make([]string, 0, 12)
	fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", v.Sequence))
	fieldVals = append(fieldVals, xgb.Sprintf("Detail: %d", v.Detail))
	fieldVals = append(fieldVals, xgb.Sprintf("Time: %d", v.Time))
	fieldVals = append(fieldVals, xgb.Sprintf("Root: %d", v.Root))
	fieldVals = append(fieldVals, xgb.Sprintf("Event: %d", v.Event))
	fieldVals = append(fieldVals, xgb.Sprintf("Child: %d", v.Child))
	fieldVals = append(fieldVals, xgb.Sprintf("RootX: %d", v.RootX))
	fieldVals = append(fieldVals, xgb.Sprintf("RootY: %d", v.RootY))
	fieldVals = append(fieldVals, xgb.Sprintf("EventX: %d", v.EventX))
	fieldVals = append(fieldVals, xgb.Sprintf("EventY: %d", v.EventY))
	fieldVals = append(fieldVals, xgb.Sprintf("State: %d", v.State))
	fieldVals = append(fieldVals, xgb.Sprintf("SameScreen: %t", v.SameScreen))
	fieldVals = append(fieldVals, xgb.Sprintf("DeviceId: %d", v.DeviceId))
	return "ProximityIn {" + xgb.StringsJoin(fieldVals, ", ") + "}"
}

func init() {
	xgb.NewExtEventFuncs["XInputExtension"][8] = ProximityInEventNew
}

// EventCopy definition ProximityOut (9)

const ProximityOut = 9

type ProximityOutEvent DeviceKeyPressEvent

func ProximityOutEventNew(buf []byte) xgb.Event {
	return ProximityOutEvent(DeviceKeyPressEventNew(buf).(DeviceKeyPressEvent))
}

func (v ProximityOutEvent) Bytes() []byte {
	return DeviceKeyPressEvent(v).Bytes()
}

func (v ProximityOutEvent) ImplementsEvent() {}

func (v ProximityOutEvent) SequenceId() uint16 {
	return v.Sequence
}

func (v ProximityOutEvent) String() string {
	fieldVals := make([]string, 0, 12)
	fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", v.Sequence))
	fieldVals = append(fieldVals, xgb.Sprintf("Detail: %d", v.Detail))
	fieldVals = append(fieldVals, xgb.Sprintf("Time: %d", v.Time))
	fieldVals = append(fieldVals, xgb.Sprintf("Root: %d", v.Root))
	fieldVals = append(fieldVals, xgb.Sprintf("Event: %d", v.Event))
	fieldVals = append(fieldVals, xgb.Sprintf("Child: %d", v.Child))
	fieldVals = append(fieldVals, xgb.Sprintf("RootX: %d", v.RootX))
	fieldVals = append(fieldVals, xgb.Sprintf("RootY: %d", v.RootY))
	fieldVals = append(fieldVals, xgb.Sprintf("EventX: %d", v.EventX))
	fieldVals = append(fieldVals, xgb.Sprintf("EventY: %d", v.EventY))
	fieldVals = append(fieldVals, xgb.Sprintf("State: %d", v.State))
	fieldVals = append(fieldVals, xgb.Sprintf("SameScreen: %t", v.SameScreen))
	fieldVals = append(fieldVals, xgb.Sprintf("DeviceId: %d", v.DeviceId))
	return "ProximityOut {" + xgb.StringsJoin(fieldVals, ", ") + "}"
}

func init() {
	xgb.NewExtEventFuncs["XInputExtension"][9] = ProximityOutEventNew
}

// EventCopy definition FocusOut (7)

const FocusOut = 7

type FocusOutEvent FocusInEvent

func FocusOutEventNew(buf []byte) xgb.Event {
	return FocusOutEvent(FocusInEventNew(buf).(FocusInEvent))
}

func (v FocusOutEvent) Bytes() []byte {
	return FocusInEvent(v).Bytes()
}

func (v FocusOutEvent) ImplementsEvent() {}

func (v FocusOutEvent) SequenceId() uint16 {
	return v.Sequence
}

func (v FocusOutEvent) String() string {
	fieldVals := make([]string, 0, 6)
	fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", v.Sequence))
	fieldVals = append(fieldVals, xgb.Sprintf("Detail: %d", v.Detail))
	fieldVals = append(fieldVals, xgb.Sprintf("Time: %d", v.Time))
	fieldVals = append(fieldVals, xgb.Sprintf("Window: %d", v.Window))
	fieldVals = append(fieldVals, xgb.Sprintf("Mode: %d", v.Mode))
	fieldVals = append(fieldVals, xgb.Sprintf("DeviceId: %d", v.DeviceId))
	return "FocusOut {" + xgb.StringsJoin(fieldVals, ", ") + "}"
}

func init() {
	xgb.NewExtEventFuncs["XInputExtension"][7] = FocusOutEventNew
}

// Error definition Device (0)
// Size: 32

const BadDevice = 0

type DeviceError struct {
	Sequence uint16
	NiceName string
}

// Error read Device
func DeviceErrorNew(buf []byte) xgb.Error {
	v := DeviceError{}
	v.NiceName = "Device"

	b := 1 // skip error determinant
	b += 1 // don't read error number

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	return v
}

func (err DeviceError) ImplementsError() {}

func (err DeviceError) SequenceId() uint16 {
	return err.Sequence
}

func (err DeviceError) BadId() uint32 {
	return 0
}

func (err DeviceError) Error() string {
	fieldVals := make([]string, 0, 0)
	fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
	fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", err.Sequence))
	return "BadDevice {" + xgb.StringsJoin(fieldVals, ", ") + "}"
}

func init() {
	xgb.NewExtErrorFuncs["XInputExtension"][0] = DeviceErrorNew
}

// Error definition Event (1)
// Size: 32

const BadEvent = 1

type EventError struct {
	Sequence uint16
	NiceName string
}

// Error read Event
func EventErrorNew(buf []byte) xgb.Error {
	v := EventError{}
	v.NiceName = "Event"

	b := 1 // skip error determinant
	b += 1 // don't read error number

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	return v
}

func (err EventError) ImplementsError() {}

func (err EventError) SequenceId() uint16 {
	return err.Sequence
}

func (err EventError) BadId() uint32 {
	return 0
}

func (err EventError) Error() string {
	fieldVals := make([]string, 0, 0)
	fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
	fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", err.Sequence))
	return "BadEvent {" + xgb.StringsJoin(fieldVals, ", ") + "}"
}

func init() {
	xgb.NewExtErrorFuncs["XInputExtension"][1] = EventErrorNew
}

// Error definition Mode (2)
// Size: 32

const BadMode = 2

type ModeError struct {
	Sequence uint16
	NiceName string
}

// Error read Mode
func ModeErrorNew(buf []byte) xgb.Error {
	v := ModeError{}
	v.NiceName = "Mode"

	b := 1 // skip error determinant
	b += 1 // don't read error number

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	return v
}

func (err ModeError) ImplementsError() {}

func (err ModeError) SequenceId() uint16 {
	return err.Sequence
}

func (err ModeError) BadId() uint32 {
	return 0
}

func (err ModeError) Error() string {
	fieldVals := make([]string, 0, 0)
	fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
	fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", err.Sequence))
	return "BadMode {" + xgb.StringsJoin(fieldVals, ", ") + "}"
}

func init() {
	xgb.NewExtErrorFuncs["XInputExtension"][2] = ModeErrorNew
}

// Error definition DeviceBusy (3)
// Size: 32

const BadDeviceBusy = 3

type DeviceBusyError struct {
	Sequence uint16
	NiceName string
}

// Error read DeviceBusy
func DeviceBusyErrorNew(buf []byte) xgb.Error {
	v := DeviceBusyError{}
	v.NiceName = "DeviceBusy"

	b := 1 // skip error determinant
	b += 1 // don't read error number

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	return v
}

func (err DeviceBusyError) ImplementsError() {}

func (err DeviceBusyError) SequenceId() uint16 {
	return err.Sequence
}

func (err DeviceBusyError) BadId() uint32 {
	return 0
}

func (err DeviceBusyError) Error() string {
	fieldVals := make([]string, 0, 0)
	fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
	fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", err.Sequence))
	return "BadDeviceBusy {" + xgb.StringsJoin(fieldVals, ", ") + "}"
}

func init() {
	xgb.NewExtErrorFuncs["XInputExtension"][3] = DeviceBusyErrorNew
}

// Error definition Class (4)
// Size: 32

const BadClass = 4

type ClassError struct {
	Sequence uint16
	NiceName string
}

// Error read Class
func ClassErrorNew(buf []byte) xgb.Error {
	v := ClassError{}
	v.NiceName = "Class"

	b := 1 // skip error determinant
	b += 1 // don't read error number

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	return v
}

func (err ClassError) ImplementsError() {}

func (err ClassError) SequenceId() uint16 {
	return err.Sequence
}

func (err ClassError) BadId() uint32 {
	return 0
}

func (err ClassError) Error() string {
	fieldVals := make([]string, 0, 0)
	fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
	fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", err.Sequence))
	return "BadClass {" + xgb.StringsJoin(fieldVals, ", ") + "}"
}

func init() {
	xgb.NewExtErrorFuncs["XInputExtension"][4] = ClassErrorNew
}

// Request GetExtensionVersion
// size: xgb.Pad((8 + xgb.Pad((int(NameLen) * 1))))
type GetExtensionVersionCookie struct {
	*xgb.Cookie
}

func GetExtensionVersion(c *xgb.Conn, NameLen uint16, Name string) GetExtensionVersionCookie {
	cookie := c.NewCookie(true, true)
	c.NewRequest(getExtensionVersionRequest(c, NameLen, Name), cookie)
	return GetExtensionVersionCookie{cookie}
}

func GetExtensionVersionUnchecked(c *xgb.Conn, NameLen uint16, Name string) GetExtensionVersionCookie {
	cookie := c.NewCookie(false, true)
	c.NewRequest(getExtensionVersionRequest(c, NameLen, Name), cookie)
	return GetExtensionVersionCookie{cookie}
}

// Request reply for GetExtensionVersion
// size: 32
type GetExtensionVersionReply struct {
	Sequence uint16
	Length   uint32
	// padding: 1 bytes
	ServerMajor uint16
	ServerMinor uint16
	Present     bool
	// padding: 19 bytes
}

// Waits and reads reply data from request GetExtensionVersion
func (cook GetExtensionVersionCookie) Reply() (*GetExtensionVersionReply, error) {
	buf, err := cook.Cookie.Reply()
	if err != nil {
		return nil, err
	}
	if buf == nil {
		return nil, nil
	}
	return getExtensionVersionReply(buf), nil
}

// Read reply into structure from buffer for GetExtensionVersion
func getExtensionVersionReply(buf []byte) *GetExtensionVersionReply {
	v := new(GetExtensionVersionReply)
	b := 1 // skip reply determinant

	b += 1 // padding

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Length = xgb.Get32(buf[b:]) // 4-byte units
	b += 4

	v.ServerMajor = xgb.Get16(buf[b:])
	b += 2

	v.ServerMinor = xgb.Get16(buf[b:])
	b += 2

	if buf[b] == 1 {
		v.Present = true
	} else {
		v.Present = false
	}
	b += 1

	b += 19 // padding

	return v
}

// Write request to wire for GetExtensionVersion
func getExtensionVersionRequest(c *xgb.Conn, NameLen uint16, Name string) []byte {
	size := xgb.Pad((8 + xgb.Pad((int(NameLen) * 1))))
	b := 0
	buf := make([]byte, size)

	buf[b] = c.Extensions["XINPUTEXTENSION"]
	b += 1

	buf[b] = 1 // request opcode
	b += 1

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	xgb.Put16(buf[b:], NameLen)
	b += 2

	b += 2 // padding

	copy(buf[b:], Name[:NameLen])
	b += xgb.Pad(int(NameLen))

	return buf
}

// Request ListInputDevices
// size: 4
type ListInputDevicesCookie struct {
	*xgb.Cookie
}

func ListInputDevices(c *xgb.Conn) ListInputDevicesCookie {
	cookie := c.NewCookie(true, true)
	c.NewRequest(listInputDevicesRequest(c), cookie)
	return ListInputDevicesCookie{cookie}
}

func ListInputDevicesUnchecked(c *xgb.Conn) ListInputDevicesCookie {
	cookie := c.NewCookie(false, true)
	c.NewRequest(listInputDevicesRequest(c), cookie)
	return ListInputDevicesCookie{cookie}
}

// Request reply for ListInputDevices
// size: (32 + xgb.Pad((int(DevicesLen) * 8)))
type ListInputDevicesReply struct {
	Sequence uint16
	Length   uint32
	// padding: 1 bytes
	DevicesLen byte
	// padding: 23 bytes
	Devices []DeviceInfo // size: xgb.Pad((int(DevicesLen) * 8))
}

// Waits and reads reply data from request ListInputDevices
func (cook ListInputDevicesCookie) Reply() (*ListInputDevicesReply, error) {
	buf, err := cook.Cookie.Reply()
	if err != nil {
		return nil, err
	}
	if buf == nil {
		return nil, nil
	}
	return listInputDevicesReply(buf), nil
}

// Read reply into structure from buffer for ListInputDevices
func listInputDevicesReply(buf []byte) *ListInputDevicesReply {
	v := new(ListInputDevicesReply)
	b := 1 // skip reply determinant

	b += 1 // padding

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Length = xgb.Get32(buf[b:]) // 4-byte units
	b += 4

	v.DevicesLen = buf[b]
	b += 1

	b += 23 // padding

	v.Devices = make([]DeviceInfo, v.DevicesLen)
	b += DeviceInfoReadList(buf[b:], v.Devices)

	return v
}

// Write request to wire for ListInputDevices
func listInputDevicesRequest(c *xgb.Conn) []byte {
	size := 4
	b := 0
	buf := make([]byte, size)

	buf[b] = c.Extensions["XINPUTEXTENSION"]
	b += 1

	buf[b] = 2 // request opcode
	b += 1

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	return buf
}

// Request OpenDevice
// size: 8
type OpenDeviceCookie struct {
	*xgb.Cookie
}

func OpenDevice(c *xgb.Conn, DeviceId byte) OpenDeviceCookie {
	cookie := c.NewCookie(true, true)
	c.NewRequest(openDeviceRequest(c, DeviceId), cookie)
	return OpenDeviceCookie{cookie}
}

func OpenDeviceUnchecked(c *xgb.Conn, DeviceId byte) OpenDeviceCookie {
	cookie := c.NewCookie(false, true)
	c.NewRequest(openDeviceRequest(c, DeviceId), cookie)
	return OpenDeviceCookie{cookie}
}

// Request reply for OpenDevice
// size: (32 + xgb.Pad((int(NumClasses) * 2)))
type OpenDeviceReply struct {
	Sequence uint16
	Length   uint32
	// padding: 1 bytes
	NumClasses byte
	// padding: 23 bytes
	ClassInfo []InputClassInfo // size: xgb.Pad((int(NumClasses) * 2))
}

// Waits and reads reply data from request OpenDevice
func (cook OpenDeviceCookie) Reply() (*OpenDeviceReply, error) {
	buf, err := cook.Cookie.Reply()
	if err != nil {
		return nil, err
	}
	if buf == nil {
		return nil, nil
	}
	return openDeviceReply(buf), nil
}

// Read reply into structure from buffer for OpenDevice
func openDeviceReply(buf []byte) *OpenDeviceReply {
	v := new(OpenDeviceReply)
	b := 1 // skip reply determinant

	b += 1 // padding

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Length = xgb.Get32(buf[b:]) // 4-byte units
	b += 4

	v.NumClasses = buf[b]
	b += 1

	b += 23 // padding

	v.ClassInfo = make([]InputClassInfo, v.NumClasses)
	b += InputClassInfoReadList(buf[b:], v.ClassInfo)

	return v
}

// Write request to wire for OpenDevice
func openDeviceRequest(c *xgb.Conn, 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

	xgb.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 CloseDevice
// size: 8
type CloseDeviceCookie struct {
	*xgb.Cookie
}

// Write request to wire for CloseDevice
func CloseDevice(c *xgb.Conn, DeviceId byte) CloseDeviceCookie {
	cookie := c.NewCookie(false, false)
	c.NewRequest(closeDeviceRequest(c, DeviceId), cookie)
	return CloseDeviceCookie{cookie}
}

func CloseDeviceChecked(c *xgb.Conn, DeviceId byte) CloseDeviceCookie {
	cookie := c.NewCookie(true, false)
	c.NewRequest(closeDeviceRequest(c, DeviceId), cookie)
	return CloseDeviceCookie{cookie}
}

func (cook CloseDeviceCookie) Check() error {
	return cook.Cookie.Check()
}

// Write request to wire for CloseDevice
func closeDeviceRequest(c *xgb.Conn, 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

	xgb.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 SetDeviceMode
// size: 8
type SetDeviceModeCookie struct {
	*xgb.Cookie
}

func SetDeviceMode(c *xgb.Conn, DeviceId byte, Mode byte) SetDeviceModeCookie {
	cookie := c.NewCookie(true, true)
	c.NewRequest(setDeviceModeRequest(c, DeviceId, Mode), cookie)
	return SetDeviceModeCookie{cookie}
}

func SetDeviceModeUnchecked(c *xgb.Conn, DeviceId byte, Mode byte) SetDeviceModeCookie {
	cookie := c.NewCookie(false, true)
	c.NewRequest(setDeviceModeRequest(c, DeviceId, Mode), cookie)
	return SetDeviceModeCookie{cookie}
}

// Request reply for SetDeviceMode
// size: 32
type SetDeviceModeReply struct {
	Sequence uint16
	Length   uint32
	// padding: 1 bytes
	Status byte
	// padding: 23 bytes
}

// Waits and reads reply data from request SetDeviceMode
func (cook SetDeviceModeCookie) Reply() (*SetDeviceModeReply, error) {
	buf, err := cook.Cookie.Reply()
	if err != nil {
		return nil, err
	}
	if buf == nil {
		return nil, nil
	}
	return setDeviceModeReply(buf), nil
}

// Read reply into structure from buffer for SetDeviceMode
func setDeviceModeReply(buf []byte) *SetDeviceModeReply {
	v := new(SetDeviceModeReply)
	b := 1 // skip reply determinant

	b += 1 // padding

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Length = xgb.Get32(buf[b:]) // 4-byte units
	b += 4

	v.Status = buf[b]
	b += 1

	b += 23 // padding

	return v
}

// Write request to wire for SetDeviceMode
func setDeviceModeRequest(c *xgb.Conn, 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

	xgb.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 SelectExtensionEvent
// size: xgb.Pad((12 + xgb.Pad((int(NumClasses) * 4))))
type SelectExtensionEventCookie struct {
	*xgb.Cookie
}

// Write request to wire for SelectExtensionEvent
func SelectExtensionEvent(c *xgb.Conn, Window xproto.Window, NumClasses uint16, Classes []EventClass) SelectExtensionEventCookie {
	cookie := c.NewCookie(false, false)
	c.NewRequest(selectExtensionEventRequest(c, Window, NumClasses, Classes), cookie)
	return SelectExtensionEventCookie{cookie}
}

func SelectExtensionEventChecked(c *xgb.Conn, Window xproto.Window, NumClasses uint16, Classes []EventClass) SelectExtensionEventCookie {
	cookie := c.NewCookie(true, false)
	c.NewRequest(selectExtensionEventRequest(c, Window, NumClasses, Classes), cookie)
	return SelectExtensionEventCookie{cookie}
}

func (cook SelectExtensionEventCookie) Check() error {
	return cook.Cookie.Check()
}

// Write request to wire for SelectExtensionEvent
func selectExtensionEventRequest(c *xgb.Conn, Window xproto.Window, NumClasses uint16, Classes []EventClass) []byte {
	size := xgb.Pad((12 + xgb.Pad((int(NumClasses) * 4))))
	b := 0
	buf := make([]byte, size)

	buf[b] = c.Extensions["XINPUTEXTENSION"]
	b += 1

	buf[b] = 6 // request opcode
	b += 1

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	xgb.Put32(buf[b:], uint32(Window))
	b += 4

	xgb.Put16(buf[b:], NumClasses)
	b += 2

	b += 2 // padding

	for i := 0; i < int(NumClasses); i++ {
		xgb.Put32(buf[b:], uint32(Classes[i]))
		b += 4
	}
	b = xgb.Pad(b)

	return buf
}

// Request GetSelectedExtensionEvents
// size: 8
type GetSelectedExtensionEventsCookie struct {
	*xgb.Cookie
}

func GetSelectedExtensionEvents(c *xgb.Conn, Window xproto.Window) GetSelectedExtensionEventsCookie {
	cookie := c.NewCookie(true, true)
	c.NewRequest(getSelectedExtensionEventsRequest(c, Window), cookie)
	return GetSelectedExtensionEventsCookie{cookie}
}

func GetSelectedExtensionEventsUnchecked(c *xgb.Conn, Window xproto.Window) GetSelectedExtensionEventsCookie {
	cookie := c.NewCookie(false, true)
	c.NewRequest(getSelectedExtensionEventsRequest(c, Window), cookie)
	return GetSelectedExtensionEventsCookie{cookie}
}

// Request reply for GetSelectedExtensionEvents
// size: ((32 + xgb.Pad((int(NumThisClasses) * 4))) + xgb.Pad((int(NumAllClasses) * 4)))
type GetSelectedExtensionEventsReply struct {
	Sequence uint16
	Length   uint32
	// padding: 1 bytes
	NumThisClasses uint16
	NumAllClasses  uint16
	// padding: 20 bytes
	ThisClasses []EventClass // size: xgb.Pad((int(NumThisClasses) * 4))
	AllClasses  []EventClass // size: xgb.Pad((int(NumAllClasses) * 4))
}

// Waits and reads reply data from request GetSelectedExtensionEvents
func (cook GetSelectedExtensionEventsCookie) Reply() (*GetSelectedExtensionEventsReply, error) {
	buf, err := cook.Cookie.Reply()
	if err != nil {
		return nil, err
	}
	if buf == nil {
		return nil, nil
	}
	return getSelectedExtensionEventsReply(buf), nil
}

// Read reply into structure from buffer for GetSelectedExtensionEvents
func getSelectedExtensionEventsReply(buf []byte) *GetSelectedExtensionEventsReply {
	v := new(GetSelectedExtensionEventsReply)
	b := 1 // skip reply determinant

	b += 1 // padding

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Length = xgb.Get32(buf[b:]) // 4-byte units
	b += 4

	v.NumThisClasses = xgb.Get16(buf[b:])
	b += 2

	v.NumAllClasses = xgb.Get16(buf[b:])
	b += 2

	b += 20 // padding

	v.ThisClasses = make([]EventClass, v.NumThisClasses)
	for i := 0; i < int(v.NumThisClasses); i++ {
		v.ThisClasses[i] = EventClass(xgb.Get32(buf[b:]))
		b += 4
	}
	b = xgb.Pad(b)

	v.AllClasses = make([]EventClass, v.NumAllClasses)
	for i := 0; i < int(v.NumAllClasses); i++ {
		v.AllClasses[i] = EventClass(xgb.Get32(buf[b:]))
		b += 4
	}
	b = xgb.Pad(b)

	return v
}

// Write request to wire for GetSelectedExtensionEvents
func getSelectedExtensionEventsRequest(c *xgb.Conn, Window xproto.Window) []byte {
	size := 8
	b := 0
	buf := make([]byte, size)

	buf[b] = c.Extensions["XINPUTEXTENSION"]
	b += 1

	buf[b] = 7 // request opcode
	b += 1

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	xgb.Put32(buf[b:], uint32(Window))
	b += 4

	return buf
}

// Request ChangeDeviceDontPropagateList
// size: xgb.Pad((12 + xgb.Pad((int(NumClasses) * 4))))
type ChangeDeviceDontPropagateListCookie struct {
	*xgb.Cookie
}

// Write request to wire for ChangeDeviceDontPropagateList
func ChangeDeviceDontPropagateList(c *xgb.Conn, Window xproto.Window, NumClasses uint16, Mode byte, Classes []EventClass) ChangeDeviceDontPropagateListCookie {
	cookie := c.NewCookie(false, false)
	c.NewRequest(changeDeviceDontPropagateListRequest(c, Window, NumClasses, Mode, Classes), cookie)
	return ChangeDeviceDontPropagateListCookie{cookie}
}

func ChangeDeviceDontPropagateListChecked(c *xgb.Conn, Window xproto.Window, NumClasses uint16, Mode byte, Classes []EventClass) ChangeDeviceDontPropagateListCookie {
	cookie := c.NewCookie(true, false)
	c.NewRequest(changeDeviceDontPropagateListRequest(c, Window, NumClasses, Mode, Classes), cookie)
	return ChangeDeviceDontPropagateListCookie{cookie}
}

func (cook ChangeDeviceDontPropagateListCookie) Check() error {
	return cook.Cookie.Check()
}

// Write request to wire for ChangeDeviceDontPropagateList
func changeDeviceDontPropagateListRequest(c *xgb.Conn, Window xproto.Window, NumClasses uint16, Mode byte, Classes []EventClass) []byte {
	size := xgb.Pad((12 + xgb.Pad((int(NumClasses) * 4))))
	b := 0
	buf := make([]byte, size)

	buf[b] = c.Extensions["XINPUTEXTENSION"]
	b += 1

	buf[b] = 8 // request opcode
	b += 1

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	xgb.Put32(buf[b:], uint32(Window))
	b += 4

	xgb.Put16(buf[b:], NumClasses)
	b += 2

	buf[b] = Mode
	b += 1

	b += 1 // padding

	for i := 0; i < int(NumClasses); i++ {
		xgb.Put32(buf[b:], uint32(Classes[i]))
		b += 4
	}
	b = xgb.Pad(b)

	return buf
}

// Request GetDeviceDontPropagateList
// size: 8
type GetDeviceDontPropagateListCookie struct {
	*xgb.Cookie
}

func GetDeviceDontPropagateList(c *xgb.Conn, Window xproto.Window) GetDeviceDontPropagateListCookie {
	cookie := c.NewCookie(true, true)
	c.NewRequest(getDeviceDontPropagateListRequest(c, Window), cookie)
	return GetDeviceDontPropagateListCookie{cookie}
}

func GetDeviceDontPropagateListUnchecked(c *xgb.Conn, Window xproto.Window) GetDeviceDontPropagateListCookie {
	cookie := c.NewCookie(false, true)
	c.NewRequest(getDeviceDontPropagateListRequest(c, Window), cookie)
	return GetDeviceDontPropagateListCookie{cookie}
}

// Request reply for GetDeviceDontPropagateList
// size: (32 + xgb.Pad((int(NumClasses) * 4)))
type GetDeviceDontPropagateListReply struct {
	Sequence uint16
	Length   uint32
	// padding: 1 bytes
	NumClasses uint16
	// padding: 22 bytes
	Classes []EventClass // size: xgb.Pad((int(NumClasses) * 4))
}

// Waits and reads reply data from request GetDeviceDontPropagateList
func (cook GetDeviceDontPropagateListCookie) Reply() (*GetDeviceDontPropagateListReply, error) {
	buf, err := cook.Cookie.Reply()
	if err != nil {
		return nil, err
	}
	if buf == nil {
		return nil, nil
	}
	return getDeviceDontPropagateListReply(buf), nil
}

// Read reply into structure from buffer for GetDeviceDontPropagateList
func getDeviceDontPropagateListReply(buf []byte) *GetDeviceDontPropagateListReply {
	v := new(GetDeviceDontPropagateListReply)
	b := 1 // skip reply determinant

	b += 1 // padding

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Length = xgb.Get32(buf[b:]) // 4-byte units
	b += 4

	v.NumClasses = xgb.Get16(buf[b:])
	b += 2

	b += 22 // padding

	v.Classes = make([]EventClass, v.NumClasses)
	for i := 0; i < int(v.NumClasses); i++ {
		v.Classes[i] = EventClass(xgb.Get32(buf[b:]))
		b += 4
	}
	b = xgb.Pad(b)

	return v
}

// Write request to wire for GetDeviceDontPropagateList
func getDeviceDontPropagateListRequest(c *xgb.Conn, Window xproto.Window) []byte {
	size := 8
	b := 0
	buf := make([]byte, size)

	buf[b] = c.Extensions["XINPUTEXTENSION"]
	b += 1

	buf[b] = 9 // request opcode
	b += 1

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	xgb.Put32(buf[b:], uint32(Window))
	b += 4

	return buf
}

// Request GetDeviceMotionEvents
// size: 16
type GetDeviceMotionEventsCookie struct {
	*xgb.Cookie
}

func GetDeviceMotionEvents(c *xgb.Conn, Start xproto.Timestamp, Stop xproto.Timestamp, DeviceId byte) GetDeviceMotionEventsCookie {
	cookie := c.NewCookie(true, true)
	c.NewRequest(getDeviceMotionEventsRequest(c, Start, Stop, DeviceId), cookie)
	return GetDeviceMotionEventsCookie{cookie}
}

func GetDeviceMotionEventsUnchecked(c *xgb.Conn, Start xproto.Timestamp, Stop xproto.Timestamp, DeviceId byte) GetDeviceMotionEventsCookie {
	cookie := c.NewCookie(false, true)
	c.NewRequest(getDeviceMotionEventsRequest(c, Start, Stop, DeviceId), cookie)
	return GetDeviceMotionEventsCookie{cookie}
}

// Request reply for GetDeviceMotionEvents
// size: 32
type GetDeviceMotionEventsReply struct {
	Sequence uint16
	Length   uint32
	// padding: 1 bytes
	NumCoords  uint32
	NumAxes    byte
	DeviceMode byte
	// padding: 18 bytes
}

// Waits and reads reply data from request GetDeviceMotionEvents
func (cook GetDeviceMotionEventsCookie) Reply() (*GetDeviceMotionEventsReply, error) {
	buf, err := cook.Cookie.Reply()
	if err != nil {
		return nil, err
	}
	if buf == nil {
		return nil, nil
	}
	return getDeviceMotionEventsReply(buf), nil
}

// Read reply into structure from buffer for GetDeviceMotionEvents
func getDeviceMotionEventsReply(buf []byte) *GetDeviceMotionEventsReply {
	v := new(GetDeviceMotionEventsReply)
	b := 1 // skip reply determinant

	b += 1 // padding

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Length = xgb.Get32(buf[b:]) // 4-byte units
	b += 4

	v.NumCoords = xgb.Get32(buf[b:])
	b += 4

	v.NumAxes = buf[b]
	b += 1

	v.DeviceMode = buf[b]
	b += 1

	b += 18 // padding

	return v
}

// Write request to wire for GetDeviceMotionEvents
func getDeviceMotionEventsRequest(c *xgb.Conn, Start xproto.Timestamp, Stop xproto.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

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	xgb.Put32(buf[b:], uint32(Start))
	b += 4

	xgb.Put32(buf[b:], uint32(Stop))
	b += 4

	buf[b] = DeviceId
	b += 1

	return buf
}

// Request ChangeKeyboardDevice
// size: 8
type ChangeKeyboardDeviceCookie struct {
	*xgb.Cookie
}

func ChangeKeyboardDevice(c *xgb.Conn, DeviceId byte) ChangeKeyboardDeviceCookie {
	cookie := c.NewCookie(true, true)
	c.NewRequest(changeKeyboardDeviceRequest(c, DeviceId), cookie)
	return ChangeKeyboardDeviceCookie{cookie}
}

func ChangeKeyboardDeviceUnchecked(c *xgb.Conn, DeviceId byte) ChangeKeyboardDeviceCookie {
	cookie := c.NewCookie(false, true)
	c.NewRequest(changeKeyboardDeviceRequest(c, DeviceId), cookie)
	return ChangeKeyboardDeviceCookie{cookie}
}

// Request reply for ChangeKeyboardDevice
// size: 32
type ChangeKeyboardDeviceReply struct {
	Sequence uint16
	Length   uint32
	// padding: 1 bytes
	Status byte
	// padding: 23 bytes
}

// Waits and reads reply data from request ChangeKeyboardDevice
func (cook ChangeKeyboardDeviceCookie) Reply() (*ChangeKeyboardDeviceReply, error) {
	buf, err := cook.Cookie.Reply()
	if err != nil {
		return nil, err
	}
	if buf == nil {
		return nil, nil
	}
	return changeKeyboardDeviceReply(buf), nil
}

// Read reply into structure from buffer for ChangeKeyboardDevice
func changeKeyboardDeviceReply(buf []byte) *ChangeKeyboardDeviceReply {
	v := new(ChangeKeyboardDeviceReply)
	b := 1 // skip reply determinant

	b += 1 // padding

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Length = xgb.Get32(buf[b:]) // 4-byte units
	b += 4

	v.Status = buf[b]
	b += 1

	b += 23 // padding

	return v
}

// Write request to wire for ChangeKeyboardDevice
func changeKeyboardDeviceRequest(c *xgb.Conn, 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

	xgb.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 ChangePointerDevice
// size: 8
type ChangePointerDeviceCookie struct {
	*xgb.Cookie
}

func ChangePointerDevice(c *xgb.Conn, XAxis byte, YAxis byte, DeviceId byte) ChangePointerDeviceCookie {
	cookie := c.NewCookie(true, true)
	c.NewRequest(changePointerDeviceRequest(c, XAxis, YAxis, DeviceId), cookie)
	return ChangePointerDeviceCookie{cookie}
}

func ChangePointerDeviceUnchecked(c *xgb.Conn, XAxis byte, YAxis byte, DeviceId byte) ChangePointerDeviceCookie {
	cookie := c.NewCookie(false, true)
	c.NewRequest(changePointerDeviceRequest(c, XAxis, YAxis, DeviceId), cookie)
	return ChangePointerDeviceCookie{cookie}
}

// Request reply for ChangePointerDevice
// size: 32
type ChangePointerDeviceReply struct {
	Sequence uint16
	Length   uint32
	// padding: 1 bytes
	Status byte
	// padding: 23 bytes
}

// Waits and reads reply data from request ChangePointerDevice
func (cook ChangePointerDeviceCookie) Reply() (*ChangePointerDeviceReply, error) {
	buf, err := cook.Cookie.Reply()
	if err != nil {
		return nil, err
	}
	if buf == nil {
		return nil, nil
	}
	return changePointerDeviceReply(buf), nil
}

// Read reply into structure from buffer for ChangePointerDevice
func changePointerDeviceReply(buf []byte) *ChangePointerDeviceReply {
	v := new(ChangePointerDeviceReply)
	b := 1 // skip reply determinant

	b += 1 // padding

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Length = xgb.Get32(buf[b:]) // 4-byte units
	b += 4

	v.Status = buf[b]
	b += 1

	b += 23 // padding

	return v
}

// Write request to wire for ChangePointerDevice
func changePointerDeviceRequest(c *xgb.Conn, 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

	xgb.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 GrabDevice
// size: xgb.Pad((20 + xgb.Pad((int(NumClasses) * 4))))
type GrabDeviceCookie struct {
	*xgb.Cookie
}

func GrabDevice(c *xgb.Conn, GrabWindow xproto.Window, Time xproto.Timestamp, NumClasses uint16, ThisDeviceMode byte, OtherDeviceMode byte, OwnerEvents bool, DeviceId byte, Classes []EventClass) GrabDeviceCookie {
	cookie := c.NewCookie(true, true)
	c.NewRequest(grabDeviceRequest(c, GrabWindow, Time, NumClasses, ThisDeviceMode, OtherDeviceMode, OwnerEvents, DeviceId, Classes), cookie)
	return GrabDeviceCookie{cookie}
}

func GrabDeviceUnchecked(c *xgb.Conn, GrabWindow xproto.Window, Time xproto.Timestamp, NumClasses uint16, ThisDeviceMode byte, OtherDeviceMode byte, OwnerEvents bool, DeviceId byte, Classes []EventClass) GrabDeviceCookie {
	cookie := c.NewCookie(false, true)
	c.NewRequest(grabDeviceRequest(c, GrabWindow, Time, NumClasses, ThisDeviceMode, OtherDeviceMode, OwnerEvents, DeviceId, Classes), cookie)
	return GrabDeviceCookie{cookie}
}

// Request reply for GrabDevice
// size: 32
type GrabDeviceReply struct {
	Sequence uint16
	Length   uint32
	// padding: 1 bytes
	Status byte
	// padding: 23 bytes
}

// Waits and reads reply data from request GrabDevice
func (cook GrabDeviceCookie) Reply() (*GrabDeviceReply, error) {
	buf, err := cook.Cookie.Reply()
	if err != nil {
		return nil, err
	}
	if buf == nil {
		return nil, nil
	}
	return grabDeviceReply(buf), nil
}

// Read reply into structure from buffer for GrabDevice
func grabDeviceReply(buf []byte) *GrabDeviceReply {
	v := new(GrabDeviceReply)
	b := 1 // skip reply determinant

	b += 1 // padding

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Length = xgb.Get32(buf[b:]) // 4-byte units
	b += 4

	v.Status = buf[b]
	b += 1

	b += 23 // padding

	return v
}

// Write request to wire for GrabDevice
func grabDeviceRequest(c *xgb.Conn, GrabWindow xproto.Window, Time xproto.Timestamp, NumClasses uint16, ThisDeviceMode byte, OtherDeviceMode byte, OwnerEvents bool, DeviceId byte, Classes []EventClass) []byte {
	size := xgb.Pad((20 + xgb.Pad((int(NumClasses) * 4))))
	b := 0
	buf := make([]byte, size)

	buf[b] = c.Extensions["XINPUTEXTENSION"]
	b += 1

	buf[b] = 13 // request opcode
	b += 1

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	xgb.Put32(buf[b:], uint32(GrabWindow))
	b += 4

	xgb.Put32(buf[b:], uint32(Time))
	b += 4

	xgb.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++ {
		xgb.Put32(buf[b:], uint32(Classes[i]))
		b += 4
	}
	b = xgb.Pad(b)

	return buf
}

// Request UngrabDevice
// size: 12
type UngrabDeviceCookie struct {
	*xgb.Cookie
}

// Write request to wire for UngrabDevice
func UngrabDevice(c *xgb.Conn, Time xproto.Timestamp, DeviceId byte) UngrabDeviceCookie {
	cookie := c.NewCookie(false, false)
	c.NewRequest(ungrabDeviceRequest(c, Time, DeviceId), cookie)
	return UngrabDeviceCookie{cookie}
}

func UngrabDeviceChecked(c *xgb.Conn, Time xproto.Timestamp, DeviceId byte) UngrabDeviceCookie {
	cookie := c.NewCookie(true, false)
	c.NewRequest(ungrabDeviceRequest(c, Time, DeviceId), cookie)
	return UngrabDeviceCookie{cookie}
}

func (cook UngrabDeviceCookie) Check() error {
	return cook.Cookie.Check()
}

// Write request to wire for UngrabDevice
func ungrabDeviceRequest(c *xgb.Conn, Time xproto.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

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	xgb.Put32(buf[b:], uint32(Time))
	b += 4

	buf[b] = DeviceId
	b += 1

	return buf
}

// Request GrabDeviceKey
// size: xgb.Pad((20 + xgb.Pad((int(NumClasses) * 4))))
type GrabDeviceKeyCookie struct {
	*xgb.Cookie
}

// Write request to wire for GrabDeviceKey
func GrabDeviceKey(c *xgb.Conn, GrabWindow xproto.Window, NumClasses uint16, Modifiers uint16, ModifierDevice byte, GrabbedDevice byte, Key byte, ThisDeviceMode byte, OtherDeviceMode byte, OwnerEvents bool, Classes []EventClass) GrabDeviceKeyCookie {
	cookie := c.NewCookie(false, false)
	c.NewRequest(grabDeviceKeyRequest(c, GrabWindow, NumClasses, Modifiers, ModifierDevice, GrabbedDevice, Key, ThisDeviceMode, OtherDeviceMode, OwnerEvents, Classes), cookie)
	return GrabDeviceKeyCookie{cookie}
}

func GrabDeviceKeyChecked(c *xgb.Conn, GrabWindow xproto.Window, NumClasses uint16, Modifiers uint16, ModifierDevice byte, GrabbedDevice byte, Key byte, ThisDeviceMode byte, OtherDeviceMode byte, OwnerEvents bool, Classes []EventClass) GrabDeviceKeyCookie {
	cookie := c.NewCookie(true, false)
	c.NewRequest(grabDeviceKeyRequest(c, GrabWindow, NumClasses, Modifiers, ModifierDevice, GrabbedDevice, Key, ThisDeviceMode, OtherDeviceMode, OwnerEvents, Classes), cookie)
	return GrabDeviceKeyCookie{cookie}
}

func (cook GrabDeviceKeyCookie) Check() error {
	return cook.Cookie.Check()
}

// Write request to wire for GrabDeviceKey
func grabDeviceKeyRequest(c *xgb.Conn, GrabWindow xproto.Window, NumClasses uint16, Modifiers uint16, ModifierDevice byte, GrabbedDevice byte, Key byte, ThisDeviceMode byte, OtherDeviceMode byte, OwnerEvents bool, Classes []EventClass) []byte {
	size := xgb.Pad((20 + xgb.Pad((int(NumClasses) * 4))))
	b := 0
	buf := make([]byte, size)

	buf[b] = c.Extensions["XINPUTEXTENSION"]
	b += 1

	buf[b] = 15 // request opcode
	b += 1

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	xgb.Put32(buf[b:], uint32(GrabWindow))
	b += 4

	xgb.Put16(buf[b:], NumClasses)
	b += 2

	xgb.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++ {
		xgb.Put32(buf[b:], uint32(Classes[i]))
		b += 4
	}
	b = xgb.Pad(b)

	return buf
}

// Request UngrabDeviceKey
// size: 16
type UngrabDeviceKeyCookie struct {
	*xgb.Cookie
}

// Write request to wire for UngrabDeviceKey
func UngrabDeviceKey(c *xgb.Conn, GrabWindow xproto.Window, Modifiers uint16, ModifierDevice byte, Key byte, GrabbedDevice byte) UngrabDeviceKeyCookie {
	cookie := c.NewCookie(false, false)
	c.NewRequest(ungrabDeviceKeyRequest(c, GrabWindow, Modifiers, ModifierDevice, Key, GrabbedDevice), cookie)
	return UngrabDeviceKeyCookie{cookie}
}

func UngrabDeviceKeyChecked(c *xgb.Conn, GrabWindow xproto.Window, Modifiers uint16, ModifierDevice byte, Key byte, GrabbedDevice byte) UngrabDeviceKeyCookie {
	cookie := c.NewCookie(true, false)
	c.NewRequest(ungrabDeviceKeyRequest(c, GrabWindow, Modifiers, ModifierDevice, Key, GrabbedDevice), cookie)
	return UngrabDeviceKeyCookie{cookie}
}

func (cook UngrabDeviceKeyCookie) Check() error {
	return cook.Cookie.Check()
}

// Write request to wire for UngrabDeviceKey
func ungrabDeviceKeyRequest(c *xgb.Conn, GrabWindow xproto.Window, 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

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	xgb.Put32(buf[b:], uint32(GrabWindow))
	b += 4

	xgb.Put16(buf[b:], Modifiers)
	b += 2

	buf[b] = ModifierDevice
	b += 1

	buf[b] = Key
	b += 1

	buf[b] = GrabbedDevice
	b += 1

	return buf
}

// Request GrabDeviceButton
// size: xgb.Pad((20 + xgb.Pad((int(NumClasses) * 4))))
type GrabDeviceButtonCookie struct {
	*xgb.Cookie
}

// Write request to wire for GrabDeviceButton
func GrabDeviceButton(c *xgb.Conn, GrabWindow xproto.Window, GrabbedDevice byte, ModifierDevice byte, NumClasses uint16, Modifiers uint16, ThisDeviceMode byte, OtherDeviceMode byte, Button byte, OwnerEvents byte, Classes []EventClass) GrabDeviceButtonCookie {
	cookie := c.NewCookie(false, false)
	c.NewRequest(grabDeviceButtonRequest(c, GrabWindow, GrabbedDevice, ModifierDevice, NumClasses, Modifiers, ThisDeviceMode, OtherDeviceMode, Button, OwnerEvents, Classes), cookie)
	return GrabDeviceButtonCookie{cookie}
}

func GrabDeviceButtonChecked(c *xgb.Conn, GrabWindow xproto.Window, GrabbedDevice byte, ModifierDevice byte, NumClasses uint16, Modifiers uint16, ThisDeviceMode byte, OtherDeviceMode byte, Button byte, OwnerEvents byte, Classes []EventClass) GrabDeviceButtonCookie {
	cookie := c.NewCookie(true, false)
	c.NewRequest(grabDeviceButtonRequest(c, GrabWindow, GrabbedDevice, ModifierDevice, NumClasses, Modifiers, ThisDeviceMode, OtherDeviceMode, Button, OwnerEvents, Classes), cookie)
	return GrabDeviceButtonCookie{cookie}
}

func (cook GrabDeviceButtonCookie) Check() error {
	return cook.Cookie.Check()
}

// Write request to wire for GrabDeviceButton
func grabDeviceButtonRequest(c *xgb.Conn, GrabWindow xproto.Window, GrabbedDevice byte, ModifierDevice byte, NumClasses uint16, Modifiers uint16, ThisDeviceMode byte, OtherDeviceMode byte, Button byte, OwnerEvents byte, Classes []EventClass) []byte {
	size := xgb.Pad((20 + xgb.Pad((int(NumClasses) * 4))))
	b := 0
	buf := make([]byte, size)

	buf[b] = c.Extensions["XINPUTEXTENSION"]
	b += 1

	buf[b] = 17 // request opcode
	b += 1

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	xgb.Put32(buf[b:], uint32(GrabWindow))
	b += 4

	buf[b] = GrabbedDevice
	b += 1

	buf[b] = ModifierDevice
	b += 1

	xgb.Put16(buf[b:], NumClasses)
	b += 2

	xgb.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++ {
		xgb.Put32(buf[b:], uint32(Classes[i]))
		b += 4
	}
	b = xgb.Pad(b)

	return buf
}

// Request UngrabDeviceButton
// size: 16
type UngrabDeviceButtonCookie struct {
	*xgb.Cookie
}

// Write request to wire for UngrabDeviceButton
func UngrabDeviceButton(c *xgb.Conn, GrabWindow xproto.Window, Modifiers uint16, ModifierDevice byte, Button byte, GrabbedDevice byte) UngrabDeviceButtonCookie {
	cookie := c.NewCookie(false, false)
	c.NewRequest(ungrabDeviceButtonRequest(c, GrabWindow, Modifiers, ModifierDevice, Button, GrabbedDevice), cookie)
	return UngrabDeviceButtonCookie{cookie}
}

func UngrabDeviceButtonChecked(c *xgb.Conn, GrabWindow xproto.Window, Modifiers uint16, ModifierDevice byte, Button byte, GrabbedDevice byte) UngrabDeviceButtonCookie {
	cookie := c.NewCookie(true, false)
	c.NewRequest(ungrabDeviceButtonRequest(c, GrabWindow, Modifiers, ModifierDevice, Button, GrabbedDevice), cookie)
	return UngrabDeviceButtonCookie{cookie}
}

func (cook UngrabDeviceButtonCookie) Check() error {
	return cook.Cookie.Check()
}

// Write request to wire for UngrabDeviceButton
func ungrabDeviceButtonRequest(c *xgb.Conn, GrabWindow xproto.Window, 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

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	xgb.Put32(buf[b:], uint32(GrabWindow))
	b += 4

	xgb.Put16(buf[b:], Modifiers)
	b += 2

	buf[b] = ModifierDevice
	b += 1

	buf[b] = Button
	b += 1

	buf[b] = GrabbedDevice
	b += 1

	return buf
}

// Request AllowDeviceEvents
// size: 12
type AllowDeviceEventsCookie struct {
	*xgb.Cookie
}

// Write request to wire for AllowDeviceEvents
func AllowDeviceEvents(c *xgb.Conn, Time xproto.Timestamp, Mode byte, DeviceId byte) AllowDeviceEventsCookie {
	cookie := c.NewCookie(false, false)
	c.NewRequest(allowDeviceEventsRequest(c, Time, Mode, DeviceId), cookie)
	return AllowDeviceEventsCookie{cookie}
}

func AllowDeviceEventsChecked(c *xgb.Conn, Time xproto.Timestamp, Mode byte, DeviceId byte) AllowDeviceEventsCookie {
	cookie := c.NewCookie(true, false)
	c.NewRequest(allowDeviceEventsRequest(c, Time, Mode, DeviceId), cookie)
	return AllowDeviceEventsCookie{cookie}
}

func (cook AllowDeviceEventsCookie) Check() error {
	return cook.Cookie.Check()
}

// Write request to wire for AllowDeviceEvents
func allowDeviceEventsRequest(c *xgb.Conn, Time xproto.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

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	xgb.Put32(buf[b:], uint32(Time))
	b += 4

	buf[b] = Mode
	b += 1

	buf[b] = DeviceId
	b += 1

	return buf
}

// Request GetDeviceFocus
// size: 8
type GetDeviceFocusCookie struct {
	*xgb.Cookie
}

func GetDeviceFocus(c *xgb.Conn, DeviceId byte) GetDeviceFocusCookie {
	cookie := c.NewCookie(true, true)
	c.NewRequest(getDeviceFocusRequest(c, DeviceId), cookie)
	return GetDeviceFocusCookie{cookie}
}

func GetDeviceFocusUnchecked(c *xgb.Conn, DeviceId byte) GetDeviceFocusCookie {
	cookie := c.NewCookie(false, true)
	c.NewRequest(getDeviceFocusRequest(c, DeviceId), cookie)
	return GetDeviceFocusCookie{cookie}
}

// Request reply for GetDeviceFocus
// size: 32
type GetDeviceFocusReply struct {
	Sequence uint16
	Length   uint32
	// padding: 1 bytes
	Focus    xproto.Window
	Time     xproto.Timestamp
	RevertTo byte
	// padding: 15 bytes
}

// Waits and reads reply data from request GetDeviceFocus
func (cook GetDeviceFocusCookie) Reply() (*GetDeviceFocusReply, error) {
	buf, err := cook.Cookie.Reply()
	if err != nil {
		return nil, err
	}
	if buf == nil {
		return nil, nil
	}
	return getDeviceFocusReply(buf), nil
}

// Read reply into structure from buffer for GetDeviceFocus
func getDeviceFocusReply(buf []byte) *GetDeviceFocusReply {
	v := new(GetDeviceFocusReply)
	b := 1 // skip reply determinant

	b += 1 // padding

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Length = xgb.Get32(buf[b:]) // 4-byte units
	b += 4

	v.Focus = xproto.Window(xgb.Get32(buf[b:]))
	b += 4

	v.Time = xproto.Timestamp(xgb.Get32(buf[b:]))
	b += 4

	v.RevertTo = buf[b]
	b += 1

	b += 15 // padding

	return v
}

// Write request to wire for GetDeviceFocus
func getDeviceFocusRequest(c *xgb.Conn, 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

	xgb.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 SetDeviceFocus
// size: 16
type SetDeviceFocusCookie struct {
	*xgb.Cookie
}

// Write request to wire for SetDeviceFocus
func SetDeviceFocus(c *xgb.Conn, Focus xproto.Window, Time xproto.Timestamp, RevertTo byte, DeviceId byte) SetDeviceFocusCookie {
	cookie := c.NewCookie(false, false)
	c.NewRequest(setDeviceFocusRequest(c, Focus, Time, RevertTo, DeviceId), cookie)
	return SetDeviceFocusCookie{cookie}
}

func SetDeviceFocusChecked(c *xgb.Conn, Focus xproto.Window, Time xproto.Timestamp, RevertTo byte, DeviceId byte) SetDeviceFocusCookie {
	cookie := c.NewCookie(true, false)
	c.NewRequest(setDeviceFocusRequest(c, Focus, Time, RevertTo, DeviceId), cookie)
	return SetDeviceFocusCookie{cookie}
}

func (cook SetDeviceFocusCookie) Check() error {
	return cook.Cookie.Check()
}

// Write request to wire for SetDeviceFocus
func setDeviceFocusRequest(c *xgb.Conn, Focus xproto.Window, Time xproto.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

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	xgb.Put32(buf[b:], uint32(Focus))
	b += 4

	xgb.Put32(buf[b:], uint32(Time))
	b += 4

	buf[b] = RevertTo
	b += 1

	buf[b] = DeviceId
	b += 1

	return buf
}

// Request GetFeedbackControl
// size: 8
type GetFeedbackControlCookie struct {
	*xgb.Cookie
}

func GetFeedbackControl(c *xgb.Conn, DeviceId byte) GetFeedbackControlCookie {
	cookie := c.NewCookie(true, true)
	c.NewRequest(getFeedbackControlRequest(c, DeviceId), cookie)
	return GetFeedbackControlCookie{cookie}
}

func GetFeedbackControlUnchecked(c *xgb.Conn, DeviceId byte) GetFeedbackControlCookie {
	cookie := c.NewCookie(false, true)
	c.NewRequest(getFeedbackControlRequest(c, DeviceId), cookie)
	return GetFeedbackControlCookie{cookie}
}

// Request reply for GetFeedbackControl
// size: 32
type GetFeedbackControlReply struct {
	Sequence uint16
	Length   uint32
	// padding: 1 bytes
	NumFeedback uint16
	// padding: 22 bytes
}

// Waits and reads reply data from request GetFeedbackControl
func (cook GetFeedbackControlCookie) Reply() (*GetFeedbackControlReply, error) {
	buf, err := cook.Cookie.Reply()
	if err != nil {
		return nil, err
	}
	if buf == nil {
		return nil, nil
	}
	return getFeedbackControlReply(buf), nil
}

// Read reply into structure from buffer for GetFeedbackControl
func getFeedbackControlReply(buf []byte) *GetFeedbackControlReply {
	v := new(GetFeedbackControlReply)
	b := 1 // skip reply determinant

	b += 1 // padding

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Length = xgb.Get32(buf[b:]) // 4-byte units
	b += 4

	v.NumFeedback = xgb.Get16(buf[b:])
	b += 2

	b += 22 // padding

	return v
}

// Write request to wire for GetFeedbackControl
func getFeedbackControlRequest(c *xgb.Conn, 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

	xgb.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 GetDeviceKeyMapping
// size: 8
type GetDeviceKeyMappingCookie struct {
	*xgb.Cookie
}

func GetDeviceKeyMapping(c *xgb.Conn, DeviceId byte, FirstKeycode KeyCode, Count byte) GetDeviceKeyMappingCookie {
	cookie := c.NewCookie(true, true)
	c.NewRequest(getDeviceKeyMappingRequest(c, DeviceId, FirstKeycode, Count), cookie)
	return GetDeviceKeyMappingCookie{cookie}
}

func GetDeviceKeyMappingUnchecked(c *xgb.Conn, DeviceId byte, FirstKeycode KeyCode, Count byte) GetDeviceKeyMappingCookie {
	cookie := c.NewCookie(false, true)
	c.NewRequest(getDeviceKeyMappingRequest(c, DeviceId, FirstKeycode, Count), cookie)
	return GetDeviceKeyMappingCookie{cookie}
}

// Request reply for GetDeviceKeyMapping
// size: (32 + xgb.Pad((int(Length) * 4)))
type GetDeviceKeyMappingReply struct {
	Sequence uint16
	Length   uint32
	// padding: 1 bytes
	KeysymsPerKeycode byte
	// padding: 23 bytes
	Keysyms []xproto.Keysym // size: xgb.Pad((int(Length) * 4))
}

// Waits and reads reply data from request GetDeviceKeyMapping
func (cook GetDeviceKeyMappingCookie) Reply() (*GetDeviceKeyMappingReply, error) {
	buf, err := cook.Cookie.Reply()
	if err != nil {
		return nil, err
	}
	if buf == nil {
		return nil, nil
	}
	return getDeviceKeyMappingReply(buf), nil
}

// Read reply into structure from buffer for GetDeviceKeyMapping
func getDeviceKeyMappingReply(buf []byte) *GetDeviceKeyMappingReply {
	v := new(GetDeviceKeyMappingReply)
	b := 1 // skip reply determinant

	b += 1 // padding

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Length = xgb.Get32(buf[b:]) // 4-byte units
	b += 4

	v.KeysymsPerKeycode = buf[b]
	b += 1

	b += 23 // padding

	v.Keysyms = make([]xproto.Keysym, v.Length)
	for i := 0; i < int(v.Length); i++ {
		v.Keysyms[i] = xproto.Keysym(xgb.Get32(buf[b:]))
		b += 4
	}
	b = xgb.Pad(b)

	return v
}

// Write request to wire for GetDeviceKeyMapping
func getDeviceKeyMappingRequest(c *xgb.Conn, DeviceId byte, FirstKeycode KeyCode, 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

	xgb.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 ChangeDeviceKeyMapping
// size: xgb.Pad((8 + xgb.Pad(((int(KeycodeCount) * int(KeysymsPerKeycode)) * 4))))
type ChangeDeviceKeyMappingCookie struct {
	*xgb.Cookie
}

// Write request to wire for ChangeDeviceKeyMapping
func ChangeDeviceKeyMapping(c *xgb.Conn, DeviceId byte, FirstKeycode KeyCode, KeysymsPerKeycode byte, KeycodeCount byte, Keysyms []xproto.Keysym) ChangeDeviceKeyMappingCookie {
	cookie := c.NewCookie(false, false)
	c.NewRequest(changeDeviceKeyMappingRequest(c, DeviceId, FirstKeycode, KeysymsPerKeycode, KeycodeCount, Keysyms), cookie)
	return ChangeDeviceKeyMappingCookie{cookie}
}

func ChangeDeviceKeyMappingChecked(c *xgb.Conn, DeviceId byte, FirstKeycode KeyCode, KeysymsPerKeycode byte, KeycodeCount byte, Keysyms []xproto.Keysym) ChangeDeviceKeyMappingCookie {
	cookie := c.NewCookie(true, false)
	c.NewRequest(changeDeviceKeyMappingRequest(c, DeviceId, FirstKeycode, KeysymsPerKeycode, KeycodeCount, Keysyms), cookie)
	return ChangeDeviceKeyMappingCookie{cookie}
}

func (cook ChangeDeviceKeyMappingCookie) Check() error {
	return cook.Cookie.Check()
}

// Write request to wire for ChangeDeviceKeyMapping
func changeDeviceKeyMappingRequest(c *xgb.Conn, DeviceId byte, FirstKeycode KeyCode, KeysymsPerKeycode byte, KeycodeCount byte, Keysyms []xproto.Keysym) []byte {
	size := xgb.Pad((8 + xgb.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

	xgb.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++ {
		xgb.Put32(buf[b:], uint32(Keysyms[i]))
		b += 4
	}
	b = xgb.Pad(b)

	return buf
}

// Request GetDeviceModifierMapping
// size: 8
type GetDeviceModifierMappingCookie struct {
	*xgb.Cookie
}

func GetDeviceModifierMapping(c *xgb.Conn, DeviceId byte) GetDeviceModifierMappingCookie {
	cookie := c.NewCookie(true, true)
	c.NewRequest(getDeviceModifierMappingRequest(c, DeviceId), cookie)
	return GetDeviceModifierMappingCookie{cookie}
}

func GetDeviceModifierMappingUnchecked(c *xgb.Conn, DeviceId byte) GetDeviceModifierMappingCookie {
	cookie := c.NewCookie(false, true)
	c.NewRequest(getDeviceModifierMappingRequest(c, DeviceId), cookie)
	return GetDeviceModifierMappingCookie{cookie}
}

// Request reply for GetDeviceModifierMapping
// size: (32 + xgb.Pad(((int(KeycodesPerModifier) * 8) * 1)))
type GetDeviceModifierMappingReply struct {
	Sequence uint16
	Length   uint32
	// padding: 1 bytes
	KeycodesPerModifier byte
	// padding: 23 bytes
	Keymaps []byte // size: xgb.Pad(((int(KeycodesPerModifier) * 8) * 1))
}

// Waits and reads reply data from request GetDeviceModifierMapping
func (cook GetDeviceModifierMappingCookie) Reply() (*GetDeviceModifierMappingReply, error) {
	buf, err := cook.Cookie.Reply()
	if err != nil {
		return nil, err
	}
	if buf == nil {
		return nil, nil
	}
	return getDeviceModifierMappingReply(buf), nil
}

// Read reply into structure from buffer for GetDeviceModifierMapping
func getDeviceModifierMappingReply(buf []byte) *GetDeviceModifierMappingReply {
	v := new(GetDeviceModifierMappingReply)
	b := 1 // skip reply determinant

	b += 1 // padding

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Length = xgb.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 += xgb.Pad(int((int(v.KeycodesPerModifier) * 8)))

	return v
}

// Write request to wire for GetDeviceModifierMapping
func getDeviceModifierMappingRequest(c *xgb.Conn, 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

	xgb.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 SetDeviceModifierMapping
// size: xgb.Pad((7 + xgb.Pad(((int(KeycodesPerModifier) * 8) * 1))))
type SetDeviceModifierMappingCookie struct {
	*xgb.Cookie
}

func SetDeviceModifierMapping(c *xgb.Conn, DeviceId byte, KeycodesPerModifier byte, Keymaps []byte) SetDeviceModifierMappingCookie {
	cookie := c.NewCookie(true, true)
	c.NewRequest(setDeviceModifierMappingRequest(c, DeviceId, KeycodesPerModifier, Keymaps), cookie)
	return SetDeviceModifierMappingCookie{cookie}
}

func SetDeviceModifierMappingUnchecked(c *xgb.Conn, DeviceId byte, KeycodesPerModifier byte, Keymaps []byte) SetDeviceModifierMappingCookie {
	cookie := c.NewCookie(false, true)
	c.NewRequest(setDeviceModifierMappingRequest(c, DeviceId, KeycodesPerModifier, Keymaps), cookie)
	return SetDeviceModifierMappingCookie{cookie}
}

// Request reply for SetDeviceModifierMapping
// size: 32
type SetDeviceModifierMappingReply struct {
	Sequence uint16
	Length   uint32
	// padding: 1 bytes
	Status byte
	// padding: 23 bytes
}

// Waits and reads reply data from request SetDeviceModifierMapping
func (cook SetDeviceModifierMappingCookie) Reply() (*SetDeviceModifierMappingReply, error) {
	buf, err := cook.Cookie.Reply()
	if err != nil {
		return nil, err
	}
	if buf == nil {
		return nil, nil
	}
	return setDeviceModifierMappingReply(buf), nil
}

// Read reply into structure from buffer for SetDeviceModifierMapping
func setDeviceModifierMappingReply(buf []byte) *SetDeviceModifierMappingReply {
	v := new(SetDeviceModifierMappingReply)
	b := 1 // skip reply determinant

	b += 1 // padding

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Length = xgb.Get32(buf[b:]) // 4-byte units
	b += 4

	v.Status = buf[b]
	b += 1

	b += 23 // padding

	return v
}

// Write request to wire for SetDeviceModifierMapping
func setDeviceModifierMappingRequest(c *xgb.Conn, DeviceId byte, KeycodesPerModifier byte, Keymaps []byte) []byte {
	size := xgb.Pad((7 + xgb.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

	xgb.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 += xgb.Pad(int((int(KeycodesPerModifier) * 8)))

	return buf
}

// Request GetDeviceButtonMapping
// size: 8
type GetDeviceButtonMappingCookie struct {
	*xgb.Cookie
}

func GetDeviceButtonMapping(c *xgb.Conn, DeviceId byte) GetDeviceButtonMappingCookie {
	cookie := c.NewCookie(true, true)
	c.NewRequest(getDeviceButtonMappingRequest(c, DeviceId), cookie)
	return GetDeviceButtonMappingCookie{cookie}
}

func GetDeviceButtonMappingUnchecked(c *xgb.Conn, DeviceId byte) GetDeviceButtonMappingCookie {
	cookie := c.NewCookie(false, true)
	c.NewRequest(getDeviceButtonMappingRequest(c, DeviceId), cookie)
	return GetDeviceButtonMappingCookie{cookie}
}

// Request reply for GetDeviceButtonMapping
// size: (32 + xgb.Pad((int(MapSize) * 1)))
type GetDeviceButtonMappingReply struct {
	Sequence uint16
	Length   uint32
	// padding: 1 bytes
	MapSize byte
	// padding: 23 bytes
	Map []byte // size: xgb.Pad((int(MapSize) * 1))
}

// Waits and reads reply data from request GetDeviceButtonMapping
func (cook GetDeviceButtonMappingCookie) Reply() (*GetDeviceButtonMappingReply, error) {
	buf, err := cook.Cookie.Reply()
	if err != nil {
		return nil, err
	}
	if buf == nil {
		return nil, nil
	}
	return getDeviceButtonMappingReply(buf), nil
}

// Read reply into structure from buffer for GetDeviceButtonMapping
func getDeviceButtonMappingReply(buf []byte) *GetDeviceButtonMappingReply {
	v := new(GetDeviceButtonMappingReply)
	b := 1 // skip reply determinant

	b += 1 // padding

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Length = xgb.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 += xgb.Pad(int(v.MapSize))

	return v
}

// Write request to wire for GetDeviceButtonMapping
func getDeviceButtonMappingRequest(c *xgb.Conn, 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

	xgb.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 SetDeviceButtonMapping
// size: xgb.Pad((8 + xgb.Pad((int(MapSize) * 1))))
type SetDeviceButtonMappingCookie struct {
	*xgb.Cookie
}

func SetDeviceButtonMapping(c *xgb.Conn, DeviceId byte, MapSize byte, Map []byte) SetDeviceButtonMappingCookie {
	cookie := c.NewCookie(true, true)
	c.NewRequest(setDeviceButtonMappingRequest(c, DeviceId, MapSize, Map), cookie)
	return SetDeviceButtonMappingCookie{cookie}
}

func SetDeviceButtonMappingUnchecked(c *xgb.Conn, DeviceId byte, MapSize byte, Map []byte) SetDeviceButtonMappingCookie {
	cookie := c.NewCookie(false, true)
	c.NewRequest(setDeviceButtonMappingRequest(c, DeviceId, MapSize, Map), cookie)
	return SetDeviceButtonMappingCookie{cookie}
}

// Request reply for SetDeviceButtonMapping
// size: 32
type SetDeviceButtonMappingReply struct {
	Sequence uint16
	Length   uint32
	// padding: 1 bytes
	Status byte
	// padding: 23 bytes
}

// Waits and reads reply data from request SetDeviceButtonMapping
func (cook SetDeviceButtonMappingCookie) Reply() (*SetDeviceButtonMappingReply, error) {
	buf, err := cook.Cookie.Reply()
	if err != nil {
		return nil, err
	}
	if buf == nil {
		return nil, nil
	}
	return setDeviceButtonMappingReply(buf), nil
}

// Read reply into structure from buffer for SetDeviceButtonMapping
func setDeviceButtonMappingReply(buf []byte) *SetDeviceButtonMappingReply {
	v := new(SetDeviceButtonMappingReply)
	b := 1 // skip reply determinant

	b += 1 // padding

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Length = xgb.Get32(buf[b:]) // 4-byte units
	b += 4

	v.Status = buf[b]
	b += 1

	b += 23 // padding

	return v
}

// Write request to wire for SetDeviceButtonMapping
func setDeviceButtonMappingRequest(c *xgb.Conn, DeviceId byte, MapSize byte, Map []byte) []byte {
	size := xgb.Pad((8 + xgb.Pad((int(MapSize) * 1))))
	b := 0
	buf := make([]byte, size)

	buf[b] = c.Extensions["XINPUTEXTENSION"]
	b += 1

	buf[b] = 29 // request opcode
	b += 1

	xgb.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 += xgb.Pad(int(MapSize))

	return buf
}

// Request QueryDeviceState
// size: 8
type QueryDeviceStateCookie struct {
	*xgb.Cookie
}

func QueryDeviceState(c *xgb.Conn, DeviceId byte) QueryDeviceStateCookie {
	cookie := c.NewCookie(true, true)
	c.NewRequest(queryDeviceStateRequest(c, DeviceId), cookie)
	return QueryDeviceStateCookie{cookie}
}

func QueryDeviceStateUnchecked(c *xgb.Conn, DeviceId byte) QueryDeviceStateCookie {
	cookie := c.NewCookie(false, true)
	c.NewRequest(queryDeviceStateRequest(c, DeviceId), cookie)
	return QueryDeviceStateCookie{cookie}
}

// Request reply for QueryDeviceState
// size: 32
type QueryDeviceStateReply struct {
	Sequence uint16
	Length   uint32
	// padding: 1 bytes
	NumClasses byte
	// padding: 23 bytes
}

// Waits and reads reply data from request QueryDeviceState
func (cook QueryDeviceStateCookie) Reply() (*QueryDeviceStateReply, error) {
	buf, err := cook.Cookie.Reply()
	if err != nil {
		return nil, err
	}
	if buf == nil {
		return nil, nil
	}
	return queryDeviceStateReply(buf), nil
}

// Read reply into structure from buffer for QueryDeviceState
func queryDeviceStateReply(buf []byte) *QueryDeviceStateReply {
	v := new(QueryDeviceStateReply)
	b := 1 // skip reply determinant

	b += 1 // padding

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Length = xgb.Get32(buf[b:]) // 4-byte units
	b += 4

	v.NumClasses = buf[b]
	b += 1

	b += 23 // padding

	return v
}

// Write request to wire for QueryDeviceState
func queryDeviceStateRequest(c *xgb.Conn, 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

	xgb.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 SendExtensionEvent
// size: xgb.Pad(((16 + xgb.Pad(((int(NumEvents) * 32) * 1))) + xgb.Pad((int(NumClasses) * 4))))
type SendExtensionEventCookie struct {
	*xgb.Cookie
}

// Write request to wire for SendExtensionEvent
func SendExtensionEvent(c *xgb.Conn, Destination xproto.Window, DeviceId byte, Propagate bool, NumClasses uint16, NumEvents byte, Events string, Classes []EventClass) SendExtensionEventCookie {
	cookie := c.NewCookie(false, false)
	c.NewRequest(sendExtensionEventRequest(c, Destination, DeviceId, Propagate, NumClasses, NumEvents, Events, Classes), cookie)
	return SendExtensionEventCookie{cookie}
}

func SendExtensionEventChecked(c *xgb.Conn, Destination xproto.Window, DeviceId byte, Propagate bool, NumClasses uint16, NumEvents byte, Events string, Classes []EventClass) SendExtensionEventCookie {
	cookie := c.NewCookie(true, false)
	c.NewRequest(sendExtensionEventRequest(c, Destination, DeviceId, Propagate, NumClasses, NumEvents, Events, Classes), cookie)
	return SendExtensionEventCookie{cookie}
}

func (cook SendExtensionEventCookie) Check() error {
	return cook.Cookie.Check()
}

// Write request to wire for SendExtensionEvent
func sendExtensionEventRequest(c *xgb.Conn, Destination xproto.Window, DeviceId byte, Propagate bool, NumClasses uint16, NumEvents byte, Events string, Classes []EventClass) []byte {
	size := xgb.Pad(((16 + xgb.Pad(((int(NumEvents) * 32) * 1))) + xgb.Pad((int(NumClasses) * 4))))
	b := 0
	buf := make([]byte, size)

	buf[b] = c.Extensions["XINPUTEXTENSION"]
	b += 1

	buf[b] = 31 // request opcode
	b += 1

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	xgb.Put32(buf[b:], uint32(Destination))
	b += 4

	buf[b] = DeviceId
	b += 1

	if Propagate {
		buf[b] = 1
	} else {
		buf[b] = 0
	}
	b += 1

	xgb.Put16(buf[b:], NumClasses)
	b += 2

	buf[b] = NumEvents
	b += 1

	b += 3 // padding

	copy(buf[b:], Events[:(int(NumEvents)*32)])
	b += xgb.Pad(int((int(NumEvents) * 32)))

	for i := 0; i < int(NumClasses); i++ {
		xgb.Put32(buf[b:], uint32(Classes[i]))
		b += 4
	}
	b = xgb.Pad(b)

	return buf
}

// Request DeviceBell
// size: 8
type DeviceBellCookie struct {
	*xgb.Cookie
}

// Write request to wire for DeviceBell
func DeviceBell(c *xgb.Conn, DeviceId byte, FeedbackId byte, FeedbackClass byte, Percent int8) DeviceBellCookie {
	cookie := c.NewCookie(false, false)
	c.NewRequest(deviceBellRequest(c, DeviceId, FeedbackId, FeedbackClass, Percent), cookie)
	return DeviceBellCookie{cookie}
}

func DeviceBellChecked(c *xgb.Conn, DeviceId byte, FeedbackId byte, FeedbackClass byte, Percent int8) DeviceBellCookie {
	cookie := c.NewCookie(true, false)
	c.NewRequest(deviceBellRequest(c, DeviceId, FeedbackId, FeedbackClass, Percent), cookie)
	return DeviceBellCookie{cookie}
}

func (cook DeviceBellCookie) Check() error {
	return cook.Cookie.Check()
}

// Write request to wire for DeviceBell
func deviceBellRequest(c *xgb.Conn, 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

	xgb.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 SetDeviceValuators
// size: xgb.Pad((8 + xgb.Pad((int(NumValuators) * 4))))
type SetDeviceValuatorsCookie struct {
	*xgb.Cookie
}

func SetDeviceValuators(c *xgb.Conn, DeviceId byte, FirstValuator byte, NumValuators byte, Valuators []int32) SetDeviceValuatorsCookie {
	cookie := c.NewCookie(true, true)
	c.NewRequest(setDeviceValuatorsRequest(c, DeviceId, FirstValuator, NumValuators, Valuators), cookie)
	return SetDeviceValuatorsCookie{cookie}
}

func SetDeviceValuatorsUnchecked(c *xgb.Conn, DeviceId byte, FirstValuator byte, NumValuators byte, Valuators []int32) SetDeviceValuatorsCookie {
	cookie := c.NewCookie(false, true)
	c.NewRequest(setDeviceValuatorsRequest(c, DeviceId, FirstValuator, NumValuators, Valuators), cookie)
	return SetDeviceValuatorsCookie{cookie}
}

// Request reply for SetDeviceValuators
// size: 32
type SetDeviceValuatorsReply struct {
	Sequence uint16
	Length   uint32
	// padding: 1 bytes
	Status byte
	// padding: 23 bytes
}

// Waits and reads reply data from request SetDeviceValuators
func (cook SetDeviceValuatorsCookie) Reply() (*SetDeviceValuatorsReply, error) {
	buf, err := cook.Cookie.Reply()
	if err != nil {
		return nil, err
	}
	if buf == nil {
		return nil, nil
	}
	return setDeviceValuatorsReply(buf), nil
}

// Read reply into structure from buffer for SetDeviceValuators
func setDeviceValuatorsReply(buf []byte) *SetDeviceValuatorsReply {
	v := new(SetDeviceValuatorsReply)
	b := 1 // skip reply determinant

	b += 1 // padding

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Length = xgb.Get32(buf[b:]) // 4-byte units
	b += 4

	v.Status = buf[b]
	b += 1

	b += 23 // padding

	return v
}

// Write request to wire for SetDeviceValuators
func setDeviceValuatorsRequest(c *xgb.Conn, DeviceId byte, FirstValuator byte, NumValuators byte, Valuators []int32) []byte {
	size := xgb.Pad((8 + xgb.Pad((int(NumValuators) * 4))))
	b := 0
	buf := make([]byte, size)

	buf[b] = c.Extensions["XINPUTEXTENSION"]
	b += 1

	buf[b] = 33 // request opcode
	b += 1

	xgb.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++ {
		xgb.Put32(buf[b:], uint32(Valuators[i]))
		b += 4
	}
	b = xgb.Pad(b)

	return buf
}

// Request GetDeviceControl
// size: 8
type GetDeviceControlCookie struct {
	*xgb.Cookie
}

func GetDeviceControl(c *xgb.Conn, ControlId uint16, DeviceId byte) GetDeviceControlCookie {
	cookie := c.NewCookie(true, true)
	c.NewRequest(getDeviceControlRequest(c, ControlId, DeviceId), cookie)
	return GetDeviceControlCookie{cookie}
}

func GetDeviceControlUnchecked(c *xgb.Conn, ControlId uint16, DeviceId byte) GetDeviceControlCookie {
	cookie := c.NewCookie(false, true)
	c.NewRequest(getDeviceControlRequest(c, ControlId, DeviceId), cookie)
	return GetDeviceControlCookie{cookie}
}

// Request reply for GetDeviceControl
// size: 32
type GetDeviceControlReply struct {
	Sequence uint16
	Length   uint32
	// padding: 1 bytes
	Status byte
	// padding: 23 bytes
}

// Waits and reads reply data from request GetDeviceControl
func (cook GetDeviceControlCookie) Reply() (*GetDeviceControlReply, error) {
	buf, err := cook.Cookie.Reply()
	if err != nil {
		return nil, err
	}
	if buf == nil {
		return nil, nil
	}
	return getDeviceControlReply(buf), nil
}

// Read reply into structure from buffer for GetDeviceControl
func getDeviceControlReply(buf []byte) *GetDeviceControlReply {
	v := new(GetDeviceControlReply)
	b := 1 // skip reply determinant

	b += 1 // padding

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Length = xgb.Get32(buf[b:]) // 4-byte units
	b += 4

	v.Status = buf[b]
	b += 1

	b += 23 // padding

	return v
}

// Write request to wire for GetDeviceControl
func getDeviceControlRequest(c *xgb.Conn, 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

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	xgb.Put16(buf[b:], ControlId)
	b += 2

	buf[b] = DeviceId
	b += 1

	b += 1 // padding

	return buf
}