// Code generated by xtgen; DO NOT EDIT.
package xproto

import "encoding/binary"
import "math/bits"
import "bnema.dev/xturbo"

type CreateWindowValues struct {
	Mask               Cw
	BackgroundPixmap   Pixmap
	BackgroundPixel    uint32
	BorderPixmap       Pixmap
	BorderPixel        uint32
	BitGravity         Gravity
	WinGravity         Gravity
	BackingStore       BackingStore
	BackingPlanes      uint32
	BackingPixel       uint32
	OverrideRedirect   bool
	SaveUnder          bool
	EventMask          EventMask
	DoNotPropogateMask EventMask
	Colormap           Colormap
	Cursor             Cursor
}

func (v *CreateWindowValues) SetBackgroundPixmap(x Pixmap) *CreateWindowValues {
	v.Mask |= CwBackPixmap
	v.BackgroundPixmap = x
	return v
}
func (v *CreateWindowValues) SetBackgroundPixel(x uint32) *CreateWindowValues {
	v.Mask |= CwBackPixel
	v.BackgroundPixel = x
	return v
}
func (v *CreateWindowValues) SetBorderPixmap(x Pixmap) *CreateWindowValues {
	v.Mask |= CwBorderPixmap
	v.BorderPixmap = x
	return v
}
func (v *CreateWindowValues) SetBorderPixel(x uint32) *CreateWindowValues {
	v.Mask |= CwBorderPixel
	v.BorderPixel = x
	return v
}
func (v *CreateWindowValues) SetBitGravity(x Gravity) *CreateWindowValues {
	v.Mask |= CwBitGravity
	v.BitGravity = x
	return v
}
func (v *CreateWindowValues) SetWinGravity(x Gravity) *CreateWindowValues {
	v.Mask |= CwWinGravity
	v.WinGravity = x
	return v
}
func (v *CreateWindowValues) SetBackingStore(x BackingStore) *CreateWindowValues {
	v.Mask |= CwBackingStore
	v.BackingStore = x
	return v
}
func (v *CreateWindowValues) SetBackingPlanes(x uint32) *CreateWindowValues {
	v.Mask |= CwBackingPlanes
	v.BackingPlanes = x
	return v
}
func (v *CreateWindowValues) SetBackingPixel(x uint32) *CreateWindowValues {
	v.Mask |= CwBackingPixel
	v.BackingPixel = x
	return v
}
func (v *CreateWindowValues) SetOverrideRedirect(x bool) *CreateWindowValues {
	v.Mask |= CwOverrideRedirect
	v.OverrideRedirect = x
	return v
}
func (v *CreateWindowValues) SetSaveUnder(x bool) *CreateWindowValues {
	v.Mask |= CwSaveUnder
	v.SaveUnder = x
	return v
}
func (v *CreateWindowValues) SetEventMask(x EventMask) *CreateWindowValues {
	v.Mask |= CwEventMask
	v.EventMask = x
	return v
}
func (v *CreateWindowValues) SetDoNotPropogateMask(x EventMask) *CreateWindowValues {
	v.Mask |= CwDontPropagate
	v.DoNotPropogateMask = x
	return v
}
func (v *CreateWindowValues) SetColormap(x Colormap) *CreateWindowValues {
	v.Mask |= CwColormap
	v.Colormap = x
	return v
}
func (v *CreateWindowValues) SetCursor(x Cursor) *CreateWindowValues {
	v.Mask |= CwCursor
	v.Cursor = x
	return v
}
func CreateWindow(b *xturbo.Buf, depth uint8, wid Window, parent Window, x int16, y int16, width uint16, height uint16, borderWidth uint16, class WindowClass, visual Visualid, v *CreateWindowValues) xturbo.Seq {
	p, seq := b.Request(1, uint8(int(depth)), 28+4*bits.OnesCount32(uint32(v.Mask)))
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(wid))
	binary.LittleEndian.PutUint32(p[4:], uint32(parent))
	binary.LittleEndian.PutUint16(p[8:], uint16(x))
	binary.LittleEndian.PutUint16(p[10:], uint16(y))
	binary.LittleEndian.PutUint16(p[12:], uint16(width))
	binary.LittleEndian.PutUint16(p[14:], uint16(height))
	binary.LittleEndian.PutUint16(p[16:], uint16(borderWidth))
	binary.LittleEndian.PutUint16(p[18:], uint16(class))
	binary.LittleEndian.PutUint32(p[20:], uint32(visual))
	binary.LittleEndian.PutUint32(p[24:], uint32(v.Mask))
	off := 28
	if v.Mask&CwBackPixmap != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.BackgroundPixmap))
		off += 4
	}
	if v.Mask&CwBackPixel != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.BackgroundPixel))
		off += 4
	}
	if v.Mask&CwBorderPixmap != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.BorderPixmap))
		off += 4
	}
	if v.Mask&CwBorderPixel != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.BorderPixel))
		off += 4
	}
	if v.Mask&CwBitGravity != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.BitGravity))
		off += 4
	}
	if v.Mask&CwWinGravity != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.WinGravity))
		off += 4
	}
	if v.Mask&CwBackingStore != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.BackingStore))
		off += 4
	}
	if v.Mask&CwBackingPlanes != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.BackingPlanes))
		off += 4
	}
	if v.Mask&CwBackingPixel != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.BackingPixel))
		off += 4
	}
	if v.Mask&CwOverrideRedirect != 0 {
		if v.OverrideRedirect {
			binary.LittleEndian.PutUint32(p[off:], 1)
		} else {
			binary.LittleEndian.PutUint32(p[off:], 0)
		}
		off += 4
	}
	if v.Mask&CwSaveUnder != 0 {
		if v.SaveUnder {
			binary.LittleEndian.PutUint32(p[off:], 1)
		} else {
			binary.LittleEndian.PutUint32(p[off:], 0)
		}
		off += 4
	}
	if v.Mask&CwEventMask != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.EventMask))
		off += 4
	}
	if v.Mask&CwDontPropagate != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.DoNotPropogateMask))
		off += 4
	}
	if v.Mask&CwColormap != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Colormap))
		off += 4
	}
	if v.Mask&CwCursor != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Cursor))
		off += 4
	}
	_ = off
	return seq
}

type ChangeWindowAttributesValues struct {
	Mask               Cw
	BackgroundPixmap   Pixmap
	BackgroundPixel    uint32
	BorderPixmap       Pixmap
	BorderPixel        uint32
	BitGravity         Gravity
	WinGravity         Gravity
	BackingStore       BackingStore
	BackingPlanes      uint32
	BackingPixel       uint32
	OverrideRedirect   bool
	SaveUnder          bool
	EventMask          EventMask
	DoNotPropogateMask EventMask
	Colormap           Colormap
	Cursor             Cursor
}

func (v *ChangeWindowAttributesValues) SetBackgroundPixmap(x Pixmap) *ChangeWindowAttributesValues {
	v.Mask |= CwBackPixmap
	v.BackgroundPixmap = x
	return v
}
func (v *ChangeWindowAttributesValues) SetBackgroundPixel(x uint32) *ChangeWindowAttributesValues {
	v.Mask |= CwBackPixel
	v.BackgroundPixel = x
	return v
}
func (v *ChangeWindowAttributesValues) SetBorderPixmap(x Pixmap) *ChangeWindowAttributesValues {
	v.Mask |= CwBorderPixmap
	v.BorderPixmap = x
	return v
}
func (v *ChangeWindowAttributesValues) SetBorderPixel(x uint32) *ChangeWindowAttributesValues {
	v.Mask |= CwBorderPixel
	v.BorderPixel = x
	return v
}
func (v *ChangeWindowAttributesValues) SetBitGravity(x Gravity) *ChangeWindowAttributesValues {
	v.Mask |= CwBitGravity
	v.BitGravity = x
	return v
}
func (v *ChangeWindowAttributesValues) SetWinGravity(x Gravity) *ChangeWindowAttributesValues {
	v.Mask |= CwWinGravity
	v.WinGravity = x
	return v
}
func (v *ChangeWindowAttributesValues) SetBackingStore(x BackingStore) *ChangeWindowAttributesValues {
	v.Mask |= CwBackingStore
	v.BackingStore = x
	return v
}
func (v *ChangeWindowAttributesValues) SetBackingPlanes(x uint32) *ChangeWindowAttributesValues {
	v.Mask |= CwBackingPlanes
	v.BackingPlanes = x
	return v
}
func (v *ChangeWindowAttributesValues) SetBackingPixel(x uint32) *ChangeWindowAttributesValues {
	v.Mask |= CwBackingPixel
	v.BackingPixel = x
	return v
}
func (v *ChangeWindowAttributesValues) SetOverrideRedirect(x bool) *ChangeWindowAttributesValues {
	v.Mask |= CwOverrideRedirect
	v.OverrideRedirect = x
	return v
}
func (v *ChangeWindowAttributesValues) SetSaveUnder(x bool) *ChangeWindowAttributesValues {
	v.Mask |= CwSaveUnder
	v.SaveUnder = x
	return v
}
func (v *ChangeWindowAttributesValues) SetEventMask(x EventMask) *ChangeWindowAttributesValues {
	v.Mask |= CwEventMask
	v.EventMask = x
	return v
}
func (v *ChangeWindowAttributesValues) SetDoNotPropogateMask(x EventMask) *ChangeWindowAttributesValues {
	v.Mask |= CwDontPropagate
	v.DoNotPropogateMask = x
	return v
}
func (v *ChangeWindowAttributesValues) SetColormap(x Colormap) *ChangeWindowAttributesValues {
	v.Mask |= CwColormap
	v.Colormap = x
	return v
}
func (v *ChangeWindowAttributesValues) SetCursor(x Cursor) *ChangeWindowAttributesValues {
	v.Mask |= CwCursor
	v.Cursor = x
	return v
}
func ChangeWindowAttributes(b *xturbo.Buf, window Window, v *ChangeWindowAttributesValues) xturbo.Seq {
	p, seq := b.Request(2, 0, 8+4*bits.OnesCount32(uint32(v.Mask)))
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(window))
	binary.LittleEndian.PutUint32(p[4:], uint32(v.Mask))
	off := 8
	if v.Mask&CwBackPixmap != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.BackgroundPixmap))
		off += 4
	}
	if v.Mask&CwBackPixel != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.BackgroundPixel))
		off += 4
	}
	if v.Mask&CwBorderPixmap != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.BorderPixmap))
		off += 4
	}
	if v.Mask&CwBorderPixel != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.BorderPixel))
		off += 4
	}
	if v.Mask&CwBitGravity != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.BitGravity))
		off += 4
	}
	if v.Mask&CwWinGravity != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.WinGravity))
		off += 4
	}
	if v.Mask&CwBackingStore != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.BackingStore))
		off += 4
	}
	if v.Mask&CwBackingPlanes != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.BackingPlanes))
		off += 4
	}
	if v.Mask&CwBackingPixel != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.BackingPixel))
		off += 4
	}
	if v.Mask&CwOverrideRedirect != 0 {
		if v.OverrideRedirect {
			binary.LittleEndian.PutUint32(p[off:], 1)
		} else {
			binary.LittleEndian.PutUint32(p[off:], 0)
		}
		off += 4
	}
	if v.Mask&CwSaveUnder != 0 {
		if v.SaveUnder {
			binary.LittleEndian.PutUint32(p[off:], 1)
		} else {
			binary.LittleEndian.PutUint32(p[off:], 0)
		}
		off += 4
	}
	if v.Mask&CwEventMask != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.EventMask))
		off += 4
	}
	if v.Mask&CwDontPropagate != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.DoNotPropogateMask))
		off += 4
	}
	if v.Mask&CwColormap != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Colormap))
		off += 4
	}
	if v.Mask&CwCursor != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Cursor))
		off += 4
	}
	_ = off
	return seq
}

func GetWindowAttributes(b *xturbo.Buf, window Window) xturbo.Seq {
	p, seq := b.Request(3, 0, 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(window))
	return seq
}

func DestroyWindow(b *xturbo.Buf, window Window) xturbo.Seq {
	p, seq := b.Request(4, 0, 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(window))
	return seq
}

func DestroySubwindows(b *xturbo.Buf, window Window) xturbo.Seq {
	p, seq := b.Request(5, 0, 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(window))
	return seq
}

func ChangeSaveSet(b *xturbo.Buf, mode SetMode, window Window) xturbo.Seq {
	p, seq := b.Request(6, uint8(int(mode)), 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(window))
	return seq
}

func ReparentWindow(b *xturbo.Buf, window Window, parent Window, x int16, y int16) xturbo.Seq {
	p, seq := b.Request(7, 0, 12)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(window))
	binary.LittleEndian.PutUint32(p[4:], uint32(parent))
	binary.LittleEndian.PutUint16(p[8:], uint16(x))
	binary.LittleEndian.PutUint16(p[10:], uint16(y))
	return seq
}

func MapWindow(b *xturbo.Buf, window Window) xturbo.Seq {
	p, seq := b.Request(8, 0, 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(window))
	return seq
}

func MapSubwindows(b *xturbo.Buf, window Window) xturbo.Seq {
	p, seq := b.Request(9, 0, 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(window))
	return seq
}

func UnmapWindow(b *xturbo.Buf, window Window) xturbo.Seq {
	p, seq := b.Request(10, 0, 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(window))
	return seq
}

func UnmapSubwindows(b *xturbo.Buf, window Window) xturbo.Seq {
	p, seq := b.Request(11, 0, 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(window))
	return seq
}

type ConfigureWindowValues struct {
	Mask        ConfigWindow
	X           int32
	Y           int32
	Width       uint32
	Height      uint32
	BorderWidth uint32
	Sibling     Window
	StackMode   StackMode
}

func (v *ConfigureWindowValues) SetX(x int32) *ConfigureWindowValues {
	v.Mask |= ConfigWindowX
	v.X = x
	return v
}
func (v *ConfigureWindowValues) SetY(x int32) *ConfigureWindowValues {
	v.Mask |= ConfigWindowY
	v.Y = x
	return v
}
func (v *ConfigureWindowValues) SetWidth(x uint32) *ConfigureWindowValues {
	v.Mask |= ConfigWindowWidth
	v.Width = x
	return v
}
func (v *ConfigureWindowValues) SetHeight(x uint32) *ConfigureWindowValues {
	v.Mask |= ConfigWindowHeight
	v.Height = x
	return v
}
func (v *ConfigureWindowValues) SetBorderWidth(x uint32) *ConfigureWindowValues {
	v.Mask |= ConfigWindowBorderWidth
	v.BorderWidth = x
	return v
}
func (v *ConfigureWindowValues) SetSibling(x Window) *ConfigureWindowValues {
	v.Mask |= ConfigWindowSibling
	v.Sibling = x
	return v
}
func (v *ConfigureWindowValues) SetStackMode(x StackMode) *ConfigureWindowValues {
	v.Mask |= ConfigWindowStackMode
	v.StackMode = x
	return v
}
func ConfigureWindow(b *xturbo.Buf, window Window, v *ConfigureWindowValues) xturbo.Seq {
	p, seq := b.Request(12, 0, 8+4*bits.OnesCount32(uint32(v.Mask)))
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(window))
	binary.LittleEndian.PutUint16(p[4:], uint16(v.Mask))
	off := 8
	if v.Mask&ConfigWindowX != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.X))
		off += 4
	}
	if v.Mask&ConfigWindowY != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Y))
		off += 4
	}
	if v.Mask&ConfigWindowWidth != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Width))
		off += 4
	}
	if v.Mask&ConfigWindowHeight != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Height))
		off += 4
	}
	if v.Mask&ConfigWindowBorderWidth != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.BorderWidth))
		off += 4
	}
	if v.Mask&ConfigWindowSibling != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Sibling))
		off += 4
	}
	if v.Mask&ConfigWindowStackMode != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.StackMode))
		off += 4
	}
	_ = off
	return seq
}

func CirculateWindow(b *xturbo.Buf, direction Circulate, window Window) xturbo.Seq {
	p, seq := b.Request(13, uint8(int(direction)), 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(window))
	return seq
}

func GetGeometry(b *xturbo.Buf, drawable Drawable) xturbo.Seq {
	p, seq := b.Request(14, 0, 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(drawable))
	return seq
}

func QueryTree(b *xturbo.Buf, window Window) xturbo.Seq {
	p, seq := b.Request(15, 0, 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(window))
	return seq
}

func InternAtom(b *xturbo.Buf, onlyIfExists bool, name string) xturbo.Seq {
	if uint64(len(name)) > 65535 {
		b.Fail(xturbo.ErrBadLength)
		return 0
	}
	size := 0
	size += 2
	size += 2
	size += len(name) * 1
	size = (size + 3) &^ 3
	var data uint8
	if onlyIfExists {
		data = 1
	}
	p, seq := b.Request(16, data, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint16(p[off:], uint16(len(name)))
	off += 2
	off += 2
	copy(p[off:], name)
	off += len(name)
	return seq
}

func GetAtomName(b *xturbo.Buf, atom Atom) xturbo.Seq {
	p, seq := b.Request(17, 0, 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(atom))
	return seq
}

func ChangeProperty(b *xturbo.Buf, mode PropMode, window Window, property Atom, type_ Atom, format uint8, dataLen uint32, data []byte) xturbo.Seq {
	if len(data) != ((int(dataLen) * int(format)) / 8) {
		b.Fail(xturbo.ErrBadLength)
		return 0
	}
	size := 0
	size += 4
	size += 4
	size += 4
	size += 1
	size += 3
	size += 4
	size += len(data) * 1
	size = (size + 3) &^ 3
	p, seq := b.Request(18, uint8(int(mode)), size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(window))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(property))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(type_))
	off += 4
	p[off:][0] = byte(format)
	off += 1
	off += 3
	binary.LittleEndian.PutUint32(p[off:], uint32(dataLen))
	off += 4
	copy(p[off:], data)
	off += len(data)
	return seq
}

func DeleteProperty(b *xturbo.Buf, window Window, property Atom) xturbo.Seq {
	p, seq := b.Request(19, 0, 8)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(window))
	binary.LittleEndian.PutUint32(p[4:], uint32(property))
	return seq
}

func GetProperty(b *xturbo.Buf, delete bool, window Window, property Atom, type_ Atom, longOffset uint32, longLength uint32) xturbo.Seq {
	var data uint8
	if delete {
		data = 1
	}
	p, seq := b.Request(20, data, 20)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(window))
	binary.LittleEndian.PutUint32(p[4:], uint32(property))
	binary.LittleEndian.PutUint32(p[8:], uint32(type_))
	binary.LittleEndian.PutUint32(p[12:], uint32(longOffset))
	binary.LittleEndian.PutUint32(p[16:], uint32(longLength))
	return seq
}

func ListProperties(b *xturbo.Buf, window Window) xturbo.Seq {
	p, seq := b.Request(21, 0, 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(window))
	return seq
}

func SetSelectionOwner(b *xturbo.Buf, owner Window, selection Atom, time Timestamp) xturbo.Seq {
	p, seq := b.Request(22, 0, 12)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(owner))
	binary.LittleEndian.PutUint32(p[4:], uint32(selection))
	binary.LittleEndian.PutUint32(p[8:], uint32(time))
	return seq
}

func GetSelectionOwner(b *xturbo.Buf, selection Atom) xturbo.Seq {
	p, seq := b.Request(23, 0, 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(selection))
	return seq
}

func ConvertSelection(b *xturbo.Buf, requestor Window, selection Atom, target Atom, property Atom, time Timestamp) xturbo.Seq {
	p, seq := b.Request(24, 0, 20)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(requestor))
	binary.LittleEndian.PutUint32(p[4:], uint32(selection))
	binary.LittleEndian.PutUint32(p[8:], uint32(target))
	binary.LittleEndian.PutUint32(p[12:], uint32(property))
	binary.LittleEndian.PutUint32(p[16:], uint32(time))
	return seq
}

func SendEvent(b *xturbo.Buf, propagate bool, destination Window, eventMask EventMask, event *[32]byte) xturbo.Seq {
	if len(event) != 32 {
		b.Fail(xturbo.ErrBadLength)
		return 0
	}
	size := 0
	size += 4
	size += 4
	size += len(event) * 1
	size = (size + 3) &^ 3
	var data uint8
	if propagate {
		data = 1
	}
	p, seq := b.Request(25, data, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(destination))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(eventMask))
	off += 4
	copy(p[off:], event[:])
	return seq
}

func GrabPointer(b *xturbo.Buf, ownerEvents bool, grabWindow Window, eventMask EventMask, pointerMode GrabMode, keyboardMode GrabMode, confineTo Window, cursor Cursor, time Timestamp) xturbo.Seq {
	var data uint8
	if ownerEvents {
		data = 1
	}
	p, seq := b.Request(26, data, 20)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(grabWindow))
	binary.LittleEndian.PutUint16(p[4:], uint16(eventMask))
	p[6:][0] = byte(pointerMode)
	p[7:][0] = byte(keyboardMode)
	binary.LittleEndian.PutUint32(p[8:], uint32(confineTo))
	binary.LittleEndian.PutUint32(p[12:], uint32(cursor))
	binary.LittleEndian.PutUint32(p[16:], uint32(time))
	return seq
}

func UngrabPointer(b *xturbo.Buf, time Timestamp) xturbo.Seq {
	p, seq := b.Request(27, 0, 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(time))
	return seq
}

func GrabButton(b *xturbo.Buf, ownerEvents bool, grabWindow Window, eventMask EventMask, pointerMode GrabMode, keyboardMode GrabMode, confineTo Window, cursor Cursor, button ButtonIndex, modifiers ModMask) xturbo.Seq {
	var data uint8
	if ownerEvents {
		data = 1
	}
	p, seq := b.Request(28, data, 20)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(grabWindow))
	binary.LittleEndian.PutUint16(p[4:], uint16(eventMask))
	p[6:][0] = byte(pointerMode)
	p[7:][0] = byte(keyboardMode)
	binary.LittleEndian.PutUint32(p[8:], uint32(confineTo))
	binary.LittleEndian.PutUint32(p[12:], uint32(cursor))
	p[16:][0] = byte(button)
	binary.LittleEndian.PutUint16(p[18:], uint16(modifiers))
	return seq
}

func UngrabButton(b *xturbo.Buf, button ButtonIndex, grabWindow Window, modifiers ModMask) xturbo.Seq {
	p, seq := b.Request(29, uint8(int(button)), 8)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(grabWindow))
	binary.LittleEndian.PutUint16(p[4:], uint16(modifiers))
	return seq
}

func ChangeActivePointerGrab(b *xturbo.Buf, cursor Cursor, time Timestamp, eventMask EventMask) xturbo.Seq {
	p, seq := b.Request(30, 0, 12)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(cursor))
	binary.LittleEndian.PutUint32(p[4:], uint32(time))
	binary.LittleEndian.PutUint16(p[8:], uint16(eventMask))
	return seq
}

func GrabKeyboard(b *xturbo.Buf, ownerEvents bool, grabWindow Window, time Timestamp, pointerMode GrabMode, keyboardMode GrabMode) xturbo.Seq {
	var data uint8
	if ownerEvents {
		data = 1
	}
	p, seq := b.Request(31, data, 12)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(grabWindow))
	binary.LittleEndian.PutUint32(p[4:], uint32(time))
	p[8:][0] = byte(pointerMode)
	p[9:][0] = byte(keyboardMode)
	return seq
}

func UngrabKeyboard(b *xturbo.Buf, time Timestamp) xturbo.Seq {
	p, seq := b.Request(32, 0, 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(time))
	return seq
}

func GrabKey(b *xturbo.Buf, ownerEvents bool, grabWindow Window, modifiers ModMask, key Keycode, pointerMode GrabMode, keyboardMode GrabMode) xturbo.Seq {
	var data uint8
	if ownerEvents {
		data = 1
	}
	p, seq := b.Request(33, data, 12)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(grabWindow))
	binary.LittleEndian.PutUint16(p[4:], uint16(modifiers))
	p[6:][0] = byte(key)
	p[7:][0] = byte(pointerMode)
	p[8:][0] = byte(keyboardMode)
	return seq
}

func UngrabKey(b *xturbo.Buf, key Keycode, grabWindow Window, modifiers ModMask) xturbo.Seq {
	p, seq := b.Request(34, uint8(int(key)), 8)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(grabWindow))
	binary.LittleEndian.PutUint16(p[4:], uint16(modifiers))
	return seq
}

func AllowEvents(b *xturbo.Buf, mode Allow, time Timestamp) xturbo.Seq {
	p, seq := b.Request(35, uint8(int(mode)), 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(time))
	return seq
}

func GrabServer(b *xturbo.Buf) xturbo.Seq {
	p, seq := b.Request(36, 0, 0)
	if p == nil {
		return 0
	}
	return seq
}

func UngrabServer(b *xturbo.Buf) xturbo.Seq {
	p, seq := b.Request(37, 0, 0)
	if p == nil {
		return 0
	}
	return seq
}

func QueryPointer(b *xturbo.Buf, window Window) xturbo.Seq {
	p, seq := b.Request(38, 0, 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(window))
	return seq
}

func GetMotionEvents(b *xturbo.Buf, window Window, start Timestamp, stop Timestamp) xturbo.Seq {
	p, seq := b.Request(39, 0, 12)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(window))
	binary.LittleEndian.PutUint32(p[4:], uint32(start))
	binary.LittleEndian.PutUint32(p[8:], uint32(stop))
	return seq
}

func TranslateCoordinates(b *xturbo.Buf, srcWindow Window, dstWindow Window, srcX int16, srcY int16) xturbo.Seq {
	p, seq := b.Request(40, 0, 12)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(srcWindow))
	binary.LittleEndian.PutUint32(p[4:], uint32(dstWindow))
	binary.LittleEndian.PutUint16(p[8:], uint16(srcX))
	binary.LittleEndian.PutUint16(p[10:], uint16(srcY))
	return seq
}

func WarpPointer(b *xturbo.Buf, srcWindow Window, dstWindow Window, srcX int16, srcY int16, srcWidth uint16, srcHeight uint16, dstX int16, dstY int16) xturbo.Seq {
	p, seq := b.Request(41, 0, 20)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(srcWindow))
	binary.LittleEndian.PutUint32(p[4:], uint32(dstWindow))
	binary.LittleEndian.PutUint16(p[8:], uint16(srcX))
	binary.LittleEndian.PutUint16(p[10:], uint16(srcY))
	binary.LittleEndian.PutUint16(p[12:], uint16(srcWidth))
	binary.LittleEndian.PutUint16(p[14:], uint16(srcHeight))
	binary.LittleEndian.PutUint16(p[16:], uint16(dstX))
	binary.LittleEndian.PutUint16(p[18:], uint16(dstY))
	return seq
}

func SetInputFocus(b *xturbo.Buf, revertTo InputFocus, focus Window, time Timestamp) xturbo.Seq {
	p, seq := b.Request(42, uint8(int(revertTo)), 8)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(focus))
	binary.LittleEndian.PutUint32(p[4:], uint32(time))
	return seq
}

func GetInputFocus(b *xturbo.Buf) xturbo.Seq {
	p, seq := b.Request(43, 0, 0)
	if p == nil {
		return 0
	}
	return seq
}

func QueryKeymap(b *xturbo.Buf) xturbo.Seq {
	p, seq := b.Request(44, 0, 0)
	if p == nil {
		return 0
	}
	return seq
}

func OpenFont(b *xturbo.Buf, fid Font, name string) xturbo.Seq {
	if uint64(len(name)) > 65535 {
		b.Fail(xturbo.ErrBadLength)
		return 0
	}
	size := 0
	size += 4
	size += 2
	size += 2
	size += len(name) * 1
	size = (size + 3) &^ 3
	p, seq := b.Request(45, 0, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(fid))
	off += 4
	binary.LittleEndian.PutUint16(p[off:], uint16(len(name)))
	off += 2
	off += 2
	copy(p[off:], name)
	off += len(name)
	return seq
}

func CloseFont(b *xturbo.Buf, font Font) xturbo.Seq {
	p, seq := b.Request(46, 0, 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(font))
	return seq
}

func QueryFont(b *xturbo.Buf, font Fontable) xturbo.Seq {
	p, seq := b.Request(47, 0, 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(font))
	return seq
}

func QueryTextExtents(b *xturbo.Buf, font Fontable, string []Char2b) xturbo.Seq {
	size := 0
	size += 4
	size += len(string) * 2
	size = (size + 3) &^ 3
	var data uint8
	if (len(string) & 1) != 0 {
		data = 1
	}
	p, seq := b.Request(48, data, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(font))
	off += 4
	for i := range string {
		string[i].Put(p[off:])
		off += 2
	}
	return seq
}

func ListFonts(b *xturbo.Buf, maxNames uint16, pattern string) xturbo.Seq {
	if uint64(len(pattern)) > 65535 {
		b.Fail(xturbo.ErrBadLength)
		return 0
	}
	size := 0
	size += 2
	size += 2
	size += len(pattern) * 1
	size = (size + 3) &^ 3
	p, seq := b.Request(49, 0, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint16(p[off:], uint16(maxNames))
	off += 2
	binary.LittleEndian.PutUint16(p[off:], uint16(len(pattern)))
	off += 2
	copy(p[off:], pattern)
	off += len(pattern)
	return seq
}

func ListFontsWithInfo(b *xturbo.Buf, maxNames uint16, pattern string) xturbo.Seq {
	if uint64(len(pattern)) > 65535 {
		b.Fail(xturbo.ErrBadLength)
		return 0
	}
	size := 0
	size += 2
	size += 2
	size += len(pattern) * 1
	size = (size + 3) &^ 3
	p, seq := b.Request(50, 0, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint16(p[off:], uint16(maxNames))
	off += 2
	binary.LittleEndian.PutUint16(p[off:], uint16(len(pattern)))
	off += 2
	copy(p[off:], pattern)
	off += len(pattern)
	return seq
}

func SetFontPath(b *xturbo.Buf, font []Str) xturbo.Seq {
	if uint64(len(font)) > 65535 {
		b.Fail(xturbo.ErrBadLength)
		return 0
	}
	size := 0
	size += 2
	size += 2
	for i := range font {
		size += font[i].Size()
	}
	size = (size + 3) &^ 3
	p, seq := b.Request(51, 0, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint16(p[off:], uint16(len(font)))
	off += 2
	off += 2
	for i := range font {
		font[i].Put(p[off:])
		off += font[i].Size()
	}
	return seq
}

func GetFontPath(b *xturbo.Buf) xturbo.Seq {
	p, seq := b.Request(52, 0, 0)
	if p == nil {
		return 0
	}
	return seq
}

func CreatePixmap(b *xturbo.Buf, depth uint8, pid Pixmap, drawable Drawable, width uint16, height uint16) xturbo.Seq {
	p, seq := b.Request(53, uint8(int(depth)), 12)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(pid))
	binary.LittleEndian.PutUint32(p[4:], uint32(drawable))
	binary.LittleEndian.PutUint16(p[8:], uint16(width))
	binary.LittleEndian.PutUint16(p[10:], uint16(height))
	return seq
}

func FreePixmap(b *xturbo.Buf, pixmap Pixmap) xturbo.Seq {
	p, seq := b.Request(54, 0, 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(pixmap))
	return seq
}

type CreateGCValues struct {
	Mask               Gc
	Function           Gx
	PlaneMask          uint32
	Foreground         uint32
	Background         uint32
	LineWidth          uint32
	LineStyle          LineStyle
	CapStyle           CapStyle
	JoinStyle          JoinStyle
	FillStyle          FillStyle
	FillRule           FillRule
	Tile               Pixmap
	Stipple            Pixmap
	TileStippleXOrigin int32
	TileStippleYOrigin int32
	Font               Font
	SubwindowMode      SubwindowMode
	GraphicsExposures  bool
	ClipXOrigin        int32
	ClipYOrigin        int32
	ClipMask           Pixmap
	DashOffset         uint32
	Dashes             uint32
	ArcMode            ArcMode
}

func (v *CreateGCValues) SetFunction(x Gx) *CreateGCValues {
	v.Mask |= GcFunction
	v.Function = x
	return v
}
func (v *CreateGCValues) SetPlaneMask(x uint32) *CreateGCValues {
	v.Mask |= GcPlaneMask
	v.PlaneMask = x
	return v
}
func (v *CreateGCValues) SetForeground(x uint32) *CreateGCValues {
	v.Mask |= GcForeground
	v.Foreground = x
	return v
}
func (v *CreateGCValues) SetBackground(x uint32) *CreateGCValues {
	v.Mask |= GcBackground
	v.Background = x
	return v
}
func (v *CreateGCValues) SetLineWidth(x uint32) *CreateGCValues {
	v.Mask |= GcLineWidth
	v.LineWidth = x
	return v
}
func (v *CreateGCValues) SetLineStyle(x LineStyle) *CreateGCValues {
	v.Mask |= GcLineStyle
	v.LineStyle = x
	return v
}
func (v *CreateGCValues) SetCapStyle(x CapStyle) *CreateGCValues {
	v.Mask |= GcCapStyle
	v.CapStyle = x
	return v
}
func (v *CreateGCValues) SetJoinStyle(x JoinStyle) *CreateGCValues {
	v.Mask |= GcJoinStyle
	v.JoinStyle = x
	return v
}
func (v *CreateGCValues) SetFillStyle(x FillStyle) *CreateGCValues {
	v.Mask |= GcFillStyle
	v.FillStyle = x
	return v
}
func (v *CreateGCValues) SetFillRule(x FillRule) *CreateGCValues {
	v.Mask |= GcFillRule
	v.FillRule = x
	return v
}
func (v *CreateGCValues) SetTile(x Pixmap) *CreateGCValues { v.Mask |= GcTile; v.Tile = x; return v }
func (v *CreateGCValues) SetStipple(x Pixmap) *CreateGCValues {
	v.Mask |= GcStipple
	v.Stipple = x
	return v
}
func (v *CreateGCValues) SetTileStippleXOrigin(x int32) *CreateGCValues {
	v.Mask |= GcTileStippleOriginX
	v.TileStippleXOrigin = x
	return v
}
func (v *CreateGCValues) SetTileStippleYOrigin(x int32) *CreateGCValues {
	v.Mask |= GcTileStippleOriginY
	v.TileStippleYOrigin = x
	return v
}
func (v *CreateGCValues) SetFont(x Font) *CreateGCValues { v.Mask |= GcFont; v.Font = x; return v }
func (v *CreateGCValues) SetSubwindowMode(x SubwindowMode) *CreateGCValues {
	v.Mask |= GcSubwindowMode
	v.SubwindowMode = x
	return v
}
func (v *CreateGCValues) SetGraphicsExposures(x bool) *CreateGCValues {
	v.Mask |= GcGraphicsExposures
	v.GraphicsExposures = x
	return v
}
func (v *CreateGCValues) SetClipXOrigin(x int32) *CreateGCValues {
	v.Mask |= GcClipOriginX
	v.ClipXOrigin = x
	return v
}
func (v *CreateGCValues) SetClipYOrigin(x int32) *CreateGCValues {
	v.Mask |= GcClipOriginY
	v.ClipYOrigin = x
	return v
}
func (v *CreateGCValues) SetClipMask(x Pixmap) *CreateGCValues {
	v.Mask |= GcClipMask
	v.ClipMask = x
	return v
}
func (v *CreateGCValues) SetDashOffset(x uint32) *CreateGCValues {
	v.Mask |= GcDashOffset
	v.DashOffset = x
	return v
}
func (v *CreateGCValues) SetDashes(x uint32) *CreateGCValues {
	v.Mask |= GcDashList
	v.Dashes = x
	return v
}
func (v *CreateGCValues) SetArcMode(x ArcMode) *CreateGCValues {
	v.Mask |= GcArcMode
	v.ArcMode = x
	return v
}
func CreateGC(b *xturbo.Buf, cid Gcontext, drawable Drawable, v *CreateGCValues) xturbo.Seq {
	p, seq := b.Request(55, 0, 12+4*bits.OnesCount32(uint32(v.Mask)))
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(cid))
	binary.LittleEndian.PutUint32(p[4:], uint32(drawable))
	binary.LittleEndian.PutUint32(p[8:], uint32(v.Mask))
	off := 12
	if v.Mask&GcFunction != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Function))
		off += 4
	}
	if v.Mask&GcPlaneMask != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.PlaneMask))
		off += 4
	}
	if v.Mask&GcForeground != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Foreground))
		off += 4
	}
	if v.Mask&GcBackground != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Background))
		off += 4
	}
	if v.Mask&GcLineWidth != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.LineWidth))
		off += 4
	}
	if v.Mask&GcLineStyle != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.LineStyle))
		off += 4
	}
	if v.Mask&GcCapStyle != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.CapStyle))
		off += 4
	}
	if v.Mask&GcJoinStyle != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.JoinStyle))
		off += 4
	}
	if v.Mask&GcFillStyle != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.FillStyle))
		off += 4
	}
	if v.Mask&GcFillRule != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.FillRule))
		off += 4
	}
	if v.Mask&GcTile != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Tile))
		off += 4
	}
	if v.Mask&GcStipple != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Stipple))
		off += 4
	}
	if v.Mask&GcTileStippleOriginX != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.TileStippleXOrigin))
		off += 4
	}
	if v.Mask&GcTileStippleOriginY != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.TileStippleYOrigin))
		off += 4
	}
	if v.Mask&GcFont != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Font))
		off += 4
	}
	if v.Mask&GcSubwindowMode != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.SubwindowMode))
		off += 4
	}
	if v.Mask&GcGraphicsExposures != 0 {
		if v.GraphicsExposures {
			binary.LittleEndian.PutUint32(p[off:], 1)
		} else {
			binary.LittleEndian.PutUint32(p[off:], 0)
		}
		off += 4
	}
	if v.Mask&GcClipOriginX != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.ClipXOrigin))
		off += 4
	}
	if v.Mask&GcClipOriginY != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.ClipYOrigin))
		off += 4
	}
	if v.Mask&GcClipMask != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.ClipMask))
		off += 4
	}
	if v.Mask&GcDashOffset != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.DashOffset))
		off += 4
	}
	if v.Mask&GcDashList != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Dashes))
		off += 4
	}
	if v.Mask&GcArcMode != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.ArcMode))
		off += 4
	}
	_ = off
	return seq
}

type ChangeGCValues struct {
	Mask               Gc
	Function           Gx
	PlaneMask          uint32
	Foreground         uint32
	Background         uint32
	LineWidth          uint32
	LineStyle          LineStyle
	CapStyle           CapStyle
	JoinStyle          JoinStyle
	FillStyle          FillStyle
	FillRule           FillRule
	Tile               Pixmap
	Stipple            Pixmap
	TileStippleXOrigin int32
	TileStippleYOrigin int32
	Font               Font
	SubwindowMode      SubwindowMode
	GraphicsExposures  bool
	ClipXOrigin        int32
	ClipYOrigin        int32
	ClipMask           Pixmap
	DashOffset         uint32
	Dashes             uint32
	ArcMode            ArcMode
}

func (v *ChangeGCValues) SetFunction(x Gx) *ChangeGCValues {
	v.Mask |= GcFunction
	v.Function = x
	return v
}
func (v *ChangeGCValues) SetPlaneMask(x uint32) *ChangeGCValues {
	v.Mask |= GcPlaneMask
	v.PlaneMask = x
	return v
}
func (v *ChangeGCValues) SetForeground(x uint32) *ChangeGCValues {
	v.Mask |= GcForeground
	v.Foreground = x
	return v
}
func (v *ChangeGCValues) SetBackground(x uint32) *ChangeGCValues {
	v.Mask |= GcBackground
	v.Background = x
	return v
}
func (v *ChangeGCValues) SetLineWidth(x uint32) *ChangeGCValues {
	v.Mask |= GcLineWidth
	v.LineWidth = x
	return v
}
func (v *ChangeGCValues) SetLineStyle(x LineStyle) *ChangeGCValues {
	v.Mask |= GcLineStyle
	v.LineStyle = x
	return v
}
func (v *ChangeGCValues) SetCapStyle(x CapStyle) *ChangeGCValues {
	v.Mask |= GcCapStyle
	v.CapStyle = x
	return v
}
func (v *ChangeGCValues) SetJoinStyle(x JoinStyle) *ChangeGCValues {
	v.Mask |= GcJoinStyle
	v.JoinStyle = x
	return v
}
func (v *ChangeGCValues) SetFillStyle(x FillStyle) *ChangeGCValues {
	v.Mask |= GcFillStyle
	v.FillStyle = x
	return v
}
func (v *ChangeGCValues) SetFillRule(x FillRule) *ChangeGCValues {
	v.Mask |= GcFillRule
	v.FillRule = x
	return v
}
func (v *ChangeGCValues) SetTile(x Pixmap) *ChangeGCValues { v.Mask |= GcTile; v.Tile = x; return v }
func (v *ChangeGCValues) SetStipple(x Pixmap) *ChangeGCValues {
	v.Mask |= GcStipple
	v.Stipple = x
	return v
}
func (v *ChangeGCValues) SetTileStippleXOrigin(x int32) *ChangeGCValues {
	v.Mask |= GcTileStippleOriginX
	v.TileStippleXOrigin = x
	return v
}
func (v *ChangeGCValues) SetTileStippleYOrigin(x int32) *ChangeGCValues {
	v.Mask |= GcTileStippleOriginY
	v.TileStippleYOrigin = x
	return v
}
func (v *ChangeGCValues) SetFont(x Font) *ChangeGCValues { v.Mask |= GcFont; v.Font = x; return v }
func (v *ChangeGCValues) SetSubwindowMode(x SubwindowMode) *ChangeGCValues {
	v.Mask |= GcSubwindowMode
	v.SubwindowMode = x
	return v
}
func (v *ChangeGCValues) SetGraphicsExposures(x bool) *ChangeGCValues {
	v.Mask |= GcGraphicsExposures
	v.GraphicsExposures = x
	return v
}
func (v *ChangeGCValues) SetClipXOrigin(x int32) *ChangeGCValues {
	v.Mask |= GcClipOriginX
	v.ClipXOrigin = x
	return v
}
func (v *ChangeGCValues) SetClipYOrigin(x int32) *ChangeGCValues {
	v.Mask |= GcClipOriginY
	v.ClipYOrigin = x
	return v
}
func (v *ChangeGCValues) SetClipMask(x Pixmap) *ChangeGCValues {
	v.Mask |= GcClipMask
	v.ClipMask = x
	return v
}
func (v *ChangeGCValues) SetDashOffset(x uint32) *ChangeGCValues {
	v.Mask |= GcDashOffset
	v.DashOffset = x
	return v
}
func (v *ChangeGCValues) SetDashes(x uint32) *ChangeGCValues {
	v.Mask |= GcDashList
	v.Dashes = x
	return v
}
func (v *ChangeGCValues) SetArcMode(x ArcMode) *ChangeGCValues {
	v.Mask |= GcArcMode
	v.ArcMode = x
	return v
}
func ChangeGC(b *xturbo.Buf, gc Gcontext, v *ChangeGCValues) xturbo.Seq {
	p, seq := b.Request(56, 0, 8+4*bits.OnesCount32(uint32(v.Mask)))
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(gc))
	binary.LittleEndian.PutUint32(p[4:], uint32(v.Mask))
	off := 8
	if v.Mask&GcFunction != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Function))
		off += 4
	}
	if v.Mask&GcPlaneMask != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.PlaneMask))
		off += 4
	}
	if v.Mask&GcForeground != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Foreground))
		off += 4
	}
	if v.Mask&GcBackground != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Background))
		off += 4
	}
	if v.Mask&GcLineWidth != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.LineWidth))
		off += 4
	}
	if v.Mask&GcLineStyle != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.LineStyle))
		off += 4
	}
	if v.Mask&GcCapStyle != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.CapStyle))
		off += 4
	}
	if v.Mask&GcJoinStyle != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.JoinStyle))
		off += 4
	}
	if v.Mask&GcFillStyle != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.FillStyle))
		off += 4
	}
	if v.Mask&GcFillRule != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.FillRule))
		off += 4
	}
	if v.Mask&GcTile != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Tile))
		off += 4
	}
	if v.Mask&GcStipple != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Stipple))
		off += 4
	}
	if v.Mask&GcTileStippleOriginX != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.TileStippleXOrigin))
		off += 4
	}
	if v.Mask&GcTileStippleOriginY != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.TileStippleYOrigin))
		off += 4
	}
	if v.Mask&GcFont != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Font))
		off += 4
	}
	if v.Mask&GcSubwindowMode != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.SubwindowMode))
		off += 4
	}
	if v.Mask&GcGraphicsExposures != 0 {
		if v.GraphicsExposures {
			binary.LittleEndian.PutUint32(p[off:], 1)
		} else {
			binary.LittleEndian.PutUint32(p[off:], 0)
		}
		off += 4
	}
	if v.Mask&GcClipOriginX != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.ClipXOrigin))
		off += 4
	}
	if v.Mask&GcClipOriginY != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.ClipYOrigin))
		off += 4
	}
	if v.Mask&GcClipMask != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.ClipMask))
		off += 4
	}
	if v.Mask&GcDashOffset != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.DashOffset))
		off += 4
	}
	if v.Mask&GcDashList != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Dashes))
		off += 4
	}
	if v.Mask&GcArcMode != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.ArcMode))
		off += 4
	}
	_ = off
	return seq
}

func CopyGC(b *xturbo.Buf, srcGc Gcontext, dstGc Gcontext, valueMask Gc) xturbo.Seq {
	p, seq := b.Request(57, 0, 12)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(srcGc))
	binary.LittleEndian.PutUint32(p[4:], uint32(dstGc))
	binary.LittleEndian.PutUint32(p[8:], uint32(valueMask))
	return seq
}

func SetDashes(b *xturbo.Buf, gc Gcontext, dashOffset uint16, dashes []byte) xturbo.Seq {
	if uint64(len(dashes)) > 65535 {
		b.Fail(xturbo.ErrBadLength)
		return 0
	}
	size := 0
	size += 4
	size += 2
	size += 2
	size += len(dashes) * 1
	size = (size + 3) &^ 3
	p, seq := b.Request(58, 0, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(gc))
	off += 4
	binary.LittleEndian.PutUint16(p[off:], uint16(dashOffset))
	off += 2
	binary.LittleEndian.PutUint16(p[off:], uint16(len(dashes)))
	off += 2
	copy(p[off:], dashes)
	off += len(dashes)
	return seq
}

func SetClipRectangles(b *xturbo.Buf, ordering ClipOrdering, gc Gcontext, clipXOrigin int16, clipYOrigin int16, rectangles []Rectangle) xturbo.Seq {
	size := 0
	size += 4
	size += 2
	size += 2
	size += len(rectangles) * 8
	size = (size + 3) &^ 3
	p, seq := b.Request(59, uint8(int(ordering)), size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(gc))
	off += 4
	binary.LittleEndian.PutUint16(p[off:], uint16(clipXOrigin))
	off += 2
	binary.LittleEndian.PutUint16(p[off:], uint16(clipYOrigin))
	off += 2
	for i := range rectangles {
		rectangles[i].Put(p[off:])
		off += 8
	}
	return seq
}

func FreeGC(b *xturbo.Buf, gc Gcontext) xturbo.Seq {
	p, seq := b.Request(60, 0, 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(gc))
	return seq
}

func ClearArea(b *xturbo.Buf, exposures bool, window Window, x int16, y int16, width uint16, height uint16) xturbo.Seq {
	var data uint8
	if exposures {
		data = 1
	}
	p, seq := b.Request(61, data, 12)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(window))
	binary.LittleEndian.PutUint16(p[4:], uint16(x))
	binary.LittleEndian.PutUint16(p[6:], uint16(y))
	binary.LittleEndian.PutUint16(p[8:], uint16(width))
	binary.LittleEndian.PutUint16(p[10:], uint16(height))
	return seq
}

func CopyArea(b *xturbo.Buf, srcDrawable Drawable, dstDrawable Drawable, gc Gcontext, srcX int16, srcY int16, dstX int16, dstY int16, width uint16, height uint16) xturbo.Seq {
	p, seq := b.Request(62, 0, 24)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(srcDrawable))
	binary.LittleEndian.PutUint32(p[4:], uint32(dstDrawable))
	binary.LittleEndian.PutUint32(p[8:], uint32(gc))
	binary.LittleEndian.PutUint16(p[12:], uint16(srcX))
	binary.LittleEndian.PutUint16(p[14:], uint16(srcY))
	binary.LittleEndian.PutUint16(p[16:], uint16(dstX))
	binary.LittleEndian.PutUint16(p[18:], uint16(dstY))
	binary.LittleEndian.PutUint16(p[20:], uint16(width))
	binary.LittleEndian.PutUint16(p[22:], uint16(height))
	return seq
}

func CopyPlane(b *xturbo.Buf, srcDrawable Drawable, dstDrawable Drawable, gc Gcontext, srcX int16, srcY int16, dstX int16, dstY int16, width uint16, height uint16, bitPlane uint32) xturbo.Seq {
	p, seq := b.Request(63, 0, 28)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(srcDrawable))
	binary.LittleEndian.PutUint32(p[4:], uint32(dstDrawable))
	binary.LittleEndian.PutUint32(p[8:], uint32(gc))
	binary.LittleEndian.PutUint16(p[12:], uint16(srcX))
	binary.LittleEndian.PutUint16(p[14:], uint16(srcY))
	binary.LittleEndian.PutUint16(p[16:], uint16(dstX))
	binary.LittleEndian.PutUint16(p[18:], uint16(dstY))
	binary.LittleEndian.PutUint16(p[20:], uint16(width))
	binary.LittleEndian.PutUint16(p[22:], uint16(height))
	binary.LittleEndian.PutUint32(p[24:], uint32(bitPlane))
	return seq
}

func PolyPoint(b *xturbo.Buf, coordinateMode CoordMode, drawable Drawable, gc Gcontext, points []Point) xturbo.Seq {
	size := 0
	size += 4
	size += 4
	size += len(points) * 4
	size = (size + 3) &^ 3
	p, seq := b.Request(64, uint8(int(coordinateMode)), size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(drawable))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(gc))
	off += 4
	for i := range points {
		points[i].Put(p[off:])
		off += 4
	}
	return seq
}

func PolyLine(b *xturbo.Buf, coordinateMode CoordMode, drawable Drawable, gc Gcontext, points []Point) xturbo.Seq {
	size := 0
	size += 4
	size += 4
	size += len(points) * 4
	size = (size + 3) &^ 3
	p, seq := b.Request(65, uint8(int(coordinateMode)), size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(drawable))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(gc))
	off += 4
	for i := range points {
		points[i].Put(p[off:])
		off += 4
	}
	return seq
}

func PolySegment(b *xturbo.Buf, drawable Drawable, gc Gcontext, segments []Segment) xturbo.Seq {
	size := 0
	size += 4
	size += 4
	size += len(segments) * 8
	size = (size + 3) &^ 3
	p, seq := b.Request(66, 0, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(drawable))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(gc))
	off += 4
	for i := range segments {
		segments[i].Put(p[off:])
		off += 8
	}
	return seq
}

func PolyRectangle(b *xturbo.Buf, drawable Drawable, gc Gcontext, rectangles []Rectangle) xturbo.Seq {
	size := 0
	size += 4
	size += 4
	size += len(rectangles) * 8
	size = (size + 3) &^ 3
	p, seq := b.Request(67, 0, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(drawable))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(gc))
	off += 4
	for i := range rectangles {
		rectangles[i].Put(p[off:])
		off += 8
	}
	return seq
}

func PolyArc(b *xturbo.Buf, drawable Drawable, gc Gcontext, arcs []Arc) xturbo.Seq {
	size := 0
	size += 4
	size += 4
	size += len(arcs) * 12
	size = (size + 3) &^ 3
	p, seq := b.Request(68, 0, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(drawable))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(gc))
	off += 4
	for i := range arcs {
		arcs[i].Put(p[off:])
		off += 12
	}
	return seq
}

func FillPoly(b *xturbo.Buf, drawable Drawable, gc Gcontext, shape PolyShape, coordinateMode CoordMode, points []Point) xturbo.Seq {
	size := 0
	size += 4
	size += 4
	size += 1
	size += 1
	size += 2
	size += len(points) * 4
	size = (size + 3) &^ 3
	p, seq := b.Request(69, 0, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(drawable))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(gc))
	off += 4
	p[off:][0] = byte(shape)
	off += 1
	p[off:][0] = byte(coordinateMode)
	off += 1
	off += 2
	for i := range points {
		points[i].Put(p[off:])
		off += 4
	}
	return seq
}

func PolyFillRectangle(b *xturbo.Buf, drawable Drawable, gc Gcontext, rectangles []Rectangle) xturbo.Seq {
	size := 0
	size += 4
	size += 4
	size += len(rectangles) * 8
	size = (size + 3) &^ 3
	p, seq := b.Request(70, 0, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(drawable))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(gc))
	off += 4
	for i := range rectangles {
		rectangles[i].Put(p[off:])
		off += 8
	}
	return seq
}

func PolyFillArc(b *xturbo.Buf, drawable Drawable, gc Gcontext, arcs []Arc) xturbo.Seq {
	size := 0
	size += 4
	size += 4
	size += len(arcs) * 12
	size = (size + 3) &^ 3
	p, seq := b.Request(71, 0, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(drawable))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(gc))
	off += 4
	for i := range arcs {
		arcs[i].Put(p[off:])
		off += 12
	}
	return seq
}

func PutImage(b *xturbo.Buf, format ImageFormat, drawable Drawable, gc Gcontext, width uint16, height uint16, dstX int16, dstY int16, leftPad uint8, depth uint8, data []byte) xturbo.Seq {
	size := 0
	size += 4
	size += 4
	size += 2
	size += 2
	size += 2
	size += 2
	size += 1
	size += 1
	size += 2
	size += len(data) * 1
	size = (size + 3) &^ 3
	p, seq := b.Request(72, uint8(int(format)), size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(drawable))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(gc))
	off += 4
	binary.LittleEndian.PutUint16(p[off:], uint16(width))
	off += 2
	binary.LittleEndian.PutUint16(p[off:], uint16(height))
	off += 2
	binary.LittleEndian.PutUint16(p[off:], uint16(dstX))
	off += 2
	binary.LittleEndian.PutUint16(p[off:], uint16(dstY))
	off += 2
	p[off:][0] = byte(leftPad)
	off += 1
	p[off:][0] = byte(depth)
	off += 1
	off += 2
	copy(p[off:], data)
	off += len(data)
	return seq
}

func GetImage(b *xturbo.Buf, format ImageFormat, drawable Drawable, x int16, y int16, width uint16, height uint16, planeMask uint32) xturbo.Seq {
	p, seq := b.Request(73, uint8(int(format)), 16)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(drawable))
	binary.LittleEndian.PutUint16(p[4:], uint16(x))
	binary.LittleEndian.PutUint16(p[6:], uint16(y))
	binary.LittleEndian.PutUint16(p[8:], uint16(width))
	binary.LittleEndian.PutUint16(p[10:], uint16(height))
	binary.LittleEndian.PutUint32(p[12:], uint32(planeMask))
	return seq
}

func PolyText8(b *xturbo.Buf, drawable Drawable, gc Gcontext, x int16, y int16, items []byte) xturbo.Seq {
	size := 0
	size += 4
	size += 4
	size += 2
	size += 2
	size += len(items) * 1
	size = (size + 3) &^ 3
	p, seq := b.Request(74, 0, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(drawable))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(gc))
	off += 4
	binary.LittleEndian.PutUint16(p[off:], uint16(x))
	off += 2
	binary.LittleEndian.PutUint16(p[off:], uint16(y))
	off += 2
	copy(p[off:], items)
	off += len(items)
	return seq
}

func PolyText16(b *xturbo.Buf, drawable Drawable, gc Gcontext, x int16, y int16, items []byte) xturbo.Seq {
	size := 0
	size += 4
	size += 4
	size += 2
	size += 2
	size += len(items) * 1
	size = (size + 3) &^ 3
	p, seq := b.Request(75, 0, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(drawable))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(gc))
	off += 4
	binary.LittleEndian.PutUint16(p[off:], uint16(x))
	off += 2
	binary.LittleEndian.PutUint16(p[off:], uint16(y))
	off += 2
	copy(p[off:], items)
	off += len(items)
	return seq
}

func ImageText8(b *xturbo.Buf, drawable Drawable, gc Gcontext, x int16, y int16, string string) xturbo.Seq {
	if len(string) > 255 {
		b.Fail(xturbo.ErrBadLength)
		return 0
	}
	size := 0
	size += 4
	size += 4
	size += 2
	size += 2
	size += len(string) * 1
	size = (size + 3) &^ 3
	p, seq := b.Request(76, uint8(len(string)), size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(drawable))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(gc))
	off += 4
	binary.LittleEndian.PutUint16(p[off:], uint16(x))
	off += 2
	binary.LittleEndian.PutUint16(p[off:], uint16(y))
	off += 2
	copy(p[off:], string)
	off += len(string)
	return seq
}

func ImageText16(b *xturbo.Buf, drawable Drawable, gc Gcontext, x int16, y int16, string []Char2b) xturbo.Seq {
	if len(string) > 255 {
		b.Fail(xturbo.ErrBadLength)
		return 0
	}
	size := 0
	size += 4
	size += 4
	size += 2
	size += 2
	size += len(string) * 2
	size = (size + 3) &^ 3
	p, seq := b.Request(77, uint8(len(string)), size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(drawable))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(gc))
	off += 4
	binary.LittleEndian.PutUint16(p[off:], uint16(x))
	off += 2
	binary.LittleEndian.PutUint16(p[off:], uint16(y))
	off += 2
	for i := range string {
		string[i].Put(p[off:])
		off += 2
	}
	return seq
}

func CreateColormap(b *xturbo.Buf, alloc ColormapAlloc, mid Colormap, window Window, visual Visualid) xturbo.Seq {
	p, seq := b.Request(78, uint8(int(alloc)), 12)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(mid))
	binary.LittleEndian.PutUint32(p[4:], uint32(window))
	binary.LittleEndian.PutUint32(p[8:], uint32(visual))
	return seq
}

func FreeColormap(b *xturbo.Buf, cmap Colormap) xturbo.Seq {
	p, seq := b.Request(79, 0, 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(cmap))
	return seq
}

func CopyColormapAndFree(b *xturbo.Buf, mid Colormap, srcCmap Colormap) xturbo.Seq {
	p, seq := b.Request(80, 0, 8)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(mid))
	binary.LittleEndian.PutUint32(p[4:], uint32(srcCmap))
	return seq
}

func InstallColormap(b *xturbo.Buf, cmap Colormap) xturbo.Seq {
	p, seq := b.Request(81, 0, 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(cmap))
	return seq
}

func UninstallColormap(b *xturbo.Buf, cmap Colormap) xturbo.Seq {
	p, seq := b.Request(82, 0, 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(cmap))
	return seq
}

func ListInstalledColormaps(b *xturbo.Buf, window Window) xturbo.Seq {
	p, seq := b.Request(83, 0, 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(window))
	return seq
}

func AllocColor(b *xturbo.Buf, cmap Colormap, red uint16, green uint16, blue uint16) xturbo.Seq {
	p, seq := b.Request(84, 0, 12)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(cmap))
	binary.LittleEndian.PutUint16(p[4:], uint16(red))
	binary.LittleEndian.PutUint16(p[6:], uint16(green))
	binary.LittleEndian.PutUint16(p[8:], uint16(blue))
	return seq
}

func AllocNamedColor(b *xturbo.Buf, cmap Colormap, name string) xturbo.Seq {
	if uint64(len(name)) > 65535 {
		b.Fail(xturbo.ErrBadLength)
		return 0
	}
	size := 0
	size += 4
	size += 2
	size += 2
	size += len(name) * 1
	size = (size + 3) &^ 3
	p, seq := b.Request(85, 0, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(cmap))
	off += 4
	binary.LittleEndian.PutUint16(p[off:], uint16(len(name)))
	off += 2
	off += 2
	copy(p[off:], name)
	off += len(name)
	return seq
}

func AllocColorCells(b *xturbo.Buf, contiguous bool, cmap Colormap, colors uint16, planes uint16) xturbo.Seq {
	var data uint8
	if contiguous {
		data = 1
	}
	p, seq := b.Request(86, data, 8)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(cmap))
	binary.LittleEndian.PutUint16(p[4:], uint16(colors))
	binary.LittleEndian.PutUint16(p[6:], uint16(planes))
	return seq
}

func AllocColorPlanes(b *xturbo.Buf, contiguous bool, cmap Colormap, colors uint16, reds uint16, greens uint16, blues uint16) xturbo.Seq {
	var data uint8
	if contiguous {
		data = 1
	}
	p, seq := b.Request(87, data, 12)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(cmap))
	binary.LittleEndian.PutUint16(p[4:], uint16(colors))
	binary.LittleEndian.PutUint16(p[6:], uint16(reds))
	binary.LittleEndian.PutUint16(p[8:], uint16(greens))
	binary.LittleEndian.PutUint16(p[10:], uint16(blues))
	return seq
}

func FreeColors(b *xturbo.Buf, cmap Colormap, planeMask uint32, pixels []uint32) xturbo.Seq {
	size := 0
	size += 4
	size += 4
	size += len(pixels) * 4
	size = (size + 3) &^ 3
	p, seq := b.Request(88, 0, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(cmap))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(planeMask))
	off += 4
	for i := range pixels {
		binary.LittleEndian.PutUint32(p[off:], uint32(pixels[i]))
		off += 4
	}
	return seq
}

func StoreColors(b *xturbo.Buf, cmap Colormap, items []Coloritem) xturbo.Seq {
	size := 0
	size += 4
	size += len(items) * 12
	size = (size + 3) &^ 3
	p, seq := b.Request(89, 0, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(cmap))
	off += 4
	for i := range items {
		items[i].Put(p[off:])
		off += 12
	}
	return seq
}

func StoreNamedColor(b *xturbo.Buf, flags ColorFlag, cmap Colormap, pixel uint32, name string) xturbo.Seq {
	if uint64(len(name)) > 65535 {
		b.Fail(xturbo.ErrBadLength)
		return 0
	}
	size := 0
	size += 4
	size += 4
	size += 2
	size += 2
	size += len(name) * 1
	size = (size + 3) &^ 3
	p, seq := b.Request(90, uint8(int(flags)), size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(cmap))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(pixel))
	off += 4
	binary.LittleEndian.PutUint16(p[off:], uint16(len(name)))
	off += 2
	off += 2
	copy(p[off:], name)
	off += len(name)
	return seq
}

func QueryColors(b *xturbo.Buf, cmap Colormap, pixels []uint32) xturbo.Seq {
	size := 0
	size += 4
	size += len(pixels) * 4
	size = (size + 3) &^ 3
	p, seq := b.Request(91, 0, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(cmap))
	off += 4
	for i := range pixels {
		binary.LittleEndian.PutUint32(p[off:], uint32(pixels[i]))
		off += 4
	}
	return seq
}

func LookupColor(b *xturbo.Buf, cmap Colormap, name string) xturbo.Seq {
	if uint64(len(name)) > 65535 {
		b.Fail(xturbo.ErrBadLength)
		return 0
	}
	size := 0
	size += 4
	size += 2
	size += 2
	size += len(name) * 1
	size = (size + 3) &^ 3
	p, seq := b.Request(92, 0, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(cmap))
	off += 4
	binary.LittleEndian.PutUint16(p[off:], uint16(len(name)))
	off += 2
	off += 2
	copy(p[off:], name)
	off += len(name)
	return seq
}

func CreateCursor(b *xturbo.Buf, cid Cursor, source Pixmap, mask Pixmap, foreRed uint16, foreGreen uint16, foreBlue uint16, backRed uint16, backGreen uint16, backBlue uint16, x uint16, y uint16) xturbo.Seq {
	p, seq := b.Request(93, 0, 28)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(cid))
	binary.LittleEndian.PutUint32(p[4:], uint32(source))
	binary.LittleEndian.PutUint32(p[8:], uint32(mask))
	binary.LittleEndian.PutUint16(p[12:], uint16(foreRed))
	binary.LittleEndian.PutUint16(p[14:], uint16(foreGreen))
	binary.LittleEndian.PutUint16(p[16:], uint16(foreBlue))
	binary.LittleEndian.PutUint16(p[18:], uint16(backRed))
	binary.LittleEndian.PutUint16(p[20:], uint16(backGreen))
	binary.LittleEndian.PutUint16(p[22:], uint16(backBlue))
	binary.LittleEndian.PutUint16(p[24:], uint16(x))
	binary.LittleEndian.PutUint16(p[26:], uint16(y))
	return seq
}

func CreateGlyphCursor(b *xturbo.Buf, cid Cursor, sourceFont Font, maskFont Font, sourceChar uint16, maskChar uint16, foreRed uint16, foreGreen uint16, foreBlue uint16, backRed uint16, backGreen uint16, backBlue uint16) xturbo.Seq {
	p, seq := b.Request(94, 0, 28)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(cid))
	binary.LittleEndian.PutUint32(p[4:], uint32(sourceFont))
	binary.LittleEndian.PutUint32(p[8:], uint32(maskFont))
	binary.LittleEndian.PutUint16(p[12:], uint16(sourceChar))
	binary.LittleEndian.PutUint16(p[14:], uint16(maskChar))
	binary.LittleEndian.PutUint16(p[16:], uint16(foreRed))
	binary.LittleEndian.PutUint16(p[18:], uint16(foreGreen))
	binary.LittleEndian.PutUint16(p[20:], uint16(foreBlue))
	binary.LittleEndian.PutUint16(p[22:], uint16(backRed))
	binary.LittleEndian.PutUint16(p[24:], uint16(backGreen))
	binary.LittleEndian.PutUint16(p[26:], uint16(backBlue))
	return seq
}

func FreeCursor(b *xturbo.Buf, cursor Cursor) xturbo.Seq {
	p, seq := b.Request(95, 0, 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(cursor))
	return seq
}

func RecolorCursor(b *xturbo.Buf, cursor Cursor, foreRed uint16, foreGreen uint16, foreBlue uint16, backRed uint16, backGreen uint16, backBlue uint16) xturbo.Seq {
	p, seq := b.Request(96, 0, 16)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(cursor))
	binary.LittleEndian.PutUint16(p[4:], uint16(foreRed))
	binary.LittleEndian.PutUint16(p[6:], uint16(foreGreen))
	binary.LittleEndian.PutUint16(p[8:], uint16(foreBlue))
	binary.LittleEndian.PutUint16(p[10:], uint16(backRed))
	binary.LittleEndian.PutUint16(p[12:], uint16(backGreen))
	binary.LittleEndian.PutUint16(p[14:], uint16(backBlue))
	return seq
}

func QueryBestSize(b *xturbo.Buf, class QueryShapeOf, drawable Drawable, width uint16, height uint16) xturbo.Seq {
	p, seq := b.Request(97, uint8(int(class)), 8)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(drawable))
	binary.LittleEndian.PutUint16(p[4:], uint16(width))
	binary.LittleEndian.PutUint16(p[6:], uint16(height))
	return seq
}

func QueryExtension(b *xturbo.Buf, name string) xturbo.Seq {
	if uint64(len(name)) > 65535 {
		b.Fail(xturbo.ErrBadLength)
		return 0
	}
	size := 0
	size += 2
	size += 2
	size += len(name) * 1
	size = (size + 3) &^ 3
	p, seq := b.Request(98, 0, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint16(p[off:], uint16(len(name)))
	off += 2
	off += 2
	copy(p[off:], name)
	off += len(name)
	return seq
}

func ListExtensions(b *xturbo.Buf) xturbo.Seq {
	p, seq := b.Request(99, 0, 0)
	if p == nil {
		return 0
	}
	return seq
}

func ChangeKeyboardMapping(b *xturbo.Buf, keycodeCount uint8, firstKeycode Keycode, keysymsPerKeycode uint8, keysyms []Keysym) xturbo.Seq {
	if len(keysyms) != (int(keycodeCount) * int(keysymsPerKeycode)) {
		b.Fail(xturbo.ErrBadLength)
		return 0
	}
	size := 0
	size += 1
	size += 1
	size += 2
	size += len(keysyms) * 4
	size = (size + 3) &^ 3
	p, seq := b.Request(100, uint8(int(keycodeCount)), size)
	if p == nil {
		return 0
	}
	off := 0
	p[off:][0] = byte(firstKeycode)
	off += 1
	p[off:][0] = byte(keysymsPerKeycode)
	off += 1
	off += 2
	for i := range keysyms {
		binary.LittleEndian.PutUint32(p[off:], uint32(keysyms[i]))
		off += 4
	}
	return seq
}

func GetKeyboardMapping(b *xturbo.Buf, firstKeycode Keycode, count uint8) xturbo.Seq {
	p, seq := b.Request(101, 0, 4)
	if p == nil {
		return 0
	}
	p[0:][0] = byte(firstKeycode)
	p[1:][0] = byte(count)
	return seq
}

type ChangeKeyboardControlValues struct {
	Mask            Kb
	KeyClickPercent int32
	BellPercent     int32
	BellPitch       int32
	BellDuration    int32
	Led             uint32
	LedMode         LedMode
	Key             Keycode32
	AutoRepeatMode  AutoRepeatMode
}

func (v *ChangeKeyboardControlValues) SetKeyClickPercent(x int32) *ChangeKeyboardControlValues {
	v.Mask |= KbKeyClickPercent
	v.KeyClickPercent = x
	return v
}
func (v *ChangeKeyboardControlValues) SetBellPercent(x int32) *ChangeKeyboardControlValues {
	v.Mask |= KbBellPercent
	v.BellPercent = x
	return v
}
func (v *ChangeKeyboardControlValues) SetBellPitch(x int32) *ChangeKeyboardControlValues {
	v.Mask |= KbBellPitch
	v.BellPitch = x
	return v
}
func (v *ChangeKeyboardControlValues) SetBellDuration(x int32) *ChangeKeyboardControlValues {
	v.Mask |= KbBellDuration
	v.BellDuration = x
	return v
}
func (v *ChangeKeyboardControlValues) SetLed(x uint32) *ChangeKeyboardControlValues {
	v.Mask |= KbLed
	v.Led = x
	return v
}
func (v *ChangeKeyboardControlValues) SetLedMode(x LedMode) *ChangeKeyboardControlValues {
	v.Mask |= KbLedMode
	v.LedMode = x
	return v
}
func (v *ChangeKeyboardControlValues) SetKey(x Keycode32) *ChangeKeyboardControlValues {
	v.Mask |= KbKey
	v.Key = x
	return v
}
func (v *ChangeKeyboardControlValues) SetAutoRepeatMode(x AutoRepeatMode) *ChangeKeyboardControlValues {
	v.Mask |= KbAutoRepeatMode
	v.AutoRepeatMode = x
	return v
}
func ChangeKeyboardControl(b *xturbo.Buf, v *ChangeKeyboardControlValues) xturbo.Seq {
	p, seq := b.Request(102, 0, 4+4*bits.OnesCount32(uint32(v.Mask)))
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(v.Mask))
	off := 4
	if v.Mask&KbKeyClickPercent != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.KeyClickPercent))
		off += 4
	}
	if v.Mask&KbBellPercent != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.BellPercent))
		off += 4
	}
	if v.Mask&KbBellPitch != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.BellPitch))
		off += 4
	}
	if v.Mask&KbBellDuration != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.BellDuration))
		off += 4
	}
	if v.Mask&KbLed != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Led))
		off += 4
	}
	if v.Mask&KbLedMode != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.LedMode))
		off += 4
	}
	if v.Mask&KbKey != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.Key))
		off += 4
	}
	if v.Mask&KbAutoRepeatMode != 0 {
		binary.LittleEndian.PutUint32(p[off:], uint32(v.AutoRepeatMode))
		off += 4
	}
	_ = off
	return seq
}

func GetKeyboardControl(b *xturbo.Buf) xturbo.Seq {
	p, seq := b.Request(103, 0, 0)
	if p == nil {
		return 0
	}
	return seq
}

func Bell(b *xturbo.Buf, percent int8) xturbo.Seq {
	p, seq := b.Request(104, uint8(int(percent)), 0)
	if p == nil {
		return 0
	}
	return seq
}

func ChangePointerControl(b *xturbo.Buf, accelerationNumerator int16, accelerationDenominator int16, threshold int16, doAcceleration bool, doThreshold bool) xturbo.Seq {
	p, seq := b.Request(105, 0, 8)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint16(p[0:], uint16(accelerationNumerator))
	binary.LittleEndian.PutUint16(p[2:], uint16(accelerationDenominator))
	binary.LittleEndian.PutUint16(p[4:], uint16(threshold))
	if doAcceleration {
		p[6:][0] = 1
	} else {
		p[6:][0] = 0
	}
	if doThreshold {
		p[7:][0] = 1
	} else {
		p[7:][0] = 0
	}
	return seq
}

func GetPointerControl(b *xturbo.Buf) xturbo.Seq {
	p, seq := b.Request(106, 0, 0)
	if p == nil {
		return 0
	}
	return seq
}

func SetScreenSaver(b *xturbo.Buf, timeout int16, interval int16, preferBlanking Blanking, allowExposures Exposures) xturbo.Seq {
	p, seq := b.Request(107, 0, 8)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint16(p[0:], uint16(timeout))
	binary.LittleEndian.PutUint16(p[2:], uint16(interval))
	p[4:][0] = byte(preferBlanking)
	p[5:][0] = byte(allowExposures)
	return seq
}

func GetScreenSaver(b *xturbo.Buf) xturbo.Seq {
	p, seq := b.Request(108, 0, 0)
	if p == nil {
		return 0
	}
	return seq
}

func ChangeHosts(b *xturbo.Buf, mode HostMode, family Family, address []byte) xturbo.Seq {
	if uint64(len(address)) > 65535 {
		b.Fail(xturbo.ErrBadLength)
		return 0
	}
	size := 0
	size += 1
	size += 1
	size += 2
	size += len(address) * 1
	size = (size + 3) &^ 3
	p, seq := b.Request(109, uint8(int(mode)), size)
	if p == nil {
		return 0
	}
	off := 0
	p[off:][0] = byte(family)
	off += 1
	off += 1
	binary.LittleEndian.PutUint16(p[off:], uint16(len(address)))
	off += 2
	copy(p[off:], address)
	off += len(address)
	return seq
}

func ListHosts(b *xturbo.Buf) xturbo.Seq {
	p, seq := b.Request(110, 0, 0)
	if p == nil {
		return 0
	}
	return seq
}

func SetAccessControl(b *xturbo.Buf, mode AccessControl) xturbo.Seq {
	p, seq := b.Request(111, uint8(int(mode)), 0)
	if p == nil {
		return 0
	}
	return seq
}

func SetCloseDownMode(b *xturbo.Buf, mode CloseDown) xturbo.Seq {
	p, seq := b.Request(112, uint8(int(mode)), 0)
	if p == nil {
		return 0
	}
	return seq
}

func KillClient(b *xturbo.Buf, resource uint32) xturbo.Seq {
	p, seq := b.Request(113, 0, 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(resource))
	return seq
}

func RotateProperties(b *xturbo.Buf, window Window, delta int16, atoms []Atom) xturbo.Seq {
	if uint64(len(atoms)) > 65535 {
		b.Fail(xturbo.ErrBadLength)
		return 0
	}
	size := 0
	size += 4
	size += 2
	size += 2
	size += len(atoms) * 4
	size = (size + 3) &^ 3
	p, seq := b.Request(114, 0, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(window))
	off += 4
	binary.LittleEndian.PutUint16(p[off:], uint16(len(atoms)))
	off += 2
	binary.LittleEndian.PutUint16(p[off:], uint16(delta))
	off += 2
	for i := range atoms {
		binary.LittleEndian.PutUint32(p[off:], uint32(atoms[i]))
		off += 4
	}
	return seq
}

func ForceScreenSaver(b *xturbo.Buf, mode ScreenSaver) xturbo.Seq {
	p, seq := b.Request(115, uint8(int(mode)), 0)
	if p == nil {
		return 0
	}
	return seq
}

func SetPointerMapping(b *xturbo.Buf, map_ []byte) xturbo.Seq {
	if len(map_) > 255 {
		b.Fail(xturbo.ErrBadLength)
		return 0
	}
	size := 0
	size += len(map_) * 1
	size = (size + 3) &^ 3
	p, seq := b.Request(116, uint8(len(map_)), size)
	if p == nil {
		return 0
	}
	off := 0
	copy(p[off:], map_)
	off += len(map_)
	return seq
}

func GetPointerMapping(b *xturbo.Buf) xturbo.Seq {
	p, seq := b.Request(117, 0, 0)
	if p == nil {
		return 0
	}
	return seq
}

func SetModifierMapping(b *xturbo.Buf, keycodesPerModifier uint8, keycodes []Keycode) xturbo.Seq {
	if len(keycodes) != (int(keycodesPerModifier) * 8) {
		b.Fail(xturbo.ErrBadLength)
		return 0
	}
	size := 0
	size += len(keycodes) * 1
	size = (size + 3) &^ 3
	p, seq := b.Request(118, uint8(int(keycodesPerModifier)), size)
	if p == nil {
		return 0
	}
	off := 0
	for i := range keycodes {
		p[off:][0] = byte(keycodes[i])
		off += 1
	}
	return seq
}

func GetModifierMapping(b *xturbo.Buf) xturbo.Seq {
	p, seq := b.Request(119, 0, 0)
	if p == nil {
		return 0
	}
	return seq
}

func NoOperation(b *xturbo.Buf) xturbo.Seq {
	p, seq := b.Request(127, 0, 0)
	if p == nil {
		return 0
	}
	return seq
}