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

import "bnema.dev/xturbo/render"
import "bnema.dev/xturbo/shape"
import "bnema.dev/xturbo/xproto"
import "encoding/binary"
import "bnema.dev/xturbo"

func QueryVersion(b *xturbo.Buf, clientMajorVersion uint32, clientMinorVersion uint32) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtXFixes)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 0, 8)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(clientMajorVersion))
	binary.LittleEndian.PutUint32(p[4:], uint32(clientMinorVersion))
	return seq
}

func ChangeSaveSet(b *xturbo.Buf, mode SaveSetMode, target SaveSetTarget, map_ SaveSetMapping, window xproto.Window) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtXFixes)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 1, 8)
	if p == nil {
		return 0
	}
	p[0:][0] = byte(mode)
	p[1:][0] = byte(target)
	p[2:][0] = byte(map_)
	binary.LittleEndian.PutUint32(p[4:], uint32(window))
	return seq
}

func SelectSelectionInput(b *xturbo.Buf, window xproto.Window, selection xproto.Atom, eventMask SelectionEventMask) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtXFixes)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 2, 12)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(window))
	binary.LittleEndian.PutUint32(p[4:], uint32(selection))
	binary.LittleEndian.PutUint32(p[8:], uint32(eventMask))
	return seq
}

func SelectCursorInput(b *xturbo.Buf, window xproto.Window, eventMask CursorNotifyMask) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtXFixes)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 3, 8)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(window))
	binary.LittleEndian.PutUint32(p[4:], uint32(eventMask))
	return seq
}

func GetCursorImage(b *xturbo.Buf) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtXFixes)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 4, 0)
	if p == nil {
		return 0
	}
	return seq
}

func CreateRegion(b *xturbo.Buf, region Region, rectangles []xproto.Rectangle) xturbo.Seq {
	size := 0
	size += 4
	size += len(rectangles) * 8
	size = (size + 3) &^ 3
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtXFixes)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 5, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(region))
	off += 4
	for i := range rectangles {
		rectangles[i].Put(p[off:])
		off += 8
	}
	return seq
}

func CreateRegionFromBitmap(b *xturbo.Buf, region Region, bitmap xproto.Pixmap) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtXFixes)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 6, 8)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(region))
	binary.LittleEndian.PutUint32(p[4:], uint32(bitmap))
	return seq
}

func CreateRegionFromWindow(b *xturbo.Buf, region Region, window xproto.Window, kind shape.Sk) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtXFixes)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 7, 12)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(region))
	binary.LittleEndian.PutUint32(p[4:], uint32(window))
	p[8:][0] = byte(kind)
	return seq
}

func CreateRegionFromGC(b *xturbo.Buf, region Region, gc xproto.Gcontext) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtXFixes)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 8, 8)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(region))
	binary.LittleEndian.PutUint32(p[4:], uint32(gc))
	return seq
}

func CreateRegionFromPicture(b *xturbo.Buf, region Region, picture render.Picture) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtXFixes)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 9, 8)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(region))
	binary.LittleEndian.PutUint32(p[4:], uint32(picture))
	return seq
}

func DestroyRegion(b *xturbo.Buf, region Region) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtXFixes)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 10, 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(region))
	return seq
}

func SetRegion(b *xturbo.Buf, region Region, rectangles []xproto.Rectangle) xturbo.Seq {
	size := 0
	size += 4
	size += len(rectangles) * 8
	size = (size + 3) &^ 3
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtXFixes)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 11, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(region))
	off += 4
	for i := range rectangles {
		rectangles[i].Put(p[off:])
		off += 8
	}
	return seq
}

func CopyRegion(b *xturbo.Buf, source Region, destination Region) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtXFixes)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 12, 8)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(source))
	binary.LittleEndian.PutUint32(p[4:], uint32(destination))
	return seq
}

func UnionRegion(b *xturbo.Buf, source1 Region, source2 Region, destination Region) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtXFixes)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 13, 12)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(source1))
	binary.LittleEndian.PutUint32(p[4:], uint32(source2))
	binary.LittleEndian.PutUint32(p[8:], uint32(destination))
	return seq
}

func IntersectRegion(b *xturbo.Buf, source1 Region, source2 Region, destination Region) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtXFixes)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 14, 12)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(source1))
	binary.LittleEndian.PutUint32(p[4:], uint32(source2))
	binary.LittleEndian.PutUint32(p[8:], uint32(destination))
	return seq
}

func SubtractRegion(b *xturbo.Buf, source1 Region, source2 Region, destination Region) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtXFixes)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 15, 12)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(source1))
	binary.LittleEndian.PutUint32(p[4:], uint32(source2))
	binary.LittleEndian.PutUint32(p[8:], uint32(destination))
	return seq
}

func InvertRegion(b *xturbo.Buf, source Region, bounds xproto.Rectangle, destination Region) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtXFixes)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 16, 16)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(source))
	bounds.Put(p[4:])
	binary.LittleEndian.PutUint32(p[12:], uint32(destination))
	return seq
}

func TranslateRegion(b *xturbo.Buf, region Region, dx int16, dy int16) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtXFixes)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 17, 8)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(region))
	binary.LittleEndian.PutUint16(p[4:], uint16(dx))
	binary.LittleEndian.PutUint16(p[6:], uint16(dy))
	return seq
}

func RegionExtents(b *xturbo.Buf, source Region, destination Region) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtXFixes)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 18, 8)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(source))
	binary.LittleEndian.PutUint32(p[4:], uint32(destination))
	return seq
}

func FetchRegion(b *xturbo.Buf, region Region) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtXFixes)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 19, 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(region))
	return seq
}

func SetGCClipRegion(b *xturbo.Buf, gc xproto.Gcontext, region Region, xOrigin int16, yOrigin int16) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtXFixes)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 20, 12)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(gc))
	binary.LittleEndian.PutUint32(p[4:], uint32(region))
	binary.LittleEndian.PutUint16(p[8:], uint16(xOrigin))
	binary.LittleEndian.PutUint16(p[10:], uint16(yOrigin))
	return seq
}

func SetWindowShapeRegion(b *xturbo.Buf, dest xproto.Window, destKind shape.Sk, xOffset int16, yOffset int16, region Region) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtXFixes)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 21, 16)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(dest))
	p[4:][0] = byte(destKind)
	binary.LittleEndian.PutUint16(p[8:], uint16(xOffset))
	binary.LittleEndian.PutUint16(p[10:], uint16(yOffset))
	binary.LittleEndian.PutUint32(p[12:], uint32(region))
	return seq
}

func SetPictureClipRegion(b *xturbo.Buf, picture render.Picture, region Region, xOrigin int16, yOrigin int16) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtXFixes)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 22, 12)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(picture))
	binary.LittleEndian.PutUint32(p[4:], uint32(region))
	binary.LittleEndian.PutUint16(p[8:], uint16(xOrigin))
	binary.LittleEndian.PutUint16(p[10:], uint16(yOrigin))
	return seq
}

func SetCursorName(b *xturbo.Buf, cursor xproto.Cursor, 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
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtXFixes)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 23, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(cursor))
	off += 4
	binary.LittleEndian.PutUint16(p[off:], uint16(len(name)))
	off += 2
	off += 2
	copy(p[off:], name)
	off += len(name)
	return seq
}

func GetCursorName(b *xturbo.Buf, cursor xproto.Cursor) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtXFixes)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 24, 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(cursor))
	return seq
}

func GetCursorImageAndName(b *xturbo.Buf) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtXFixes)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 25, 0)
	if p == nil {
		return 0
	}
	return seq
}

func ChangeCursor(b *xturbo.Buf, source xproto.Cursor, destination xproto.Cursor) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtXFixes)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 26, 8)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(source))
	binary.LittleEndian.PutUint32(p[4:], uint32(destination))
	return seq
}

func ChangeCursorByName(b *xturbo.Buf, src xproto.Cursor, 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
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtXFixes)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 27, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(src))
	off += 4
	binary.LittleEndian.PutUint16(p[off:], uint16(len(name)))
	off += 2
	off += 2
	copy(p[off:], name)
	off += len(name)
	return seq
}

func ExpandRegion(b *xturbo.Buf, source Region, destination Region, left uint16, right uint16, top uint16, bottom uint16) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtXFixes)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 28, 16)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(source))
	binary.LittleEndian.PutUint32(p[4:], uint32(destination))
	binary.LittleEndian.PutUint16(p[8:], uint16(left))
	binary.LittleEndian.PutUint16(p[10:], uint16(right))
	binary.LittleEndian.PutUint16(p[12:], uint16(top))
	binary.LittleEndian.PutUint16(p[14:], uint16(bottom))
	return seq
}

func HideCursor(b *xturbo.Buf, window xproto.Window) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtXFixes)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 29, 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(window))
	return seq
}

func ShowCursor(b *xturbo.Buf, window xproto.Window) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtXFixes)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 30, 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(window))
	return seq
}

func CreatePointerBarrier(b *xturbo.Buf, barrier Barrier, window xproto.Window, x1 uint16, y1 uint16, x2 uint16, y2 uint16, directions BarrierDirections, devices []uint16) xturbo.Seq {
	if uint64(len(devices)) > 65535 {
		b.Fail(xturbo.ErrBadLength)
		return 0
	}
	size := 0
	size += 4
	size += 4
	size += 2
	size += 2
	size += 2
	size += 2
	size += 4
	size += 2
	size += 2
	size += len(devices) * 2
	size = (size + 3) &^ 3
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtXFixes)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 31, size)
	if p == nil {
		return 0
	}
	off := 0
	binary.LittleEndian.PutUint32(p[off:], uint32(barrier))
	off += 4
	binary.LittleEndian.PutUint32(p[off:], uint32(window))
	off += 4
	binary.LittleEndian.PutUint16(p[off:], uint16(x1))
	off += 2
	binary.LittleEndian.PutUint16(p[off:], uint16(y1))
	off += 2
	binary.LittleEndian.PutUint16(p[off:], uint16(x2))
	off += 2
	binary.LittleEndian.PutUint16(p[off:], uint16(y2))
	off += 2
	binary.LittleEndian.PutUint32(p[off:], uint32(directions))
	off += 4
	off += 2
	binary.LittleEndian.PutUint16(p[off:], uint16(len(devices)))
	off += 2
	for i := range devices {
		binary.LittleEndian.PutUint16(p[off:], uint16(devices[i]))
		off += 2
	}
	return seq
}

func DeletePointerBarrier(b *xturbo.Buf, barrier Barrier) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtXFixes)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 32, 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(barrier))
	return seq
}

func SetClientDisconnectMode(b *xturbo.Buf, disconnectMode ClientDisconnectFlags) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtXFixes)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 33, 4)
	if p == nil {
		return 0
	}
	binary.LittleEndian.PutUint32(p[0:], uint32(disconnectMode))
	return seq
}

func GetClientDisconnectMode(b *xturbo.Buf) xturbo.Seq {
	if b.Ext == nil {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	major := b.Ext.Major(xturbo.ExtXFixes)
	if major == 0 {
		b.Fail(xturbo.ErrExtMissing)
		return 0
	}
	p, seq := b.Request(major, 34, 0)
	if p == nil {
		return 0
	}
	return seq
}