package sync

/*
	This file was generated by sync.xml on May 10 2012 4:20:28pm 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 SYNC extension.
func Init(c *xgb.Conn) error {
	reply, err := xproto.QueryExtension(c, 4, "SYNC").Reply()
	switch {
	case err != nil:
		return err
	case !reply.Present:
		return xgb.Errorf("No extension named SYNC could be found on on the server.")
	}

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

	return nil
}

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

// Skipping definition for base type 'Bool'

// Skipping definition for base type 'Float'

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

const (
	AlarmstateActive    = 0
	AlarmstateInactive  = 1
	AlarmstateDestroyed = 2
)

const (
	TesttypePositiveTransition = 0
	TesttypeNegativeTransition = 1
	TesttypePositiveComparison = 2
	TesttypeNegativeComparison = 3
)

const (
	ValuetypeAbsolute = 0
	ValuetypeRelative = 1
)

const (
	CaCounter   = 1
	CaValueType = 2
	CaValue     = 4
	CaTestType  = 8
	CaDelta     = 16
	CaEvents    = 32
)

type Alarm uint32

func NewAlarmId(c *xgb.Conn) (Alarm, error) {
	id, err := c.NewId()
	if err != nil {
		return 0, err
	}
	return Alarm(id), nil
}

type Counter uint32

func NewCounterId(c *xgb.Conn) (Counter, error) {
	id, err := c.NewId()
	if err != nil {
		return 0, err
	}
	return Counter(id), nil
}

type Fence uint32

func NewFenceId(c *xgb.Conn) (Fence, error) {
	id, err := c.NewId()
	if err != nil {
		return 0, err
	}
	return Fence(id), nil
}

// 'Int64' struct definition
// Size: 8
type Int64 struct {
	Hi int32
	Lo uint32
}

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

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

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

	return b
}

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

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

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

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

	return buf
}

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

// 'Systemcounter' struct definition
// Size: (14 + xgb.Pad((int(NameLen) * 1)))
type Systemcounter struct {
	Counter    Counter
	Resolution Int64
	NameLen    uint16
	Name       string // size: xgb.Pad((int(NameLen) * 1))
}

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

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

	v.Resolution = Int64{}
	b += Int64Read(buf[b:], &v.Resolution)

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

	{
		byteString := make([]byte, v.NameLen)
		copy(byteString[:v.NameLen], buf[b:])
		v.Name = string(byteString)
		b += xgb.Pad(int(v.NameLen))
	}

	return b
}

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

// Struct write Systemcounter
func (v Systemcounter) Bytes() []byte {
	buf := make([]byte, (14 + xgb.Pad((int(v.NameLen) * 1))))
	b := 0

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

	{
		structBytes := v.Resolution.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}

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

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

	return buf
}

// Write struct list Systemcounter
func SystemcounterListBytes(buf []byte, list []Systemcounter) 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 Systemcounter
func SystemcounterListSize(list []Systemcounter) int {
	size := 0
	for _, item := range list {
		size += (14 + xgb.Pad((int(item.NameLen) * 1)))
	}
	return size
}

// 'Trigger' struct definition
// Size: 20
type Trigger struct {
	Counter   Counter
	WaitType  uint32
	WaitValue Int64
	TestType  uint32
}

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

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

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

	v.WaitValue = Int64{}
	b += Int64Read(buf[b:], &v.WaitValue)

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

	return b
}

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

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

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

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

	{
		structBytes := v.WaitValue.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}

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

	return buf
}

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

// 'Waitcondition' struct definition
// Size: 28
type Waitcondition struct {
	Trigger        Trigger
	EventThreshold Int64
}

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

	v.Trigger = Trigger{}
	b += TriggerRead(buf[b:], &v.Trigger)

	v.EventThreshold = Int64{}
	b += Int64Read(buf[b:], &v.EventThreshold)

	return b
}

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

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

	{
		structBytes := v.Trigger.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}

	{
		structBytes := v.EventThreshold.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}

	return buf
}

// Write struct list Waitcondition
func WaitconditionListBytes(buf []byte, list []Waitcondition) 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 CounterNotify (0)
// Size: 32

const CounterNotify = 0

type CounterNotifyEvent struct {
	Sequence     uint16
	Kind         byte
	Counter      Counter
	WaitValue    Int64
	CounterValue Int64
	Timestamp    xproto.Timestamp
	Count        uint16
	Destroyed    bool
	// padding: 1 bytes
}

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

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

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

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

	v.WaitValue = Int64{}
	b += Int64Read(buf[b:], &v.WaitValue)

	v.CounterValue = Int64{}
	b += Int64Read(buf[b:], &v.CounterValue)

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

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

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

	b += 1 // padding

	return v
}

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

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

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

	b += 2 // skip sequence number

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

	{
		structBytes := v.WaitValue.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}

	{
		structBytes := v.CounterValue.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}

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

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

	if v.Destroyed {
		buf[b] = 1
	} else {
		buf[b] = 0
	}
	b += 1

	b += 1 // padding

	return buf
}

func (v CounterNotifyEvent) ImplementsEvent() {}

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

func (v CounterNotifyEvent) String() string {
	fieldVals := make([]string, 0, 8)
	fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", v.Sequence))
	fieldVals = append(fieldVals, xgb.Sprintf("Kind: %d", v.Kind))
	fieldVals = append(fieldVals, xgb.Sprintf("Counter: %d", v.Counter))
	fieldVals = append(fieldVals, xgb.Sprintf("Timestamp: %d", v.Timestamp))
	fieldVals = append(fieldVals, xgb.Sprintf("Count: %d", v.Count))
	fieldVals = append(fieldVals, xgb.Sprintf("Destroyed: %t", v.Destroyed))
	return "CounterNotify {" + xgb.StringsJoin(fieldVals, ", ") + "}"
}

func init() {
	xgb.NewExtEventFuncs["SYNC"][0] = CounterNotifyEventNew
}

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

const AlarmNotify = 1

type AlarmNotifyEvent struct {
	Sequence     uint16
	Kind         byte
	Alarm        Alarm
	CounterValue Int64
	AlarmValue   Int64
	Timestamp    xproto.Timestamp
	State        byte
	// padding: 3 bytes
}

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

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

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

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

	v.CounterValue = Int64{}
	b += Int64Read(buf[b:], &v.CounterValue)

	v.AlarmValue = Int64{}
	b += Int64Read(buf[b:], &v.AlarmValue)

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

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

	b += 3 // padding

	return v
}

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

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

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

	b += 2 // skip sequence number

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

	{
		structBytes := v.CounterValue.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}

	{
		structBytes := v.AlarmValue.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}

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

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

	b += 3 // padding

	return buf
}

func (v AlarmNotifyEvent) ImplementsEvent() {}

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

func (v AlarmNotifyEvent) String() string {
	fieldVals := make([]string, 0, 7)
	fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", v.Sequence))
	fieldVals = append(fieldVals, xgb.Sprintf("Kind: %d", v.Kind))
	fieldVals = append(fieldVals, xgb.Sprintf("Alarm: %d", v.Alarm))
	fieldVals = append(fieldVals, xgb.Sprintf("Timestamp: %d", v.Timestamp))
	fieldVals = append(fieldVals, xgb.Sprintf("State: %d", v.State))
	return "AlarmNotify {" + xgb.StringsJoin(fieldVals, ", ") + "}"
}

func init() {
	xgb.NewExtEventFuncs["SYNC"][1] = AlarmNotifyEventNew
}

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

const BadCounter = 0

type CounterError struct {
	Sequence    uint16
	NiceName    string
	BadCounter  uint32
	MinorOpcode uint16
	MajorOpcode byte
}

// Error read Counter
func CounterErrorNew(buf []byte) xgb.Error {
	v := CounterError{}
	v.NiceName = "Counter"

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

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

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

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

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

	return v
}

func (err CounterError) ImplementsError() {}

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

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

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

func init() {
	xgb.NewExtErrorFuncs["SYNC"][0] = CounterErrorNew
}

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

const BadAlarm = 1

type AlarmError struct {
	Sequence    uint16
	NiceName    string
	BadAlarm    uint32
	MinorOpcode uint16
	MajorOpcode byte
}

// Error read Alarm
func AlarmErrorNew(buf []byte) xgb.Error {
	v := AlarmError{}
	v.NiceName = "Alarm"

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

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

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

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

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

	return v
}

func (err AlarmError) ImplementsError() {}

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

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

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

func init() {
	xgb.NewExtErrorFuncs["SYNC"][1] = AlarmErrorNew
}

// Request Initialize
// size: 8
type InitializeCookie struct {
	*xgb.Cookie
}

func Initialize(c *xgb.Conn, DesiredMajorVersion byte, DesiredMinorVersion byte) InitializeCookie {
	cookie := c.NewCookie(true, true)
	c.NewRequest(initializeRequest(c, DesiredMajorVersion, DesiredMinorVersion), cookie)
	return InitializeCookie{cookie}
}

func InitializeUnchecked(c *xgb.Conn, DesiredMajorVersion byte, DesiredMinorVersion byte) InitializeCookie {
	cookie := c.NewCookie(false, true)
	c.NewRequest(initializeRequest(c, DesiredMajorVersion, DesiredMinorVersion), cookie)
	return InitializeCookie{cookie}
}

// Request reply for Initialize
// size: 32
type InitializeReply struct {
	Sequence uint16
	Length   uint32
	// padding: 1 bytes
	MajorVersion byte
	MinorVersion byte
	// padding: 22 bytes
}

// Waits and reads reply data from request Initialize
func (cook InitializeCookie) Reply() (*InitializeReply, error) {
	buf, err := cook.Cookie.Reply()
	if err != nil {
		return nil, err
	}
	if buf == nil {
		return nil, nil
	}
	return initializeReply(buf), nil
}

// Read reply into structure from buffer for Initialize
func initializeReply(buf []byte) *InitializeReply {
	v := new(InitializeReply)
	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.MajorVersion = buf[b]
	b += 1

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

	b += 22 // padding

	return v
}

// Write request to wire for Initialize
func initializeRequest(c *xgb.Conn, DesiredMajorVersion byte, DesiredMinorVersion byte) []byte {
	size := 8
	b := 0
	buf := make([]byte, size)

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

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

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

	buf[b] = DesiredMajorVersion
	b += 1

	buf[b] = DesiredMinorVersion
	b += 1

	return buf
}

// Request ListSystemCounters
// size: 4
type ListSystemCountersCookie struct {
	*xgb.Cookie
}

func ListSystemCounters(c *xgb.Conn) ListSystemCountersCookie {
	cookie := c.NewCookie(true, true)
	c.NewRequest(listSystemCountersRequest(c), cookie)
	return ListSystemCountersCookie{cookie}
}

func ListSystemCountersUnchecked(c *xgb.Conn) ListSystemCountersCookie {
	cookie := c.NewCookie(false, true)
	c.NewRequest(listSystemCountersRequest(c), cookie)
	return ListSystemCountersCookie{cookie}
}

// Request reply for ListSystemCounters
// size: (32 + SystemcounterListSize(Counters))
type ListSystemCountersReply struct {
	Sequence uint16
	Length   uint32
	// padding: 1 bytes
	CountersLen uint32
	// padding: 20 bytes
	Counters []Systemcounter // size: SystemcounterListSize(Counters)
}

// Waits and reads reply data from request ListSystemCounters
func (cook ListSystemCountersCookie) Reply() (*ListSystemCountersReply, error) {
	buf, err := cook.Cookie.Reply()
	if err != nil {
		return nil, err
	}
	if buf == nil {
		return nil, nil
	}
	return listSystemCountersReply(buf), nil
}

// Read reply into structure from buffer for ListSystemCounters
func listSystemCountersReply(buf []byte) *ListSystemCountersReply {
	v := new(ListSystemCountersReply)
	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.CountersLen = xgb.Get32(buf[b:])
	b += 4

	b += 20 // padding

	v.Counters = make([]Systemcounter, v.CountersLen)
	b += SystemcounterReadList(buf[b:], v.Counters)

	return v
}

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

	buf[b] = c.Extensions["SYNC"]
	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

	return buf
}

// Request CreateCounter
// size: 16
type CreateCounterCookie struct {
	*xgb.Cookie
}

// Write request to wire for CreateCounter
func CreateCounter(c *xgb.Conn, Id Counter, InitialValue Int64) CreateCounterCookie {
	cookie := c.NewCookie(false, false)
	c.NewRequest(createCounterRequest(c, Id, InitialValue), cookie)
	return CreateCounterCookie{cookie}
}

func CreateCounterChecked(c *xgb.Conn, Id Counter, InitialValue Int64) CreateCounterCookie {
	cookie := c.NewCookie(true, false)
	c.NewRequest(createCounterRequest(c, Id, InitialValue), cookie)
	return CreateCounterCookie{cookie}
}

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

// Write request to wire for CreateCounter
func createCounterRequest(c *xgb.Conn, Id Counter, InitialValue Int64) []byte {
	size := 16
	b := 0
	buf := make([]byte, size)

	buf[b] = c.Extensions["SYNC"]
	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

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

	{
		structBytes := InitialValue.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}

	return buf
}

// Request DestroyCounter
// size: 8
type DestroyCounterCookie struct {
	*xgb.Cookie
}

// Write request to wire for DestroyCounter
func DestroyCounter(c *xgb.Conn, Counter Counter) DestroyCounterCookie {
	cookie := c.NewCookie(false, false)
	c.NewRequest(destroyCounterRequest(c, Counter), cookie)
	return DestroyCounterCookie{cookie}
}

func DestroyCounterChecked(c *xgb.Conn, Counter Counter) DestroyCounterCookie {
	cookie := c.NewCookie(true, false)
	c.NewRequest(destroyCounterRequest(c, Counter), cookie)
	return DestroyCounterCookie{cookie}
}

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

// Write request to wire for DestroyCounter
func destroyCounterRequest(c *xgb.Conn, Counter Counter) []byte {
	size := 8
	b := 0
	buf := make([]byte, size)

	buf[b] = c.Extensions["SYNC"]
	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(Counter))
	b += 4

	return buf
}

// Request QueryCounter
// size: 8
type QueryCounterCookie struct {
	*xgb.Cookie
}

func QueryCounter(c *xgb.Conn, Counter Counter) QueryCounterCookie {
	cookie := c.NewCookie(true, true)
	c.NewRequest(queryCounterRequest(c, Counter), cookie)
	return QueryCounterCookie{cookie}
}

func QueryCounterUnchecked(c *xgb.Conn, Counter Counter) QueryCounterCookie {
	cookie := c.NewCookie(false, true)
	c.NewRequest(queryCounterRequest(c, Counter), cookie)
	return QueryCounterCookie{cookie}
}

// Request reply for QueryCounter
// size: 16
type QueryCounterReply struct {
	Sequence uint16
	Length   uint32
	// padding: 1 bytes
	CounterValue Int64
}

// Waits and reads reply data from request QueryCounter
func (cook QueryCounterCookie) Reply() (*QueryCounterReply, error) {
	buf, err := cook.Cookie.Reply()
	if err != nil {
		return nil, err
	}
	if buf == nil {
		return nil, nil
	}
	return queryCounterReply(buf), nil
}

// Read reply into structure from buffer for QueryCounter
func queryCounterReply(buf []byte) *QueryCounterReply {
	v := new(QueryCounterReply)
	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.CounterValue = Int64{}
	b += Int64Read(buf[b:], &v.CounterValue)

	return v
}

// Write request to wire for QueryCounter
func queryCounterRequest(c *xgb.Conn, Counter Counter) []byte {
	size := 8
	b := 0
	buf := make([]byte, size)

	buf[b] = c.Extensions["SYNC"]
	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

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

	return buf
}

// Request Await
// size: xgb.Pad((4 + xgb.Pad((len(WaitList) * 28))))
type AwaitCookie struct {
	*xgb.Cookie
}

// Write request to wire for Await
func Await(c *xgb.Conn, WaitList []Waitcondition) AwaitCookie {
	cookie := c.NewCookie(false, false)
	c.NewRequest(awaitRequest(c, WaitList), cookie)
	return AwaitCookie{cookie}
}

func AwaitChecked(c *xgb.Conn, WaitList []Waitcondition) AwaitCookie {
	cookie := c.NewCookie(true, false)
	c.NewRequest(awaitRequest(c, WaitList), cookie)
	return AwaitCookie{cookie}
}

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

// Write request to wire for Await
func awaitRequest(c *xgb.Conn, WaitList []Waitcondition) []byte {
	size := xgb.Pad((4 + xgb.Pad((len(WaitList) * 28))))
	b := 0
	buf := make([]byte, size)

	buf[b] = c.Extensions["SYNC"]
	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

	b += WaitconditionListBytes(buf[b:], WaitList)

	return buf
}

// Request ChangeCounter
// size: 16
type ChangeCounterCookie struct {
	*xgb.Cookie
}

// Write request to wire for ChangeCounter
func ChangeCounter(c *xgb.Conn, Counter Counter, Amount Int64) ChangeCounterCookie {
	cookie := c.NewCookie(false, false)
	c.NewRequest(changeCounterRequest(c, Counter, Amount), cookie)
	return ChangeCounterCookie{cookie}
}

func ChangeCounterChecked(c *xgb.Conn, Counter Counter, Amount Int64) ChangeCounterCookie {
	cookie := c.NewCookie(true, false)
	c.NewRequest(changeCounterRequest(c, Counter, Amount), cookie)
	return ChangeCounterCookie{cookie}
}

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

// Write request to wire for ChangeCounter
func changeCounterRequest(c *xgb.Conn, Counter Counter, Amount Int64) []byte {
	size := 16
	b := 0
	buf := make([]byte, size)

	buf[b] = c.Extensions["SYNC"]
	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

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

	{
		structBytes := Amount.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}

	return buf
}

// Request SetCounter
// size: 16
type SetCounterCookie struct {
	*xgb.Cookie
}

// Write request to wire for SetCounter
func SetCounter(c *xgb.Conn, Counter Counter, Value Int64) SetCounterCookie {
	cookie := c.NewCookie(false, false)
	c.NewRequest(setCounterRequest(c, Counter, Value), cookie)
	return SetCounterCookie{cookie}
}

func SetCounterChecked(c *xgb.Conn, Counter Counter, Value Int64) SetCounterCookie {
	cookie := c.NewCookie(true, false)
	c.NewRequest(setCounterRequest(c, Counter, Value), cookie)
	return SetCounterCookie{cookie}
}

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

// Write request to wire for SetCounter
func setCounterRequest(c *xgb.Conn, Counter Counter, Value Int64) []byte {
	size := 16
	b := 0
	buf := make([]byte, size)

	buf[b] = c.Extensions["SYNC"]
	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

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

	{
		structBytes := Value.Bytes()
		copy(buf[b:], structBytes)
		b += xgb.Pad(len(structBytes))
	}

	return buf
}

// Request CreateAlarm
// size: xgb.Pad((8 + (4 + xgb.Pad((4 * xgb.PopCount(int(ValueMask)))))))
type CreateAlarmCookie struct {
	*xgb.Cookie
}

// Write request to wire for CreateAlarm
func CreateAlarm(c *xgb.Conn, Id Alarm, ValueMask uint32, ValueList []uint32) CreateAlarmCookie {
	cookie := c.NewCookie(false, false)
	c.NewRequest(createAlarmRequest(c, Id, ValueMask, ValueList), cookie)
	return CreateAlarmCookie{cookie}
}

func CreateAlarmChecked(c *xgb.Conn, Id Alarm, ValueMask uint32, ValueList []uint32) CreateAlarmCookie {
	cookie := c.NewCookie(true, false)
	c.NewRequest(createAlarmRequest(c, Id, ValueMask, ValueList), cookie)
	return CreateAlarmCookie{cookie}
}

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

// Write request to wire for CreateAlarm
func createAlarmRequest(c *xgb.Conn, Id Alarm, ValueMask uint32, ValueList []uint32) []byte {
	size := xgb.Pad((8 + (4 + xgb.Pad((4 * xgb.PopCount(int(ValueMask)))))))
	b := 0
	buf := make([]byte, size)

	buf[b] = c.Extensions["SYNC"]
	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(Id))
	b += 4

	xgb.Put32(buf[b:], ValueMask)
	b += 4
	for i := 0; i < xgb.PopCount(int(ValueMask)); i++ {
		xgb.Put32(buf[b:], ValueList[i])
		b += 4
	}
	b = xgb.Pad(b)

	return buf
}

// Request ChangeAlarm
// size: xgb.Pad((8 + (4 + xgb.Pad((4 * xgb.PopCount(int(ValueMask)))))))
type ChangeAlarmCookie struct {
	*xgb.Cookie
}

// Write request to wire for ChangeAlarm
func ChangeAlarm(c *xgb.Conn, Id Alarm, ValueMask uint32, ValueList []uint32) ChangeAlarmCookie {
	cookie := c.NewCookie(false, false)
	c.NewRequest(changeAlarmRequest(c, Id, ValueMask, ValueList), cookie)
	return ChangeAlarmCookie{cookie}
}

func ChangeAlarmChecked(c *xgb.Conn, Id Alarm, ValueMask uint32, ValueList []uint32) ChangeAlarmCookie {
	cookie := c.NewCookie(true, false)
	c.NewRequest(changeAlarmRequest(c, Id, ValueMask, ValueList), cookie)
	return ChangeAlarmCookie{cookie}
}

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

// Write request to wire for ChangeAlarm
func changeAlarmRequest(c *xgb.Conn, Id Alarm, ValueMask uint32, ValueList []uint32) []byte {
	size := xgb.Pad((8 + (4 + xgb.Pad((4 * xgb.PopCount(int(ValueMask)))))))
	b := 0
	buf := make([]byte, size)

	buf[b] = c.Extensions["SYNC"]
	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(Id))
	b += 4

	xgb.Put32(buf[b:], ValueMask)
	b += 4
	for i := 0; i < xgb.PopCount(int(ValueMask)); i++ {
		xgb.Put32(buf[b:], ValueList[i])
		b += 4
	}
	b = xgb.Pad(b)

	return buf
}

// Request DestroyAlarm
// size: 8
type DestroyAlarmCookie struct {
	*xgb.Cookie
}

// Write request to wire for DestroyAlarm
func DestroyAlarm(c *xgb.Conn, Alarm Alarm) DestroyAlarmCookie {
	cookie := c.NewCookie(false, false)
	c.NewRequest(destroyAlarmRequest(c, Alarm), cookie)
	return DestroyAlarmCookie{cookie}
}

func DestroyAlarmChecked(c *xgb.Conn, Alarm Alarm) DestroyAlarmCookie {
	cookie := c.NewCookie(true, false)
	c.NewRequest(destroyAlarmRequest(c, Alarm), cookie)
	return DestroyAlarmCookie{cookie}
}

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

// Write request to wire for DestroyAlarm
func destroyAlarmRequest(c *xgb.Conn, Alarm Alarm) []byte {
	size := 8
	b := 0
	buf := make([]byte, size)

	buf[b] = c.Extensions["SYNC"]
	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

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

	return buf
}

// Request QueryAlarm
// size: 8
type QueryAlarmCookie struct {
	*xgb.Cookie
}

func QueryAlarm(c *xgb.Conn, Alarm Alarm) QueryAlarmCookie {
	cookie := c.NewCookie(true, true)
	c.NewRequest(queryAlarmRequest(c, Alarm), cookie)
	return QueryAlarmCookie{cookie}
}

func QueryAlarmUnchecked(c *xgb.Conn, Alarm Alarm) QueryAlarmCookie {
	cookie := c.NewCookie(false, true)
	c.NewRequest(queryAlarmRequest(c, Alarm), cookie)
	return QueryAlarmCookie{cookie}
}

// Request reply for QueryAlarm
// size: 40
type QueryAlarmReply struct {
	Sequence uint16
	Length   uint32
	// padding: 1 bytes
	Trigger Trigger
	Delta   Int64
	Events  bool
	State   byte
	// padding: 2 bytes
}

// Waits and reads reply data from request QueryAlarm
func (cook QueryAlarmCookie) Reply() (*QueryAlarmReply, error) {
	buf, err := cook.Cookie.Reply()
	if err != nil {
		return nil, err
	}
	if buf == nil {
		return nil, nil
	}
	return queryAlarmReply(buf), nil
}

// Read reply into structure from buffer for QueryAlarm
func queryAlarmReply(buf []byte) *QueryAlarmReply {
	v := new(QueryAlarmReply)
	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.Trigger = Trigger{}
	b += TriggerRead(buf[b:], &v.Trigger)

	v.Delta = Int64{}
	b += Int64Read(buf[b:], &v.Delta)

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

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

	b += 2 // padding

	return v
}

// Write request to wire for QueryAlarm
func queryAlarmRequest(c *xgb.Conn, Alarm Alarm) []byte {
	size := 8
	b := 0
	buf := make([]byte, size)

	buf[b] = c.Extensions["SYNC"]
	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(Alarm))
	b += 4

	return buf
}

// Request SetPriority
// size: 12
type SetPriorityCookie struct {
	*xgb.Cookie
}

// Write request to wire for SetPriority
func SetPriority(c *xgb.Conn, Id uint32, Priority int32) SetPriorityCookie {
	cookie := c.NewCookie(false, false)
	c.NewRequest(setPriorityRequest(c, Id, Priority), cookie)
	return SetPriorityCookie{cookie}
}

func SetPriorityChecked(c *xgb.Conn, Id uint32, Priority int32) SetPriorityCookie {
	cookie := c.NewCookie(true, false)
	c.NewRequest(setPriorityRequest(c, Id, Priority), cookie)
	return SetPriorityCookie{cookie}
}

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

// Write request to wire for SetPriority
func setPriorityRequest(c *xgb.Conn, Id uint32, Priority int32) []byte {
	size := 12
	b := 0
	buf := make([]byte, size)

	buf[b] = c.Extensions["SYNC"]
	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

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

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

	return buf
}

// Request GetPriority
// size: 8
type GetPriorityCookie struct {
	*xgb.Cookie
}

func GetPriority(c *xgb.Conn, Id uint32) GetPriorityCookie {
	cookie := c.NewCookie(true, true)
	c.NewRequest(getPriorityRequest(c, Id), cookie)
	return GetPriorityCookie{cookie}
}

func GetPriorityUnchecked(c *xgb.Conn, Id uint32) GetPriorityCookie {
	cookie := c.NewCookie(false, true)
	c.NewRequest(getPriorityRequest(c, Id), cookie)
	return GetPriorityCookie{cookie}
}

// Request reply for GetPriority
// size: 12
type GetPriorityReply struct {
	Sequence uint16
	Length   uint32
	// padding: 1 bytes
	Priority int32
}

// Waits and reads reply data from request GetPriority
func (cook GetPriorityCookie) Reply() (*GetPriorityReply, error) {
	buf, err := cook.Cookie.Reply()
	if err != nil {
		return nil, err
	}
	if buf == nil {
		return nil, nil
	}
	return getPriorityReply(buf), nil
}

// Read reply into structure from buffer for GetPriority
func getPriorityReply(buf []byte) *GetPriorityReply {
	v := new(GetPriorityReply)
	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.Priority = int32(xgb.Get32(buf[b:]))
	b += 4

	return v
}

// Write request to wire for GetPriority
func getPriorityRequest(c *xgb.Conn, Id uint32) []byte {
	size := 8
	b := 0
	buf := make([]byte, size)

	buf[b] = c.Extensions["SYNC"]
	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:], Id)
	b += 4

	return buf
}

// Request CreateFence
// size: 16
type CreateFenceCookie struct {
	*xgb.Cookie
}

// Write request to wire for CreateFence
func CreateFence(c *xgb.Conn, Drawable xproto.Drawable, Fence Fence, InitiallyTriggered bool) CreateFenceCookie {
	cookie := c.NewCookie(false, false)
	c.NewRequest(createFenceRequest(c, Drawable, Fence, InitiallyTriggered), cookie)
	return CreateFenceCookie{cookie}
}

func CreateFenceChecked(c *xgb.Conn, Drawable xproto.Drawable, Fence Fence, InitiallyTriggered bool) CreateFenceCookie {
	cookie := c.NewCookie(true, false)
	c.NewRequest(createFenceRequest(c, Drawable, Fence, InitiallyTriggered), cookie)
	return CreateFenceCookie{cookie}
}

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

// Write request to wire for CreateFence
func createFenceRequest(c *xgb.Conn, Drawable xproto.Drawable, Fence Fence, InitiallyTriggered bool) []byte {
	size := 16
	b := 0
	buf := make([]byte, size)

	buf[b] = c.Extensions["SYNC"]
	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(Drawable))
	b += 4

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

	if InitiallyTriggered {
		buf[b] = 1
	} else {
		buf[b] = 0
	}
	b += 1

	return buf
}

// Request TriggerFence
// size: 8
type TriggerFenceCookie struct {
	*xgb.Cookie
}

// Write request to wire for TriggerFence
func TriggerFence(c *xgb.Conn, Fence Fence) TriggerFenceCookie {
	cookie := c.NewCookie(false, false)
	c.NewRequest(triggerFenceRequest(c, Fence), cookie)
	return TriggerFenceCookie{cookie}
}

func TriggerFenceChecked(c *xgb.Conn, Fence Fence) TriggerFenceCookie {
	cookie := c.NewCookie(true, false)
	c.NewRequest(triggerFenceRequest(c, Fence), cookie)
	return TriggerFenceCookie{cookie}
}

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

// Write request to wire for TriggerFence
func triggerFenceRequest(c *xgb.Conn, Fence Fence) []byte {
	size := 8
	b := 0
	buf := make([]byte, size)

	buf[b] = c.Extensions["SYNC"]
	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(Fence))
	b += 4

	return buf
}

// Request ResetFence
// size: 8
type ResetFenceCookie struct {
	*xgb.Cookie
}

// Write request to wire for ResetFence
func ResetFence(c *xgb.Conn, Fence Fence) ResetFenceCookie {
	cookie := c.NewCookie(false, false)
	c.NewRequest(resetFenceRequest(c, Fence), cookie)
	return ResetFenceCookie{cookie}
}

func ResetFenceChecked(c *xgb.Conn, Fence Fence) ResetFenceCookie {
	cookie := c.NewCookie(true, false)
	c.NewRequest(resetFenceRequest(c, Fence), cookie)
	return ResetFenceCookie{cookie}
}

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

// Write request to wire for ResetFence
func resetFenceRequest(c *xgb.Conn, Fence Fence) []byte {
	size := 8
	b := 0
	buf := make([]byte, size)

	buf[b] = c.Extensions["SYNC"]
	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(Fence))
	b += 4

	return buf
}

// Request DestroyFence
// size: 8
type DestroyFenceCookie struct {
	*xgb.Cookie
}

// Write request to wire for DestroyFence
func DestroyFence(c *xgb.Conn, Fence Fence) DestroyFenceCookie {
	cookie := c.NewCookie(false, false)
	c.NewRequest(destroyFenceRequest(c, Fence), cookie)
	return DestroyFenceCookie{cookie}
}

func DestroyFenceChecked(c *xgb.Conn, Fence Fence) DestroyFenceCookie {
	cookie := c.NewCookie(true, false)
	c.NewRequest(destroyFenceRequest(c, Fence), cookie)
	return DestroyFenceCookie{cookie}
}

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

// Write request to wire for DestroyFence
func destroyFenceRequest(c *xgb.Conn, Fence Fence) []byte {
	size := 8
	b := 0
	buf := make([]byte, size)

	buf[b] = c.Extensions["SYNC"]
	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(Fence))
	b += 4

	return buf
}

// Request QueryFence
// size: 8
type QueryFenceCookie struct {
	*xgb.Cookie
}

func QueryFence(c *xgb.Conn, Fence Fence) QueryFenceCookie {
	cookie := c.NewCookie(true, true)
	c.NewRequest(queryFenceRequest(c, Fence), cookie)
	return QueryFenceCookie{cookie}
}

func QueryFenceUnchecked(c *xgb.Conn, Fence Fence) QueryFenceCookie {
	cookie := c.NewCookie(false, true)
	c.NewRequest(queryFenceRequest(c, Fence), cookie)
	return QueryFenceCookie{cookie}
}

// Request reply for QueryFence
// size: 32
type QueryFenceReply struct {
	Sequence uint16
	Length   uint32
	// padding: 1 bytes
	Triggered bool
	// padding: 23 bytes
}

// Waits and reads reply data from request QueryFence
func (cook QueryFenceCookie) Reply() (*QueryFenceReply, error) {
	buf, err := cook.Cookie.Reply()
	if err != nil {
		return nil, err
	}
	if buf == nil {
		return nil, nil
	}
	return queryFenceReply(buf), nil
}

// Read reply into structure from buffer for QueryFence
func queryFenceReply(buf []byte) *QueryFenceReply {
	v := new(QueryFenceReply)
	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

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

	b += 23 // padding

	return v
}

// Write request to wire for QueryFence
func queryFenceRequest(c *xgb.Conn, Fence Fence) []byte {
	size := 8
	b := 0
	buf := make([]byte, size)

	buf[b] = c.Extensions["SYNC"]
	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(Fence))
	b += 4

	return buf
}

// Request AwaitFence
// size: xgb.Pad((4 + xgb.Pad((len(FenceList) * 4))))
type AwaitFenceCookie struct {
	*xgb.Cookie
}

// Write request to wire for AwaitFence
func AwaitFence(c *xgb.Conn, FenceList []Fence) AwaitFenceCookie {
	cookie := c.NewCookie(false, false)
	c.NewRequest(awaitFenceRequest(c, FenceList), cookie)
	return AwaitFenceCookie{cookie}
}

func AwaitFenceChecked(c *xgb.Conn, FenceList []Fence) AwaitFenceCookie {
	cookie := c.NewCookie(true, false)
	c.NewRequest(awaitFenceRequest(c, FenceList), cookie)
	return AwaitFenceCookie{cookie}
}

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

// Write request to wire for AwaitFence
func awaitFenceRequest(c *xgb.Conn, FenceList []Fence) []byte {
	size := xgb.Pad((4 + xgb.Pad((len(FenceList) * 4))))
	b := 0
	buf := make([]byte, size)

	buf[b] = c.Extensions["SYNC"]
	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

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

	return buf
}