Regenerate xgb with latest XML descriptions.

nexgb/glx/glx.go

@@ -495,6 +495,122 @@ func init() {
 
 type Bool32 uint32
 
+// BufferSwapComplete is the event number for a BufferSwapCompleteEvent.
+const BufferSwapComplete = 1
+
+type BufferSwapCompleteEvent struct {
+	Sequence uint16
+	// padding: 1 bytes
+	EventType uint16
+	// padding: 2 bytes
+	Drawable Drawable
+	UstHi    uint32
+	UstLo    uint32
+	MscHi    uint32
+	MscLo    uint32
+	Sbc      uint32
+}
+
+// BufferSwapCompleteEventNew constructs a BufferSwapCompleteEvent value that implements xgb.Event from a byte slice.
+func BufferSwapCompleteEventNew(buf []byte) xgb.Event {
+	v := BufferSwapCompleteEvent{}
+	b := 1 // don't read event number
+
+	b += 1 // padding
+
+	v.Sequence = xgb.Get16(buf[b:])
+	b += 2
+
+	v.EventType = xgb.Get16(buf[b:])
+	b += 2
+
+	b += 2 // padding
+
+	v.Drawable = Drawable(xgb.Get32(buf[b:]))
+	b += 4
+
+	v.UstHi = xgb.Get32(buf[b:])
+	b += 4
+
+	v.UstLo = xgb.Get32(buf[b:])
+	b += 4
+
+	v.MscHi = xgb.Get32(buf[b:])
+	b += 4
+
+	v.MscLo = xgb.Get32(buf[b:])
+	b += 4
+
+	v.Sbc = xgb.Get32(buf[b:])
+	b += 4
+
+	return v
+}
+
+// Bytes writes a BufferSwapCompleteEvent value to a byte slice.
+func (v BufferSwapCompleteEvent) Bytes() []byte {
+	buf := make([]byte, 32)
+	b := 0
+
+	// write event number
+	buf[b] = 1
+	b += 1
+
+	b += 1 // padding
+
+	b += 2 // skip sequence number
+
+	xgb.Put16(buf[b:], v.EventType)
+	b += 2
+
+	b += 2 // padding
+
+	xgb.Put32(buf[b:], uint32(v.Drawable))
+	b += 4
+
+	xgb.Put32(buf[b:], v.UstHi)
+	b += 4
+
+	xgb.Put32(buf[b:], v.UstLo)
+	b += 4
+
+	xgb.Put32(buf[b:], v.MscHi)
+	b += 4
+
+	xgb.Put32(buf[b:], v.MscLo)
+	b += 4
+
+	xgb.Put32(buf[b:], v.Sbc)
+	b += 4
+
+	return buf
+}
+
+// SequenceId returns the sequence id attached to the BufferSwapComplete event.
+// Events without a sequence number (KeymapNotify) return 0.
+// This is mostly used internally.
+func (v BufferSwapCompleteEvent) SequenceId() uint16 {
+	return v.Sequence
+}
+
+// String is a rudimentary string representation of BufferSwapCompleteEvent.
+func (v BufferSwapCompleteEvent) String() string {
+	fieldVals := make([]string, 0, 9)
+	fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", v.Sequence))
+	fieldVals = append(fieldVals, xgb.Sprintf("EventType: %d", v.EventType))
+	fieldVals = append(fieldVals, xgb.Sprintf("Drawable: %d", v.Drawable))
+	fieldVals = append(fieldVals, xgb.Sprintf("UstHi: %d", v.UstHi))
+	fieldVals = append(fieldVals, xgb.Sprintf("UstLo: %d", v.UstLo))
+	fieldVals = append(fieldVals, xgb.Sprintf("MscHi: %d", v.MscHi))
+	fieldVals = append(fieldVals, xgb.Sprintf("MscLo: %d", v.MscLo))
+	fieldVals = append(fieldVals, xgb.Sprintf("Sbc: %d", v.Sbc))
+	return "BufferSwapComplete {" + xgb.StringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+	xgb.NewExtEventFuncs["GLX"][1] = BufferSwapCompleteEventNew
+}
+
 type Context uint32
 
 func NewContextId(c *xgb.Conn) (Context, error) {

nexgb/res/res.go

@@ -91,6 +91,342 @@ func ClientListBytes(buf []byte, list []Client) int {
 	return xgb.Pad(b)
 }
 
+const (
+	ClientIdMaskClientXID      = 1
+	ClientIdMaskLocalClientPID = 2
+)
+
+type ClientIdSpec struct {
+	Client uint32
+	Mask   uint32
+}
+
+// ClientIdSpecRead reads a byte slice into a ClientIdSpec value.
+func ClientIdSpecRead(buf []byte, v *ClientIdSpec) int {
+	b := 0
+
+	v.Client = xgb.Get32(buf[b:])
+	b += 4
+
+	v.Mask = xgb.Get32(buf[b:])
+	b += 4
+
+	return b
+}
+
+// ClientIdSpecReadList reads a byte slice into a list of ClientIdSpec values.
+func ClientIdSpecReadList(buf []byte, dest []ClientIdSpec) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = ClientIdSpec{}
+		b += ClientIdSpecRead(buf[b:], &dest[i])
+	}
+	return xgb.Pad(b)
+}
+
+// Bytes writes a ClientIdSpec value to a byte slice.
+func (v ClientIdSpec) Bytes() []byte {
+	buf := make([]byte, 8)
+	b := 0
+
+	xgb.Put32(buf[b:], v.Client)
+	b += 4
+
+	xgb.Put32(buf[b:], v.Mask)
+	b += 4
+
+	return buf
+}
+
+// ClientIdSpecListBytes writes a list of ClientIdSpec values to a byte slice.
+func ClientIdSpecListBytes(buf []byte, list []ClientIdSpec) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += len(structBytes)
+	}
+	return xgb.Pad(b)
+}
+
+type ClientIdValue struct {
+	Spec   ClientIdSpec
+	Length uint32
+	Value  []uint32 // size: xgb.Pad((int(Length) * 4))
+}
+
+// ClientIdValueRead reads a byte slice into a ClientIdValue value.
+func ClientIdValueRead(buf []byte, v *ClientIdValue) int {
+	b := 0
+
+	v.Spec = ClientIdSpec{}
+	b += ClientIdSpecRead(buf[b:], &v.Spec)
+
+	v.Length = xgb.Get32(buf[b:])
+	b += 4
+
+	v.Value = make([]uint32, v.Length)
+	for i := 0; i < int(v.Length); i++ {
+		v.Value[i] = xgb.Get32(buf[b:])
+		b += 4
+	}
+	b = xgb.Pad(b)
+
+	return b
+}
+
+// ClientIdValueReadList reads a byte slice into a list of ClientIdValue values.
+func ClientIdValueReadList(buf []byte, dest []ClientIdValue) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = ClientIdValue{}
+		b += ClientIdValueRead(buf[b:], &dest[i])
+	}
+	return xgb.Pad(b)
+}
+
+// Bytes writes a ClientIdValue value to a byte slice.
+func (v ClientIdValue) Bytes() []byte {
+	buf := make([]byte, (12 + xgb.Pad((int(v.Length) * 4))))
+	b := 0
+
+	{
+		structBytes := v.Spec.Bytes()
+		copy(buf[b:], structBytes)
+		b += xgb.Pad(len(structBytes))
+	}
+
+	xgb.Put32(buf[b:], v.Length)
+	b += 4
+
+	for i := 0; i < int(v.Length); i++ {
+		xgb.Put32(buf[b:], v.Value[i])
+		b += 4
+	}
+	b = xgb.Pad(b)
+
+	return buf
+}
+
+// ClientIdValueListBytes writes a list of ClientIdValue values to a byte slice.
+func ClientIdValueListBytes(buf []byte, list []ClientIdValue) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += len(structBytes)
+	}
+	return xgb.Pad(b)
+}
+
+// ClientIdValueListSize computes the size (bytes) of a list of ClientIdValue values.
+func ClientIdValueListSize(list []ClientIdValue) int {
+	size := 0
+	for _, item := range list {
+		size += (12 + xgb.Pad((int(item.Length) * 4)))
+	}
+	return size
+}
+
+type ResourceIdSpec struct {
+	Resource uint32
+	Type     uint32
+}
+
+// ResourceIdSpecRead reads a byte slice into a ResourceIdSpec value.
+func ResourceIdSpecRead(buf []byte, v *ResourceIdSpec) int {
+	b := 0
+
+	v.Resource = xgb.Get32(buf[b:])
+	b += 4
+
+	v.Type = xgb.Get32(buf[b:])
+	b += 4
+
+	return b
+}
+
+// ResourceIdSpecReadList reads a byte slice into a list of ResourceIdSpec values.
+func ResourceIdSpecReadList(buf []byte, dest []ResourceIdSpec) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = ResourceIdSpec{}
+		b += ResourceIdSpecRead(buf[b:], &dest[i])
+	}
+	return xgb.Pad(b)
+}
+
+// Bytes writes a ResourceIdSpec value to a byte slice.
+func (v ResourceIdSpec) Bytes() []byte {
+	buf := make([]byte, 8)
+	b := 0
+
+	xgb.Put32(buf[b:], v.Resource)
+	b += 4
+
+	xgb.Put32(buf[b:], v.Type)
+	b += 4
+
+	return buf
+}
+
+// ResourceIdSpecListBytes writes a list of ResourceIdSpec values to a byte slice.
+func ResourceIdSpecListBytes(buf []byte, list []ResourceIdSpec) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += len(structBytes)
+	}
+	return xgb.Pad(b)
+}
+
+type ResourceSizeSpec struct {
+	Spec     ResourceIdSpec
+	Bytes    uint32
+	RefCount uint32
+	UseCount uint32
+}
+
+// ResourceSizeSpecRead reads a byte slice into a ResourceSizeSpec value.
+func ResourceSizeSpecRead(buf []byte, v *ResourceSizeSpec) int {
+	b := 0
+
+	v.Spec = ResourceIdSpec{}
+	b += ResourceIdSpecRead(buf[b:], &v.Spec)
+
+	v.Bytes = xgb.Get32(buf[b:])
+	b += 4
+
+	v.RefCount = xgb.Get32(buf[b:])
+	b += 4
+
+	v.UseCount = xgb.Get32(buf[b:])
+	b += 4
+
+	return b
+}
+
+// ResourceSizeSpecReadList reads a byte slice into a list of ResourceSizeSpec values.
+func ResourceSizeSpecReadList(buf []byte, dest []ResourceSizeSpec) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = ResourceSizeSpec{}
+		b += ResourceSizeSpecRead(buf[b:], &dest[i])
+	}
+	return xgb.Pad(b)
+}
+
+// Bytes writes a ResourceSizeSpec value to a byte slice.
+func (v ResourceSizeSpec) Bytes() []byte {
+	buf := make([]byte, 20)
+	b := 0
+
+	{
+		structBytes := v.Spec.Bytes()
+		copy(buf[b:], structBytes)
+		b += xgb.Pad(len(structBytes))
+	}
+
+	xgb.Put32(buf[b:], v.Bytes)
+	b += 4
+
+	xgb.Put32(buf[b:], v.RefCount)
+	b += 4
+
+	xgb.Put32(buf[b:], v.UseCount)
+	b += 4
+
+	return buf
+}
+
+// ResourceSizeSpecListBytes writes a list of ResourceSizeSpec values to a byte slice.
+func ResourceSizeSpecListBytes(buf []byte, list []ResourceSizeSpec) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += len(structBytes)
+	}
+	return xgb.Pad(b)
+}
+
+type ResourceSizeValue struct {
+	Size               ResourceSizeSpec
+	NumCrossReferences uint32
+	CrossReferences    []ResourceSizeSpec // size: xgb.Pad((int(NumCrossReferences) * 20))
+}
+
+// ResourceSizeValueRead reads a byte slice into a ResourceSizeValue value.
+func ResourceSizeValueRead(buf []byte, v *ResourceSizeValue) int {
+	b := 0
+
+	v.Size = ResourceSizeSpec{}
+	b += ResourceSizeSpecRead(buf[b:], &v.Size)
+
+	v.NumCrossReferences = xgb.Get32(buf[b:])
+	b += 4
+
+	v.CrossReferences = make([]ResourceSizeSpec, v.NumCrossReferences)
+	b += ResourceSizeSpecReadList(buf[b:], v.CrossReferences)
+
+	return b
+}
+
+// ResourceSizeValueReadList reads a byte slice into a list of ResourceSizeValue values.
+func ResourceSizeValueReadList(buf []byte, dest []ResourceSizeValue) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = ResourceSizeValue{}
+		b += ResourceSizeValueRead(buf[b:], &dest[i])
+	}
+	return xgb.Pad(b)
+}
+
+// Bytes writes a ResourceSizeValue value to a byte slice.
+func (v ResourceSizeValue) Bytes() []byte {
+	buf := make([]byte, (24 + xgb.Pad((int(v.NumCrossReferences) * 20))))
+	b := 0
+
+	{
+		structBytes := v.Size.Bytes()
+		copy(buf[b:], structBytes)
+		b += xgb.Pad(len(structBytes))
+	}
+
+	xgb.Put32(buf[b:], v.NumCrossReferences)
+	b += 4
+
+	b += ResourceSizeSpecListBytes(buf[b:], v.CrossReferences)
+
+	return buf
+}
+
+// ResourceSizeValueListBytes writes a list of ResourceSizeValue values to a byte slice.
+func ResourceSizeValueListBytes(buf []byte, list []ResourceSizeValue) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += len(structBytes)
+	}
+	return xgb.Pad(b)
+}
+
+// ResourceSizeValueListSize computes the size (bytes) of a list of ResourceSizeValue values.
+func ResourceSizeValueListSize(list []ResourceSizeValue) int {
+	size := 0
+	for _, item := range list {
+		size += (24 + xgb.Pad((int(item.NumCrossReferences) * 20)))
+	}
+	return size
+}
+
 type Type struct {
 	ResourceType xproto.Atom
 	Count        uint32
@@ -169,6 +505,103 @@ func TypeListBytes(buf []byte, list []Type) int {
 
 // Skipping definition for base type 'Card32'
 
+// QueryClientIdsCookie is a cookie used only for QueryClientIds requests.
+type QueryClientIdsCookie struct {
+	*xgb.Cookie
+}
+
+// QueryClientIds sends a checked request.
+// If an error occurs, it will be returned with the reply by calling QueryClientIdsCookie.Reply()
+func QueryClientIds(c *xgb.Conn, NumSpecs uint32, Specs []ClientIdSpec) QueryClientIdsCookie {
+	if _, ok := c.Extensions["X-RESOURCE"]; !ok {
+		panic("Cannot issue request 'QueryClientIds' using the uninitialized extension 'X-Resource'. res.Init(connObj) must be called first.")
+	}
+	cookie := c.NewCookie(true, true)
+	c.NewRequest(queryClientIdsRequest(c, NumSpecs, Specs), cookie)
+	return QueryClientIdsCookie{cookie}
+}
+
+// QueryClientIdsUnchecked sends an unchecked request.
+// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
+func QueryClientIdsUnchecked(c *xgb.Conn, NumSpecs uint32, Specs []ClientIdSpec) QueryClientIdsCookie {
+	if _, ok := c.Extensions["X-RESOURCE"]; !ok {
+		panic("Cannot issue request 'QueryClientIds' using the uninitialized extension 'X-Resource'. res.Init(connObj) must be called first.")
+	}
+	cookie := c.NewCookie(false, true)
+	c.NewRequest(queryClientIdsRequest(c, NumSpecs, Specs), cookie)
+	return QueryClientIdsCookie{cookie}
+}
+
+// QueryClientIdsReply represents the data returned from a QueryClientIds request.
+type QueryClientIdsReply struct {
+	Sequence uint16 // sequence number of the request for this reply
+	Length   uint32 // number of bytes in this reply
+	// padding: 1 bytes
+	NumIds uint32
+	// padding: 20 bytes
+	Ids []ClientIdValue // size: ClientIdValueListSize(Ids)
+}
+
+// Reply blocks and returns the reply data for a QueryClientIds request.
+func (cook QueryClientIdsCookie) Reply() (*QueryClientIdsReply, error) {
+	buf, err := cook.Cookie.Reply()
+	if err != nil {
+		return nil, err
+	}
+	if buf == nil {
+		return nil, nil
+	}
+	return queryClientIdsReply(buf), nil
+}
+
+// queryClientIdsReply reads a byte slice into a QueryClientIdsReply value.
+func queryClientIdsReply(buf []byte) *QueryClientIdsReply {
+	v := new(QueryClientIdsReply)
+	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.NumIds = xgb.Get32(buf[b:])
+	b += 4
+
+	b += 20 // padding
+
+	v.Ids = make([]ClientIdValue, v.NumIds)
+	b += ClientIdValueReadList(buf[b:], v.Ids)
+
+	return v
+}
+
+// Write request to wire for QueryClientIds
+// queryClientIdsRequest writes a QueryClientIds request to a byte slice.
+func queryClientIdsRequest(c *xgb.Conn, NumSpecs uint32, Specs []ClientIdSpec) []byte {
+	size := xgb.Pad((8 + xgb.Pad((int(NumSpecs) * 8))))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.Extensions["X-RESOURCE"]
+	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:], NumSpecs)
+	b += 4
+
+	b += ClientIdSpecListBytes(buf[b:], Specs)
+
+	return buf
+}
+
 // QueryClientPixmapBytesCookie is a cookie used only for QueryClientPixmapBytes requests.
 type QueryClientPixmapBytesCookie struct {
 	*xgb.Cookie
@@ -448,6 +881,106 @@ func queryClientsRequest(c *xgb.Conn) []byte {
 	return buf
 }
 
+// QueryResourceBytesCookie is a cookie used only for QueryResourceBytes requests.
+type QueryResourceBytesCookie struct {
+	*xgb.Cookie
+}
+
+// QueryResourceBytes sends a checked request.
+// If an error occurs, it will be returned with the reply by calling QueryResourceBytesCookie.Reply()
+func QueryResourceBytes(c *xgb.Conn, Client uint32, NumSpecs uint32, Specs []ResourceIdSpec) QueryResourceBytesCookie {
+	if _, ok := c.Extensions["X-RESOURCE"]; !ok {
+		panic("Cannot issue request 'QueryResourceBytes' using the uninitialized extension 'X-Resource'. res.Init(connObj) must be called first.")
+	}
+	cookie := c.NewCookie(true, true)
+	c.NewRequest(queryResourceBytesRequest(c, Client, NumSpecs, Specs), cookie)
+	return QueryResourceBytesCookie{cookie}
+}
+
+// QueryResourceBytesUnchecked sends an unchecked request.
+// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
+func QueryResourceBytesUnchecked(c *xgb.Conn, Client uint32, NumSpecs uint32, Specs []ResourceIdSpec) QueryResourceBytesCookie {
+	if _, ok := c.Extensions["X-RESOURCE"]; !ok {
+		panic("Cannot issue request 'QueryResourceBytes' using the uninitialized extension 'X-Resource'. res.Init(connObj) must be called first.")
+	}
+	cookie := c.NewCookie(false, true)
+	c.NewRequest(queryResourceBytesRequest(c, Client, NumSpecs, Specs), cookie)
+	return QueryResourceBytesCookie{cookie}
+}
+
+// QueryResourceBytesReply represents the data returned from a QueryResourceBytes request.
+type QueryResourceBytesReply struct {
+	Sequence uint16 // sequence number of the request for this reply
+	Length   uint32 // number of bytes in this reply
+	// padding: 1 bytes
+	NumSizes uint32
+	// padding: 20 bytes
+	Sizes []ResourceSizeValue // size: ResourceSizeValueListSize(Sizes)
+}
+
+// Reply blocks and returns the reply data for a QueryResourceBytes request.
+func (cook QueryResourceBytesCookie) Reply() (*QueryResourceBytesReply, error) {
+	buf, err := cook.Cookie.Reply()
+	if err != nil {
+		return nil, err
+	}
+	if buf == nil {
+		return nil, nil
+	}
+	return queryResourceBytesReply(buf), nil
+}
+
+// queryResourceBytesReply reads a byte slice into a QueryResourceBytesReply value.
+func queryResourceBytesReply(buf []byte) *QueryResourceBytesReply {
+	v := new(QueryResourceBytesReply)
+	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.NumSizes = xgb.Get32(buf[b:])
+	b += 4
+
+	b += 20 // padding
+
+	v.Sizes = make([]ResourceSizeValue, v.NumSizes)
+	b += ResourceSizeValueReadList(buf[b:], v.Sizes)
+
+	return v
+}
+
+// Write request to wire for QueryResourceBytes
+// queryResourceBytesRequest writes a QueryResourceBytes request to a byte slice.
+func queryResourceBytesRequest(c *xgb.Conn, Client uint32, NumSpecs uint32, Specs []ResourceIdSpec) []byte {
+	size := xgb.Pad((12 + xgb.Pad((int(NumSpecs) * 8))))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.Extensions["X-RESOURCE"]
+	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:], Client)
+	b += 4
+
+	xgb.Put32(buf[b:], NumSpecs)
+	b += 4
+
+	b += ResourceIdSpecListBytes(buf[b:], Specs)
+
+	return buf
+}
+
 // QueryVersionCookie is a cookie used only for QueryVersion requests.
 type QueryVersionCookie struct {
 	*xgb.Cookie

nexgb/screensaver/screensaver.go

@@ -53,15 +53,12 @@ const Notify = 0
 
 type NotifyEvent struct {
 	Sequence uint16
-	Code     byte
 	State    byte
-	// padding: 1 bytes
+	Time     xproto.Timestamp
-	SequenceNumber uint16
+	Root     xproto.Window
-	Time           xproto.Timestamp
+	Window   xproto.Window
-	Root           xproto.Window
+	Kind     byte
-	Window         xproto.Window
+	Forced   bool
-	Kind           byte
-	Forced         bool
 	// padding: 14 bytes
 }
 
@@ -70,18 +67,10 @@ func NotifyEventNew(buf []byte) xgb.Event {
 	v := NotifyEvent{}
 	b := 1 // don't read event number
 
-	v.Code = buf[b]
-	b += 1
-
-	v.Sequence = xgb.Get16(buf[b:])
-	b += 2
-
 	v.State = buf[b]
 	b += 1
 
-	b += 1 // padding
+	v.Sequence = xgb.Get16(buf[b:])
-
-	v.SequenceNumber = xgb.Get16(buf[b:])
 	b += 2
 
 	v.Time = xproto.Timestamp(xgb.Get32(buf[b:]))
@@ -117,18 +106,10 @@ func (v NotifyEvent) Bytes() []byte {
 	buf[b] = 0
 	b += 1
 
-	buf[b] = v.Code
-	b += 1
-
-	b += 2 // skip sequence number
-
 	buf[b] = v.State
 	b += 1
 
-	b += 1 // padding
+	b += 2 // skip sequence number
-
-	xgb.Put16(buf[b:], v.SequenceNumber)
-	b += 2
 
 	xgb.Put32(buf[b:], uint32(v.Time))
 	b += 4
@@ -163,11 +144,9 @@ func (v NotifyEvent) SequenceId() uint16 {
 
 // String is a rudimentary string representation of NotifyEvent.
 func (v NotifyEvent) String() string {
-	fieldVals := make([]string, 0, 10)
+	fieldVals := make([]string, 0, 7)
 	fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", v.Sequence))
-	fieldVals = append(fieldVals, xgb.Sprintf("Code: %d", v.Code))
 	fieldVals = append(fieldVals, xgb.Sprintf("State: %d", v.State))
-	fieldVals = append(fieldVals, xgb.Sprintf("SequenceNumber: %d", v.SequenceNumber))
 	fieldVals = append(fieldVals, xgb.Sprintf("Time: %d", v.Time))
 	fieldVals = append(fieldVals, xgb.Sprintf("Root: %d", v.Root))
 	fieldVals = append(fieldVals, xgb.Sprintf("Window: %d", v.Window))

nexgb/shm/shm.go

@@ -276,6 +276,70 @@ func attachRequest(c *xgb.Conn, Shmseg Seg, Shmid uint32, ReadOnly bool) []byte
 	return buf
 }
 
+// AttachFdCookie is a cookie used only for AttachFd requests.
+type AttachFdCookie struct {
+	*xgb.Cookie
+}
+
+// AttachFd sends an unchecked request.
+// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
+func AttachFd(c *xgb.Conn, Shmseg Seg, ReadOnly bool) AttachFdCookie {
+	if _, ok := c.Extensions["MIT-SHM"]; !ok {
+		panic("Cannot issue request 'AttachFd' using the uninitialized extension 'MIT-SHM'. shm.Init(connObj) must be called first.")
+	}
+	cookie := c.NewCookie(false, false)
+	c.NewRequest(attachFdRequest(c, Shmseg, ReadOnly), cookie)
+	return AttachFdCookie{cookie}
+}
+
+// AttachFdChecked sends a checked request.
+// If an error occurs, it can be retrieved using AttachFdCookie.Check()
+func AttachFdChecked(c *xgb.Conn, Shmseg Seg, ReadOnly bool) AttachFdCookie {
+	if _, ok := c.Extensions["MIT-SHM"]; !ok {
+		panic("Cannot issue request 'AttachFd' using the uninitialized extension 'MIT-SHM'. shm.Init(connObj) must be called first.")
+	}
+	cookie := c.NewCookie(true, false)
+	c.NewRequest(attachFdRequest(c, Shmseg, ReadOnly), cookie)
+	return AttachFdCookie{cookie}
+}
+
+// Check returns an error if one occurred for checked requests that are not expecting a reply.
+// This cannot be called for requests expecting a reply, nor for unchecked requests.
+func (cook AttachFdCookie) Check() error {
+	return cook.Cookie.Check()
+}
+
+// Write request to wire for AttachFd
+// attachFdRequest writes a AttachFd request to a byte slice.
+func attachFdRequest(c *xgb.Conn, Shmseg Seg, ReadOnly bool) []byte {
+	size := 12
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.Extensions["MIT-SHM"]
+	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(Shmseg))
+	b += 4
+
+	if ReadOnly {
+		buf[b] = 1
+	} else {
+		buf[b] = 0
+	}
+	b += 1
+
+	b += 3 // padding
+
+	return buf
+}
+
 // CreatePixmapCookie is a cookie used only for CreatePixmap requests.
 type CreatePixmapCookie struct {
 	*xgb.Cookie
@@ -351,6 +415,106 @@ func createPixmapRequest(c *xgb.Conn, Pid xproto.Pixmap, Drawable xproto.Drawabl
 	return buf
 }
 
+// CreateSegmentCookie is a cookie used only for CreateSegment requests.
+type CreateSegmentCookie struct {
+	*xgb.Cookie
+}
+
+// CreateSegment sends a checked request.
+// If an error occurs, it will be returned with the reply by calling CreateSegmentCookie.Reply()
+func CreateSegment(c *xgb.Conn, Shmseg Seg, Size uint32, ReadOnly bool) CreateSegmentCookie {
+	if _, ok := c.Extensions["MIT-SHM"]; !ok {
+		panic("Cannot issue request 'CreateSegment' using the uninitialized extension 'MIT-SHM'. shm.Init(connObj) must be called first.")
+	}
+	cookie := c.NewCookie(true, true)
+	c.NewRequest(createSegmentRequest(c, Shmseg, Size, ReadOnly), cookie)
+	return CreateSegmentCookie{cookie}
+}
+
+// CreateSegmentUnchecked sends an unchecked request.
+// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
+func CreateSegmentUnchecked(c *xgb.Conn, Shmseg Seg, Size uint32, ReadOnly bool) CreateSegmentCookie {
+	if _, ok := c.Extensions["MIT-SHM"]; !ok {
+		panic("Cannot issue request 'CreateSegment' using the uninitialized extension 'MIT-SHM'. shm.Init(connObj) must be called first.")
+	}
+	cookie := c.NewCookie(false, true)
+	c.NewRequest(createSegmentRequest(c, Shmseg, Size, ReadOnly), cookie)
+	return CreateSegmentCookie{cookie}
+}
+
+// CreateSegmentReply represents the data returned from a CreateSegment request.
+type CreateSegmentReply struct {
+	Sequence uint16 // sequence number of the request for this reply
+	Length   uint32 // number of bytes in this reply
+	Nfd      byte
+	// padding: 24 bytes
+}
+
+// Reply blocks and returns the reply data for a CreateSegment request.
+func (cook CreateSegmentCookie) Reply() (*CreateSegmentReply, error) {
+	buf, err := cook.Cookie.Reply()
+	if err != nil {
+		return nil, err
+	}
+	if buf == nil {
+		return nil, nil
+	}
+	return createSegmentReply(buf), nil
+}
+
+// createSegmentReply reads a byte slice into a CreateSegmentReply value.
+func createSegmentReply(buf []byte) *CreateSegmentReply {
+	v := new(CreateSegmentReply)
+	b := 1 // skip reply determinant
+
+	v.Nfd = buf[b]
+	b += 1
+
+	v.Sequence = xgb.Get16(buf[b:])
+	b += 2
+
+	v.Length = xgb.Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	b += 24 // padding
+
+	return v
+}
+
+// Write request to wire for CreateSegment
+// createSegmentRequest writes a CreateSegment request to a byte slice.
+func createSegmentRequest(c *xgb.Conn, Shmseg Seg, Size uint32, ReadOnly bool) []byte {
+	size := 16
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.Extensions["MIT-SHM"]
+	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(Shmseg))
+	b += 4
+
+	xgb.Put32(buf[b:], Size)
+	b += 4
+
+	if ReadOnly {
+		buf[b] = 1
+	} else {
+		buf[b] = 0
+	}
+	b += 1
+
+	b += 3 // padding
+
+	return buf
+}
+
 // DetachCookie is a cookie used only for Detach requests.
 type DetachCookie struct {
 	*xgb.Cookie

nexgb/xfixes/xfixes.go

@@ -85,6 +85,27 @@ func init() {
 	xgb.NewExtErrorFuncs["XFIXES"][0] = BadRegionErrorNew
 }
 
+type Barrier uint32
+
+func NewBarrierId(c *xgb.Conn) (Barrier, error) {
+	id, err := c.NewId()
+	if err != nil {
+		return 0, err
+	}
+	return Barrier(id), nil
+}
+
+const (
+	BarrierDirectionsPositiveX = 1
+	BarrierDirectionsPositiveY = 2
+	BarrierDirectionsNegativeX = 4
+	BarrierDirectionsNegativeY = 8
+)
+
+const (
+	CursorNotifyDisplayCursor = 0
+)
+
 // CursorNotify is the event number for a CursorNotifyEvent.
 const CursorNotify = 1
 
@@ -180,10 +201,6 @@ func init() {
 	xgb.NewExtEventFuncs["XFIXES"][1] = CursorNotifyEventNew
 }
 
-const (
-	CursorNotifyDisplayCursor = 0
-)
-
 const (
 	CursorNotifyMaskDisplayCursor = 1
 )
@@ -601,6 +618,90 @@ func copyRegionRequest(c *xgb.Conn, Source Region, Destination Region) []byte {
 	return buf
 }
 
+// CreatePointerBarrierCookie is a cookie used only for CreatePointerBarrier requests.
+type CreatePointerBarrierCookie struct {
+	*xgb.Cookie
+}
+
+// CreatePointerBarrier sends an unchecked request.
+// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
+func CreatePointerBarrier(c *xgb.Conn, Barrier Barrier, Window xproto.Window, X1 uint16, Y1 uint16, X2 uint16, Y2 uint16, Directions uint32, NumDevices uint16, Devices []uint16) CreatePointerBarrierCookie {
+	if _, ok := c.Extensions["XFIXES"]; !ok {
+		panic("Cannot issue request 'CreatePointerBarrier' using the uninitialized extension 'XFIXES'. xfixes.Init(connObj) must be called first.")
+	}
+	cookie := c.NewCookie(false, false)
+	c.NewRequest(createPointerBarrierRequest(c, Barrier, Window, X1, Y1, X2, Y2, Directions, NumDevices, Devices), cookie)
+	return CreatePointerBarrierCookie{cookie}
+}
+
+// CreatePointerBarrierChecked sends a checked request.
+// If an error occurs, it can be retrieved using CreatePointerBarrierCookie.Check()
+func CreatePointerBarrierChecked(c *xgb.Conn, Barrier Barrier, Window xproto.Window, X1 uint16, Y1 uint16, X2 uint16, Y2 uint16, Directions uint32, NumDevices uint16, Devices []uint16) CreatePointerBarrierCookie {
+	if _, ok := c.Extensions["XFIXES"]; !ok {
+		panic("Cannot issue request 'CreatePointerBarrier' using the uninitialized extension 'XFIXES'. xfixes.Init(connObj) must be called first.")
+	}
+	cookie := c.NewCookie(true, false)
+	c.NewRequest(createPointerBarrierRequest(c, Barrier, Window, X1, Y1, X2, Y2, Directions, NumDevices, Devices), cookie)
+	return CreatePointerBarrierCookie{cookie}
+}
+
+// Check returns an error if one occurred for checked requests that are not expecting a reply.
+// This cannot be called for requests expecting a reply, nor for unchecked requests.
+func (cook CreatePointerBarrierCookie) Check() error {
+	return cook.Cookie.Check()
+}
+
+// Write request to wire for CreatePointerBarrier
+// createPointerBarrierRequest writes a CreatePointerBarrier request to a byte slice.
+func createPointerBarrierRequest(c *xgb.Conn, Barrier Barrier, Window xproto.Window, X1 uint16, Y1 uint16, X2 uint16, Y2 uint16, Directions uint32, NumDevices uint16, Devices []uint16) []byte {
+	size := xgb.Pad((28 + xgb.Pad((int(NumDevices) * 2))))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.Extensions["XFIXES"]
+	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(Barrier))
+	b += 4
+
+	xgb.Put32(buf[b:], uint32(Window))
+	b += 4
+
+	xgb.Put16(buf[b:], X1)
+	b += 2
+
+	xgb.Put16(buf[b:], Y1)
+	b += 2
+
+	xgb.Put16(buf[b:], X2)
+	b += 2
+
+	xgb.Put16(buf[b:], Y2)
+	b += 2
+
+	xgb.Put32(buf[b:], Directions)
+	b += 4
+
+	b += 2 // padding
+
+	xgb.Put16(buf[b:], NumDevices)
+	b += 2
+
+	for i := 0; i < int(NumDevices); i++ {
+		xgb.Put16(buf[b:], Devices[i])
+		b += 2
+	}
+	b = xgb.Pad(b)
+
+	return buf
+}
+
 // CreateRegionCookie is a cookie used only for CreateRegion requests.
 type CreateRegionCookie struct {
 	*xgb.Cookie
@@ -895,6 +996,61 @@ func createRegionFromWindowRequest(c *xgb.Conn, Region Region, Window xproto.Win
 	return buf
 }
 
+// DeletePointerBarrierCookie is a cookie used only for DeletePointerBarrier requests.
+type DeletePointerBarrierCookie struct {
+	*xgb.Cookie
+}
+
+// DeletePointerBarrier sends an unchecked request.
+// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
+func DeletePointerBarrier(c *xgb.Conn, Barrier Barrier) DeletePointerBarrierCookie {
+	if _, ok := c.Extensions["XFIXES"]; !ok {
+		panic("Cannot issue request 'DeletePointerBarrier' using the uninitialized extension 'XFIXES'. xfixes.Init(connObj) must be called first.")
+	}
+	cookie := c.NewCookie(false, false)
+	c.NewRequest(deletePointerBarrierRequest(c, Barrier), cookie)
+	return DeletePointerBarrierCookie{cookie}
+}
+
+// DeletePointerBarrierChecked sends a checked request.
+// If an error occurs, it can be retrieved using DeletePointerBarrierCookie.Check()
+func DeletePointerBarrierChecked(c *xgb.Conn, Barrier Barrier) DeletePointerBarrierCookie {
+	if _, ok := c.Extensions["XFIXES"]; !ok {
+		panic("Cannot issue request 'DeletePointerBarrier' using the uninitialized extension 'XFIXES'. xfixes.Init(connObj) must be called first.")
+	}
+	cookie := c.NewCookie(true, false)
+	c.NewRequest(deletePointerBarrierRequest(c, Barrier), cookie)
+	return DeletePointerBarrierCookie{cookie}
+}
+
+// Check returns an error if one occurred for checked requests that are not expecting a reply.
+// This cannot be called for requests expecting a reply, nor for unchecked requests.
+func (cook DeletePointerBarrierCookie) Check() error {
+	return cook.Cookie.Check()
+}
+
+// Write request to wire for DeletePointerBarrier
+// deletePointerBarrierRequest writes a DeletePointerBarrier request to a byte slice.
+func deletePointerBarrierRequest(c *xgb.Conn, Barrier Barrier) []byte {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.Extensions["XFIXES"]
+	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
+
+	xgb.Put32(buf[b:], uint32(Barrier))
+	b += 4
+
+	return buf
+}
+
 // DestroyRegionCookie is a cookie used only for DestroyRegion requests.
 type DestroyRegionCookie struct {
 	*xgb.Cookie

nexgb/xproto/xproto.go

@@ -2484,10 +2484,6 @@ func NewFontId(c *xgb.Conn) (Font, error) {
 	return Font(id), nil
 }
 
-const (
-	FontNone = 0
-)
-
 // BadFont is the error number for a BadFont.
 const BadFont = 7
 
@@ -2526,6 +2522,10 @@ func init() {
 	xgb.NewErrorFuncs[7] = FontErrorNew
 }
 
+const (
+	FontNone = 0
+)
+
 const (
 	FontDrawLeftToRight = 0
 	FontDrawRightToLeft = 1
@@ -2735,6 +2735,56 @@ func NewGcontextId(c *xgb.Conn) (Gcontext, error) {
 	return Gcontext(id), nil
 }
 
+// GeGeneric is the event number for a GeGenericEvent.
+const GeGeneric = 35
+
+type GeGenericEvent struct {
+	Sequence uint16
+	// padding: 22 bytes
+}
+
+// GeGenericEventNew constructs a GeGenericEvent value that implements xgb.Event from a byte slice.
+func GeGenericEventNew(buf []byte) xgb.Event {
+	v := GeGenericEvent{}
+	b := 1 // don't read event number
+
+	b += 22 // padding
+
+	return v
+}
+
+// Bytes writes a GeGenericEvent value to a byte slice.
+func (v GeGenericEvent) Bytes() []byte {
+	buf := make([]byte, 32)
+	b := 0
+
+	// write event number
+	buf[b] = 35
+	b += 1
+
+	b += 22 // padding
+
+	return buf
+}
+
+// SequenceId returns the sequence id attached to the GeGeneric event.
+// Events without a sequence number (KeymapNotify) return 0.
+// This is mostly used internally.
+func (v GeGenericEvent) SequenceId() uint16 {
+	return v.Sequence
+}
+
+// String is a rudimentary string representation of GeGenericEvent.
+func (v GeGenericEvent) String() string {
+	fieldVals := make([]string, 0, 1)
+	fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", v.Sequence))
+	return "GeGeneric {" + xgb.StringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+	xgb.NewEventFuncs[35] = GeGenericEventNew
+}
+
 const (
 	GetPropertyTypeAny = 0
 )