a huge commit. splitting extensions into their own sub-packages.

1 files changed, 1927 insertions, 0 deletions

diff --git a/nexgb/sync/sync.go b/nexgb/sync/sync.go
new file mode 100644
index 0000000..689a5c3
--- /dev/null
+++ b/nexgb/sync/sync.go
@@ -0,0 +1,1927 @@
+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
+}