// This file was generated automatically from xproto.xml.

package xgb

import "os"

type Char2b struct {
	Byte1 byte
	Byte2 byte
}

func getChar2b(b []byte, v *Char2b) int {
	v.Byte1 = b[0]
	v.Byte2 = b[1]
	return 2
}

func (c *Conn) sendChar2bList(list []Char2b, count int) {
	b0 := make([]byte, 2*count)
	for k := 0; k < count; k++ {
		b := b0[k*2:]
		b[0] = list[k].Byte1
		b[1] = list[k].Byte2
	}
	c.sendBytes(b0)
}

type Point struct {
	X int16
	Y int16
}

func getPoint(b []byte, v *Point) int {
	v.X = int16(get16(b[0:]))
	v.Y = int16(get16(b[2:]))
	return 4
}

func (c *Conn) sendPointList(list []Point, count int) {
	b0 := make([]byte, 4*count)
	for k := 0; k < count; k++ {
		b := b0[k*4:]
		put16(b[0:], uint16(list[k].X))
		put16(b[2:], uint16(list[k].Y))
	}
	c.sendBytes(b0)
}

type Rectangle struct {
	X      int16
	Y      int16
	Width  uint16
	Height uint16
}

func getRectangle(b []byte, v *Rectangle) int {
	v.X = int16(get16(b[0:]))
	v.Y = int16(get16(b[2:]))
	v.Width = get16(b[4:])
	v.Height = get16(b[6:])
	return 8
}

func (c *Conn) sendRectangleList(list []Rectangle, count int) {
	b0 := make([]byte, 8*count)
	for k := 0; k < count; k++ {
		b := b0[k*8:]
		put16(b[0:], uint16(list[k].X))
		put16(b[2:], uint16(list[k].Y))
		put16(b[4:], list[k].Width)
		put16(b[6:], list[k].Height)
	}
	c.sendBytes(b0)
}

type Arc struct {
	X      int16
	Y      int16
	Width  uint16
	Height uint16
	Angle1 int16
	Angle2 int16
}

func getArc(b []byte, v *Arc) int {
	v.X = int16(get16(b[0:]))
	v.Y = int16(get16(b[2:]))
	v.Width = get16(b[4:])
	v.Height = get16(b[6:])
	v.Angle1 = int16(get16(b[8:]))
	v.Angle2 = int16(get16(b[10:]))
	return 12
}

func (c *Conn) sendArcList(list []Arc, count int) {
	b0 := make([]byte, 12*count)
	for k := 0; k < count; k++ {
		b := b0[k*12:]
		put16(b[0:], uint16(list[k].X))
		put16(b[2:], uint16(list[k].Y))
		put16(b[4:], list[k].Width)
		put16(b[6:], list[k].Height)
		put16(b[8:], uint16(list[k].Angle1))
		put16(b[10:], uint16(list[k].Angle2))
	}
	c.sendBytes(b0)
}

type Format struct {
	Depth        byte
	BitsPerPixel byte
	ScanlinePad  byte
}

func getFormat(b []byte, v *Format) int {
	v.Depth = b[0]
	v.BitsPerPixel = b[1]
	v.ScanlinePad = b[2]
	return 8
}

const (
	VisualClassStaticGray  = 0
	VisualClassGrayScale   = 1
	VisualClassStaticColor = 2
	VisualClassPseudoColor = 3
	VisualClassTrueColor   = 4
	VisualClassDirectColor = 5
)

type VisualInfo struct {
	VisualId        Id
	Class           byte
	BitsPerRgbValue byte
	ColormapEntries uint16
	RedMask         uint32
	GreenMask       uint32
	BlueMask        uint32
}

func getVisualInfo(b []byte, v *VisualInfo) int {
	v.VisualId = Id(get32(b[0:]))
	v.Class = b[4]
	v.BitsPerRgbValue = b[5]
	v.ColormapEntries = get16(b[6:])
	v.RedMask = get32(b[8:])
	v.GreenMask = get32(b[12:])
	v.BlueMask = get32(b[16:])
	return 24
}

type DepthInfo struct {
	Depth      byte
	VisualsLen uint16
	Visuals    []VisualInfo
}

func getDepthInfo(b []byte, v *DepthInfo) int {
	v.Depth = b[0]
	v.VisualsLen = get16(b[2:])
	offset := 8
	v.Visuals = make([]VisualInfo, int(v.VisualsLen))
	for i := 0; i < int(v.VisualsLen); i++ {
		offset += getVisualInfo(b[offset:], &v.Visuals[i])
	}
	return offset
}

const (
	EventMaskNoEvent              = 0
	EventMaskKeyPress             = 1
	EventMaskKeyRelease           = 2
	EventMaskButtonPress          = 4
	EventMaskButtonRelease        = 8
	EventMaskEnterWindow          = 16
	EventMaskLeaveWindow          = 32
	EventMaskPointerMotion        = 64
	EventMaskPointerMotionHint    = 128
	EventMaskButton1Motion        = 256
	EventMaskButton2Motion        = 512
	EventMaskButton3Motion        = 1024
	EventMaskButton4Motion        = 2048
	EventMaskButton5Motion        = 4096
	EventMaskButtonMotion         = 8192
	EventMaskKeymapState          = 16384
	EventMaskExposure             = 32768
	EventMaskVisibilityChange     = 65536
	EventMaskStructureNotify      = 131072
	EventMaskResizeRedirect       = 262144
	EventMaskSubstructureNotify   = 524288
	EventMaskSubstructureRedirect = 1048576
	EventMaskFocusChange          = 2097152
	EventMaskPropertyChange       = 4194304
	EventMaskColorMapChange       = 8388608
	EventMaskOwnerGrabButton      = 16777216
)

const (
	BackingStoreNotUseful  = 0
	BackingStoreWhenMapped = 1
	BackingStoreAlways     = 2
)

type ScreenInfo struct {
	Root                Id
	DefaultColormap     Id
	WhitePixel          uint32
	BlackPixel          uint32
	CurrentInputMasks   uint32
	WidthInPixels       uint16
	HeightInPixels      uint16
	WidthInMillimeters  uint16
	HeightInMillimeters uint16
	MinInstalledMaps    uint16
	MaxInstalledMaps    uint16
	RootVisual          Id
	BackingStores       byte
	SaveUnders          byte
	RootDepth           byte
	AllowedDepthsLen    byte
	AllowedDepths       []DepthInfo
}

func getScreenInfo(b []byte, v *ScreenInfo) int {
	v.Root = Id(get32(b[0:]))
	v.DefaultColormap = Id(get32(b[4:]))
	v.WhitePixel = get32(b[8:])
	v.BlackPixel = get32(b[12:])
	v.CurrentInputMasks = get32(b[16:])
	v.WidthInPixels = get16(b[20:])
	v.HeightInPixels = get16(b[22:])
	v.WidthInMillimeters = get16(b[24:])
	v.HeightInMillimeters = get16(b[26:])
	v.MinInstalledMaps = get16(b[28:])
	v.MaxInstalledMaps = get16(b[30:])
	v.RootVisual = Id(get32(b[32:]))
	v.BackingStores = b[36]
	v.SaveUnders = b[37]
	v.RootDepth = b[38]
	v.AllowedDepthsLen = b[39]
	offset := 40
	v.AllowedDepths = make([]DepthInfo, int(v.AllowedDepthsLen))
	for i := 0; i < int(v.AllowedDepthsLen); i++ {
		offset += getDepthInfo(b[offset:], &v.AllowedDepths[i])
	}
	return offset
}

const (
	ImageOrderLSBFirst = 0
	ImageOrderMSBFirst = 1
)

type SetupInfo struct {
	Status                   byte
	ProtocolMajorVersion     uint16
	ProtocolMinorVersion     uint16
	Length                   uint16
	ReleaseNumber            uint32
	ResourceIdBase           uint32
	ResourceIdMask           uint32
	MotionBufferSize         uint32
	VendorLen                uint16
	MaximumRequestLength     uint16
	RootsLen                 byte
	PixmapFormatsLen         byte
	ImageByteOrder           byte
	BitmapFormatBitOrder     byte
	BitmapFormatScanlineUnit byte
	BitmapFormatScanlinePad  byte
	MinKeycode               byte
	MaxKeycode               byte
	Vendor                   []byte
	PixmapFormats            []Format
	Roots                    []ScreenInfo
}

func getSetupInfo(b []byte, v *SetupInfo) int {
	v.Status = b[0]
	v.ProtocolMajorVersion = get16(b[2:])
	v.ProtocolMinorVersion = get16(b[4:])
	v.Length = get16(b[6:])
	v.ReleaseNumber = get32(b[8:])
	v.ResourceIdBase = get32(b[12:])
	v.ResourceIdMask = get32(b[16:])
	v.MotionBufferSize = get32(b[20:])
	v.VendorLen = get16(b[24:])
	v.MaximumRequestLength = get16(b[26:])
	v.RootsLen = b[28]
	v.PixmapFormatsLen = b[29]
	v.ImageByteOrder = b[30]
	v.BitmapFormatBitOrder = b[31]
	v.BitmapFormatScanlineUnit = b[32]
	v.BitmapFormatScanlinePad = b[33]
	v.MinKeycode = b[34]
	v.MaxKeycode = b[35]
	offset := 40
	v.Vendor = make([]byte, int(v.VendorLen))
	copy(v.Vendor[0:len(v.Vendor)], b[offset:])
	offset += len(v.Vendor) * 1
	offset = pad(offset)
	v.PixmapFormats = make([]Format, int(v.PixmapFormatsLen))
	for i := 0; i < int(v.PixmapFormatsLen); i++ {
		offset += getFormat(b[offset:], &v.PixmapFormats[i])
	}
	offset = pad(offset)
	v.Roots = make([]ScreenInfo, int(v.RootsLen))
	for i := 0; i < int(v.RootsLen); i++ {
		offset += getScreenInfo(b[offset:], &v.Roots[i])
	}
	return offset
}

const (
	ModMaskShift   = 1
	ModMaskLock    = 2
	ModMaskControl = 4
	ModMask1       = 8
	ModMask2       = 16
	ModMask3       = 32
	ModMask4       = 64
	ModMask5       = 128
	ModMaskAny     = 32768
)

const (
	KeyButMaskShift   = 1
	KeyButMaskLock    = 2
	KeyButMaskControl = 4
	KeyButMaskMod1    = 8
	KeyButMaskMod2    = 16
	KeyButMaskMod3    = 32
	KeyButMaskMod4    = 64
	KeyButMaskMod5    = 128
	KeyButMaskButton1 = 256
	KeyButMaskButton2 = 512
	KeyButMaskButton3 = 1024
	KeyButMaskButton4 = 2048
	KeyButMaskButton5 = 4096
)

const (
	WindowNone = 0
)

const KeyPress = 2

type KeyPressEvent struct {
	Detail     byte
	Time       Timestamp
	Root       Id
	Event      Id
	Child      Id
	RootX      int16
	RootY      int16
	EventX     int16
	EventY     int16
	State      uint16
	SameScreen byte
}

func getKeyPressEvent(b []byte) KeyPressEvent {
	var v KeyPressEvent
	v.Detail = b[1]
	v.Time = Timestamp(get32(b[4:]))
	v.Root = Id(get32(b[8:]))
	v.Event = Id(get32(b[12:]))
	v.Child = Id(get32(b[16:]))
	v.RootX = int16(get16(b[20:]))
	v.RootY = int16(get16(b[22:]))
	v.EventX = int16(get16(b[24:]))
	v.EventY = int16(get16(b[26:]))
	v.State = get16(b[28:])
	v.SameScreen = b[30]
	return v
}

const KeyRelease = 3

type KeyReleaseEvent KeyPressEvent

func getKeyReleaseEvent(b []byte) KeyReleaseEvent {
	return (KeyReleaseEvent)(getKeyPressEvent(b))
}

const (
	ButtonMask1   = 256
	ButtonMask2   = 512
	ButtonMask3   = 1024
	ButtonMask4   = 2048
	ButtonMask5   = 4096
	ButtonMaskAny = 32768
)

const ButtonPress = 4

type ButtonPressEvent struct {
	Detail     byte
	Time       Timestamp
	Root       Id
	Event      Id
	Child      Id
	RootX      int16
	RootY      int16
	EventX     int16
	EventY     int16
	State      uint16
	SameScreen byte
}

func getButtonPressEvent(b []byte) ButtonPressEvent {
	var v ButtonPressEvent
	v.Detail = b[1]
	v.Time = Timestamp(get32(b[4:]))
	v.Root = Id(get32(b[8:]))
	v.Event = Id(get32(b[12:]))
	v.Child = Id(get32(b[16:]))
	v.RootX = int16(get16(b[20:]))
	v.RootY = int16(get16(b[22:]))
	v.EventX = int16(get16(b[24:]))
	v.EventY = int16(get16(b[26:]))
	v.State = get16(b[28:])
	v.SameScreen = b[30]
	return v
}

const ButtonRelease = 5

type ButtonReleaseEvent ButtonPressEvent

func getButtonReleaseEvent(b []byte) ButtonReleaseEvent {
	return (ButtonReleaseEvent)(getButtonPressEvent(b))
}

const (
	MotionNormal = 0
	MotionHint   = 1
)

const MotionNotify = 6

type MotionNotifyEvent struct {
	Detail     byte
	Time       Timestamp
	Root       Id
	Event      Id
	Child      Id
	RootX      int16
	RootY      int16
	EventX     int16
	EventY     int16
	State      uint16
	SameScreen byte
}

func getMotionNotifyEvent(b []byte) MotionNotifyEvent {
	var v MotionNotifyEvent
	v.Detail = b[1]
	v.Time = Timestamp(get32(b[4:]))
	v.Root = Id(get32(b[8:]))
	v.Event = Id(get32(b[12:]))
	v.Child = Id(get32(b[16:]))
	v.RootX = int16(get16(b[20:]))
	v.RootY = int16(get16(b[22:]))
	v.EventX = int16(get16(b[24:]))
	v.EventY = int16(get16(b[26:]))
	v.State = get16(b[28:])
	v.SameScreen = b[30]
	return v
}

const (
	NotifyDetailAncestor         = 0
	NotifyDetailVirtual          = 1
	NotifyDetailInferior         = 2
	NotifyDetailNonlinear        = 3
	NotifyDetailNonlinearVirtual = 4
	NotifyDetailPointer          = 5
	NotifyDetailPointerRoot      = 6
	NotifyDetailNone             = 7
)

const (
	NotifyModeNormal       = 0
	NotifyModeGrab         = 1
	NotifyModeUngrab       = 2
	NotifyModeWhileGrabbed = 3
)

const EnterNotify = 7

type EnterNotifyEvent struct {
	Detail          byte
	Time            Timestamp
	Root            Id
	Event           Id
	Child           Id
	RootX           int16
	RootY           int16
	EventX          int16
	EventY          int16
	State           uint16
	Mode            byte
	SameScreenFocus byte
}

func getEnterNotifyEvent(b []byte) EnterNotifyEvent {
	var v EnterNotifyEvent
	v.Detail = b[1]
	v.Time = Timestamp(get32(b[4:]))
	v.Root = Id(get32(b[8:]))
	v.Event = Id(get32(b[12:]))
	v.Child = Id(get32(b[16:]))
	v.RootX = int16(get16(b[20:]))
	v.RootY = int16(get16(b[22:]))
	v.EventX = int16(get16(b[24:]))
	v.EventY = int16(get16(b[26:]))
	v.State = get16(b[28:])
	v.Mode = b[30]
	v.SameScreenFocus = b[31]
	return v
}

const LeaveNotify = 8

type LeaveNotifyEvent EnterNotifyEvent

func getLeaveNotifyEvent(b []byte) LeaveNotifyEvent {
	return (LeaveNotifyEvent)(getEnterNotifyEvent(b))
}

const FocusIn = 9

type FocusInEvent struct {
	Detail byte
	Event  Id
	Mode   byte
}

func getFocusInEvent(b []byte) FocusInEvent {
	var v FocusInEvent
	v.Detail = b[1]
	v.Event = Id(get32(b[4:]))
	v.Mode = b[8]
	return v
}

const FocusOut = 10

type FocusOutEvent FocusInEvent

func getFocusOutEvent(b []byte) FocusOutEvent { return (FocusOutEvent)(getFocusInEvent(b)) }

const KeymapNotify = 11

type KeymapNotifyEvent struct {
	Keys [31]byte
}

func getKeymapNotifyEvent(b []byte) KeymapNotifyEvent {
	var v KeymapNotifyEvent
	copy(v.Keys[0:31], b[1:])
	return v
}

const Expose = 12

type ExposeEvent struct {
	Window Id
	X      uint16
	Y      uint16
	Width  uint16
	Height uint16
	Count  uint16
}

func getExposeEvent(b []byte) ExposeEvent {
	var v ExposeEvent
	v.Window = Id(get32(b[4:]))
	v.X = get16(b[8:])
	v.Y = get16(b[10:])
	v.Width = get16(b[12:])
	v.Height = get16(b[14:])
	v.Count = get16(b[16:])
	return v
}

const GraphicsExposure = 13

type GraphicsExposureEvent struct {
	Drawable    Id
	X           uint16
	Y           uint16
	Width       uint16
	Height      uint16
	MinorOpcode uint16
	Count       uint16
	MajorOpcode byte
}

func getGraphicsExposureEvent(b []byte) GraphicsExposureEvent {
	var v GraphicsExposureEvent
	v.Drawable = Id(get32(b[4:]))
	v.X = get16(b[8:])
	v.Y = get16(b[10:])
	v.Width = get16(b[12:])
	v.Height = get16(b[14:])
	v.MinorOpcode = get16(b[16:])
	v.Count = get16(b[18:])
	v.MajorOpcode = b[20]
	return v
}

const NoExposure = 14

type NoExposureEvent struct {
	Drawable    Id
	MinorOpcode uint16
	MajorOpcode byte
}

func getNoExposureEvent(b []byte) NoExposureEvent {
	var v NoExposureEvent
	v.Drawable = Id(get32(b[4:]))
	v.MinorOpcode = get16(b[8:])
	v.MajorOpcode = b[10]
	return v
}

const (
	VisibilityUnobscured        = 0
	VisibilityPartiallyObscured = 1
	VisibilityFullyObscured     = 2
)

const VisibilityNotify = 15

type VisibilityNotifyEvent struct {
	Window Id
	State  byte
}

func getVisibilityNotifyEvent(b []byte) VisibilityNotifyEvent {
	var v VisibilityNotifyEvent
	v.Window = Id(get32(b[4:]))
	v.State = b[8]
	return v
}

const CreateNotify = 16

type CreateNotifyEvent struct {
	Parent           Id
	Window           Id
	X                int16
	Y                int16
	Width            uint16
	Height           uint16
	BorderWidth      uint16
	OverrideRedirect byte
}

func getCreateNotifyEvent(b []byte) CreateNotifyEvent {
	var v CreateNotifyEvent
	v.Parent = Id(get32(b[4:]))
	v.Window = Id(get32(b[8:]))
	v.X = int16(get16(b[12:]))
	v.Y = int16(get16(b[14:]))
	v.Width = get16(b[16:])
	v.Height = get16(b[18:])
	v.BorderWidth = get16(b[20:])
	v.OverrideRedirect = b[22]
	return v
}

const DestroyNotify = 17

type DestroyNotifyEvent struct {
	Event  Id
	Window Id
}

func getDestroyNotifyEvent(b []byte) DestroyNotifyEvent {
	var v DestroyNotifyEvent
	v.Event = Id(get32(b[4:]))
	v.Window = Id(get32(b[8:]))
	return v
}

const UnmapNotify = 18

type UnmapNotifyEvent struct {
	Event         Id
	Window        Id
	FromConfigure byte
}

func getUnmapNotifyEvent(b []byte) UnmapNotifyEvent {
	var v UnmapNotifyEvent
	v.Event = Id(get32(b[4:]))
	v.Window = Id(get32(b[8:]))
	v.FromConfigure = b[12]
	return v
}

const MapNotify = 19

type MapNotifyEvent struct {
	Event            Id
	Window           Id
	OverrideRedirect byte
}

func getMapNotifyEvent(b []byte) MapNotifyEvent {
	var v MapNotifyEvent
	v.Event = Id(get32(b[4:]))
	v.Window = Id(get32(b[8:]))
	v.OverrideRedirect = b[12]
	return v
}

const MapRequest = 20

type MapRequestEvent struct {
	Parent Id
	Window Id
}

func getMapRequestEvent(b []byte) MapRequestEvent {
	var v MapRequestEvent
	v.Parent = Id(get32(b[4:]))
	v.Window = Id(get32(b[8:]))
	return v
}

const ReparentNotify = 21

type ReparentNotifyEvent struct {
	Event            Id
	Window           Id
	Parent           Id
	X                int16
	Y                int16
	OverrideRedirect byte
}

func getReparentNotifyEvent(b []byte) ReparentNotifyEvent {
	var v ReparentNotifyEvent
	v.Event = Id(get32(b[4:]))
	v.Window = Id(get32(b[8:]))
	v.Parent = Id(get32(b[12:]))
	v.X = int16(get16(b[16:]))
	v.Y = int16(get16(b[18:]))
	v.OverrideRedirect = b[20]
	return v
}

const ConfigureNotify = 22

type ConfigureNotifyEvent struct {
	Event            Id
	Window           Id
	AboveSibling     Id
	X                int16
	Y                int16
	Width            uint16
	Height           uint16
	BorderWidth      uint16
	OverrideRedirect byte
}

func getConfigureNotifyEvent(b []byte) ConfigureNotifyEvent {
	var v ConfigureNotifyEvent
	v.Event = Id(get32(b[4:]))
	v.Window = Id(get32(b[8:]))
	v.AboveSibling = Id(get32(b[12:]))
	v.X = int16(get16(b[16:]))
	v.Y = int16(get16(b[18:]))
	v.Width = get16(b[20:])
	v.Height = get16(b[22:])
	v.BorderWidth = get16(b[24:])
	v.OverrideRedirect = b[26]
	return v
}

const ConfigureRequest = 23

type ConfigureRequestEvent struct {
	StackMode   byte
	Parent      Id
	Window      Id
	Sibling     Id
	X           int16
	Y           int16
	Width       uint16
	Height      uint16
	BorderWidth uint16
	ValueMask   uint16
}

func getConfigureRequestEvent(b []byte) ConfigureRequestEvent {
	var v ConfigureRequestEvent
	v.StackMode = b[1]
	v.Parent = Id(get32(b[4:]))
	v.Window = Id(get32(b[8:]))
	v.Sibling = Id(get32(b[12:]))
	v.X = int16(get16(b[16:]))
	v.Y = int16(get16(b[18:]))
	v.Width = get16(b[20:])
	v.Height = get16(b[22:])
	v.BorderWidth = get16(b[24:])
	v.ValueMask = get16(b[26:])
	return v
}

const GravityNotify = 24

type GravityNotifyEvent struct {
	Event  Id
	Window Id
	X      int16
	Y      int16
}

func getGravityNotifyEvent(b []byte) GravityNotifyEvent {
	var v GravityNotifyEvent
	v.Event = Id(get32(b[4:]))
	v.Window = Id(get32(b[8:]))
	v.X = int16(get16(b[12:]))
	v.Y = int16(get16(b[14:]))
	return v
}

const ResizeRequest = 25

type ResizeRequestEvent struct {
	Window Id
	Width  uint16
	Height uint16
}

func getResizeRequestEvent(b []byte) ResizeRequestEvent {
	var v ResizeRequestEvent
	v.Window = Id(get32(b[4:]))
	v.Width = get16(b[8:])
	v.Height = get16(b[10:])
	return v
}

const (
	PlaceOnTop    = 0
	PlaceOnBottom = 1
)

const CirculateNotify = 26

type CirculateNotifyEvent struct {
	Event  Id
	Window Id
	Place  byte
}

func getCirculateNotifyEvent(b []byte) CirculateNotifyEvent {
	var v CirculateNotifyEvent
	v.Event = Id(get32(b[4:]))
	v.Window = Id(get32(b[8:]))
	v.Place = b[16]
	return v
}

const CirculateRequest = 27

type CirculateRequestEvent CirculateNotifyEvent

func getCirculateRequestEvent(b []byte) CirculateRequestEvent {
	return (CirculateRequestEvent)(getCirculateNotifyEvent(b))
}

const (
	PropertyNewValue = 0
	PropertyDelete   = 1
)

const PropertyNotify = 28

type PropertyNotifyEvent struct {
	Window Id
	Atom   Id
	Time   Timestamp
	State  byte
}

func getPropertyNotifyEvent(b []byte) PropertyNotifyEvent {
	var v PropertyNotifyEvent
	v.Window = Id(get32(b[4:]))
	v.Atom = Id(get32(b[8:]))
	v.Time = Timestamp(get32(b[12:]))
	v.State = b[16]
	return v
}

const SelectionClear = 29

type SelectionClearEvent struct {
	Time      Timestamp
	Owner     Id
	Selection Id
}

func getSelectionClearEvent(b []byte) SelectionClearEvent {
	var v SelectionClearEvent
	v.Time = Timestamp(get32(b[4:]))
	v.Owner = Id(get32(b[8:]))
	v.Selection = Id(get32(b[12:]))
	return v
}

const (
	TimeCurrentTime = 0
)

const (
	AtomNone               = 0
	AtomAny                = 0
	AtomPrimary            = 1
	AtomSecondary          = 2
	AtomArc                = 3
	AtomAtom               = 4
	AtomBitmap             = 5
	AtomCardinal           = 6
	AtomColormap           = 7
	AtomCursor             = 8
	AtomCutBuffer0         = 9
	AtomCutBuffer1         = 10
	AtomCutBuffer2         = 11
	AtomCutBuffer3         = 12
	AtomCutBuffer4         = 13
	AtomCutBuffer5         = 14
	AtomCutBuffer6         = 15
	AtomCutBuffer7         = 16
	AtomDrawable           = 17
	AtomFont               = 18
	AtomInteger            = 19
	AtomPixmap             = 20
	AtomPoint              = 21
	AtomRectangle          = 22
	AtomResourceManager    = 23
	AtomRgbColorMap        = 24
	AtomRgbBestMap         = 25
	AtomRgbBlueMap         = 26
	AtomRgbDefaultMap      = 27
	AtomRgbGrayMap         = 28
	AtomRgbGreenMap        = 29
	AtomRgbRedMap          = 30
	AtomString             = 31
	AtomVisualid           = 32
	AtomWindow             = 33
	AtomWmCommand          = 34
	AtomWmHints            = 35
	AtomWmClientMachine    = 36
	AtomWmIconName         = 37
	AtomWmIconSize         = 38
	AtomWmName             = 39
	AtomWmNormalHints      = 40
	AtomWmSizeHints        = 41
	AtomWmZoomHints        = 42
	AtomMinSpace           = 43
	AtomNormSpace          = 44
	AtomMaxSpace           = 45
	AtomEndSpace           = 46
	AtomSuperscriptX       = 47
	AtomSuperscriptY       = 48
	AtomSubscriptX         = 49
	AtomSubscriptY         = 50
	AtomUnderlinePosition  = 51
	AtomUnderlineThickness = 52
	AtomStrikeoutAscent    = 53
	AtomStrikeoutDescent   = 54
	AtomItalicAngle        = 55
	AtomXHeight            = 56
	AtomQuadWidth          = 57
	AtomWeight             = 58
	AtomPointSize          = 59
	AtomResolution         = 60
	AtomCopyright          = 61
	AtomNotice             = 62
	AtomFontName           = 63
	AtomFamilyName         = 64
	AtomFullName           = 65
	AtomCapHeight          = 66
	AtomWmClass            = 67
	AtomWmTransientFor     = 68
)

const SelectionRequest = 30

type SelectionRequestEvent struct {
	Time      Timestamp
	Owner     Id
	Requestor Id
	Selection Id
	Target    Id
	Property  Id
}

func getSelectionRequestEvent(b []byte) SelectionRequestEvent {
	var v SelectionRequestEvent
	v.Time = Timestamp(get32(b[4:]))
	v.Owner = Id(get32(b[8:]))
	v.Requestor = Id(get32(b[12:]))
	v.Selection = Id(get32(b[16:]))
	v.Target = Id(get32(b[20:]))
	v.Property = Id(get32(b[24:]))
	return v
}

const SelectionNotify = 31

type SelectionNotifyEvent struct {
	Time      Timestamp
	Requestor Id
	Selection Id
	Target    Id
	Property  Id
}

func getSelectionNotifyEvent(b []byte) SelectionNotifyEvent {
	var v SelectionNotifyEvent
	v.Time = Timestamp(get32(b[4:]))
	v.Requestor = Id(get32(b[8:]))
	v.Selection = Id(get32(b[12:]))
	v.Target = Id(get32(b[16:]))
	v.Property = Id(get32(b[20:]))
	return v
}

const (
	ColormapStateUninstalled = 0
	ColormapStateInstalled   = 1
)

const (
	ColormapNone = 0
)

const ColormapNotify = 32

type ColormapNotifyEvent struct {
	Window   Id
	Colormap Id
	New      byte
	State    byte
}

func getColormapNotifyEvent(b []byte) ColormapNotifyEvent {
	var v ColormapNotifyEvent
	v.Window = Id(get32(b[4:]))
	v.Colormap = Id(get32(b[8:]))
	v.New = b[12]
	v.State = b[13]
	return v
}

const ClientMessage = 33

type ClientMessageEvent struct {
	Format byte
	Window Id
	Type   Id
	Data   ClientMessageData
}

func getClientMessageEvent(b []byte) ClientMessageEvent {
	var v ClientMessageEvent
	v.Format = b[1]
	v.Window = Id(get32(b[4:]))
	v.Type = Id(get32(b[8:]))
	getClientMessageData(b[12:], &v.Data)
	return v
}

const (
	MappingModifier = 0
	MappingKeyboard = 1
	MappingPointer  = 2
)

const MappingNotify = 34

type MappingNotifyEvent struct {
	Request      byte
	FirstKeycode byte
	Count        byte
}

func getMappingNotifyEvent(b []byte) MappingNotifyEvent {
	var v MappingNotifyEvent
	v.Request = b[4]
	v.FirstKeycode = b[5]
	v.Count = b[6]
	return v
}

const BadRequest = 1

const BadValue = 2

const BadWindow = 3

const BadPixmap = 4

const BadAtom = 5

const BadCursor = 6

const BadFont = 7

const BadMatch = 8

const BadDrawable = 9

const BadAccess = 10

const BadAlloc = 11

const BadColormap = 12

const BadGContext = 13

const BadIDChoice = 14

const BadName = 15

const BadLength = 16

const BadImplementation = 17

const (
	WindowClassCopyFromParent = 0
	WindowClassInputOutput    = 1
	WindowClassInputOnly      = 2
)

const (
	CWBackPixmap       = 1
	CWBackPixel        = 2
	CWBorderPixmap     = 4
	CWBorderPixel      = 8
	CWBitGravity       = 16
	CWWinGravity       = 32
	CWBackingStore     = 64
	CWBackingPlanes    = 128
	CWBackingPixel     = 256
	CWOverrideRedirect = 512
	CWSaveUnder        = 1024
	CWEventMask        = 2048
	CWDontPropagate    = 4096
	CWColormap         = 8192
	CWCursor           = 16384
)

const (
	BackPixmapNone           = 0
	BackPixmapParentRelative = 1
)

const (
	GravityBitForget = 0
	GravityWinUnmap  = 0
	GravityNorthWest = 1
	GravityNorth     = 2
	GravityNorthEast = 3
	GravityWest      = 4
	GravityCenter    = 5
	GravityEast      = 6
	GravitySouthWest = 7
	GravitySouth     = 8
	GravitySouthEast = 9
	GravityStatic    = 10
)

func (c *Conn) CreateWindow(Depth byte, Wid Id, Parent Id, X int16, Y int16, Width uint16, Height uint16, BorderWidth uint16, Class uint16, Visual Id, ValueMask uint32, ValueList []uint32) {
	b := c.scratch[0:32]
	n := 32
	n += pad(popCount(int(ValueMask)) * 4)
	put16(b[2:], uint16(n/4))
	b[0] = 1
	b[1] = Depth
	put32(b[4:], uint32(Wid))
	put32(b[8:], uint32(Parent))
	put16(b[12:], uint16(X))
	put16(b[14:], uint16(Y))
	put16(b[16:], Width)
	put16(b[18:], Height)
	put16(b[20:], BorderWidth)
	put16(b[22:], Class)
	put32(b[24:], uint32(Visual))
	put32(b[28:], ValueMask)
	c.sendRequest(b)
	c.sendUInt32List(ValueList[0:popCount(int(ValueMask))])
}

func (c *Conn) ChangeWindowAttributes(Window Id, ValueMask uint32, ValueList []uint32) {
	b := c.scratch[0:12]
	n := 12
	n += pad(popCount(int(ValueMask)) * 4)
	put16(b[2:], uint16(n/4))
	b[0] = 2
	put32(b[4:], uint32(Window))
	put32(b[8:], ValueMask)
	c.sendRequest(b)
	c.sendUInt32List(ValueList[0:popCount(int(ValueMask))])
}

const (
	MapStateUnmapped   = 0
	MapStateUnviewable = 1
	MapStateViewable   = 2
)

func (c *Conn) GetWindowAttributesRequest(Window Id) Cookie {
	b := c.scratch[0:8]
	put16(b[2:], 2)
	b[0] = 3
	put32(b[4:], uint32(Window))
	return c.sendRequest(b)
}

func (c *Conn) GetWindowAttributes(Window Id) (*GetWindowAttributesReply, os.Error) {
	return c.GetWindowAttributesReply(c.GetWindowAttributesRequest(Window))
}

type GetWindowAttributesReply struct {
	BackingStore       byte
	Visual             Id
	Class              uint16
	BitGravity         byte
	WinGravity         byte
	BackingPlanes      uint32
	BackingPixel       uint32
	SaveUnder          byte
	MapIsInstalled     byte
	MapState           byte
	OverrideRedirect   byte
	Colormap           Id
	AllEventMasks      uint32
	YourEventMask      uint32
	DoNotPropagateMask uint16
}

func (c *Conn) GetWindowAttributesReply(cookie Cookie) (*GetWindowAttributesReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(GetWindowAttributesReply)
	v.BackingStore = b[1]
	v.Visual = Id(get32(b[8:]))
	v.Class = get16(b[12:])
	v.BitGravity = b[14]
	v.WinGravity = b[15]
	v.BackingPlanes = get32(b[16:])
	v.BackingPixel = get32(b[20:])
	v.SaveUnder = b[24]
	v.MapIsInstalled = b[25]
	v.MapState = b[26]
	v.OverrideRedirect = b[27]
	v.Colormap = Id(get32(b[28:]))
	v.AllEventMasks = get32(b[32:])
	v.YourEventMask = get32(b[36:])
	v.DoNotPropagateMask = get16(b[40:])
	return v, nil
}

func (c *Conn) DestroyWindow(Window Id) {
	b := c.scratch[0:8]
	put16(b[2:], 2)
	b[0] = 4
	put32(b[4:], uint32(Window))
	c.sendRequest(b)
}

func (c *Conn) DestroySubwindows(Window Id) {
	b := c.scratch[0:8]
	put16(b[2:], 2)
	b[0] = 5
	put32(b[4:], uint32(Window))
	c.sendRequest(b)
}

const (
	SetModeInsert = 0
	SetModeDelete = 1
)

func (c *Conn) ChangeSaveSet(Mode byte, Window Id) {
	b := c.scratch[0:8]
	put16(b[2:], 2)
	b[0] = 6
	b[1] = Mode
	put32(b[4:], uint32(Window))
	c.sendRequest(b)
}

func (c *Conn) ReparentWindow(Window Id, Parent Id, X int16, Y int16) {
	b := c.scratch[0:16]
	put16(b[2:], 4)
	b[0] = 7
	put32(b[4:], uint32(Window))
	put32(b[8:], uint32(Parent))
	put16(b[12:], uint16(X))
	put16(b[14:], uint16(Y))
	c.sendRequest(b)
}

func (c *Conn) MapWindow(Window Id) {
	b := c.scratch[0:8]
	put16(b[2:], 2)
	b[0] = 8
	put32(b[4:], uint32(Window))
	c.sendRequest(b)
}

func (c *Conn) MapSubwindows(Window Id) {
	b := c.scratch[0:8]
	put16(b[2:], 2)
	b[0] = 9
	put32(b[4:], uint32(Window))
	c.sendRequest(b)
}

func (c *Conn) UnmapWindow(Window Id) {
	b := c.scratch[0:8]
	put16(b[2:], 2)
	b[0] = 10
	put32(b[4:], uint32(Window))
	c.sendRequest(b)
}

func (c *Conn) UnmapSubwindows(Window Id) {
	b := c.scratch[0:8]
	put16(b[2:], 2)
	b[0] = 11
	put32(b[4:], uint32(Window))
	c.sendRequest(b)
}

const (
	ConfigWindowX           = 1
	ConfigWindowY           = 2
	ConfigWindowWidth       = 4
	ConfigWindowHeight      = 8
	ConfigWindowBorderWidth = 16
	ConfigWindowSibling     = 32
	ConfigWindowStackMode   = 64
)

const (
	StackModeAbove    = 0
	StackModeBelow    = 1
	StackModeTopIf    = 2
	StackModeBottomIf = 3
	StackModeOpposite = 4
)

func (c *Conn) ConfigureWindow(Window Id, ValueMask uint16, ValueList []uint32) {
	b := c.scratch[0:12]
	n := 12
	n += pad(popCount(int(ValueMask)) * 4)
	put16(b[2:], uint16(n/4))
	b[0] = 12
	put32(b[4:], uint32(Window))
	put16(b[8:], ValueMask)
	c.sendRequest(b)
	c.sendUInt32List(ValueList[0:popCount(int(ValueMask))])
}

const (
	CirculateRaiseLowest  = 0
	CirculateLowerHighest = 1
)

func (c *Conn) CirculateWindow(Direction byte, Window Id) {
	b := c.scratch[0:8]
	put16(b[2:], 2)
	b[0] = 13
	b[1] = Direction
	put32(b[4:], uint32(Window))
	c.sendRequest(b)
}

func (c *Conn) GetGeometryRequest(Drawable Id) Cookie {
	b := c.scratch[0:8]
	put16(b[2:], 2)
	b[0] = 14
	put32(b[4:], uint32(Drawable))
	return c.sendRequest(b)
}

func (c *Conn) GetGeometry(Drawable Id) (*GetGeometryReply, os.Error) {
	return c.GetGeometryReply(c.GetGeometryRequest(Drawable))
}

type GetGeometryReply struct {
	Depth       byte
	Root        Id
	X           int16
	Y           int16
	Width       uint16
	Height      uint16
	BorderWidth uint16
}

func (c *Conn) GetGeometryReply(cookie Cookie) (*GetGeometryReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(GetGeometryReply)
	v.Depth = b[1]
	v.Root = Id(get32(b[8:]))
	v.X = int16(get16(b[12:]))
	v.Y = int16(get16(b[14:]))
	v.Width = get16(b[16:])
	v.Height = get16(b[18:])
	v.BorderWidth = get16(b[20:])
	return v, nil
}

func (c *Conn) QueryTreeRequest(Window Id) Cookie {
	b := c.scratch[0:8]
	put16(b[2:], 2)
	b[0] = 15
	put32(b[4:], uint32(Window))
	return c.sendRequest(b)
}

func (c *Conn) QueryTree(Window Id) (*QueryTreeReply, os.Error) {
	return c.QueryTreeReply(c.QueryTreeRequest(Window))
}

type QueryTreeReply struct {
	Root        Id
	Parent      Id
	ChildrenLen uint16
	Children    []Id
}

func (c *Conn) QueryTreeReply(cookie Cookie) (*QueryTreeReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(QueryTreeReply)
	v.Root = Id(get32(b[8:]))
	v.Parent = Id(get32(b[12:]))
	v.ChildrenLen = get16(b[16:])
	offset := 32
	v.Children = make([]Id, int(v.ChildrenLen))
	for i := 0; i < len(v.Children); i++ {
		v.Children[i] = Id(get32(b[offset+i*4:]))
	}
	offset += len(v.Children) * 4
	return v, nil
}

func (c *Conn) InternAtomRequest(OnlyIfExists byte, Name string) Cookie {
	b := c.scratch[0:8]
	n := 8
	n += pad(len(Name) * 1)
	put16(b[2:], uint16(n/4))
	b[0] = 16
	b[1] = OnlyIfExists
	put16(b[4:], uint16(len(Name)))
	cookie := c.sendRequest(b)
	c.sendString(Name)
	return cookie
}

func (c *Conn) InternAtom(OnlyIfExists byte, Name string) (*InternAtomReply, os.Error) {
	return c.InternAtomReply(c.InternAtomRequest(OnlyIfExists, Name))
}

type InternAtomReply struct {
	Atom Id
}

func (c *Conn) InternAtomReply(cookie Cookie) (*InternAtomReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(InternAtomReply)
	v.Atom = Id(get32(b[8:]))
	return v, nil
}

func (c *Conn) GetAtomNameRequest(Atom Id) Cookie {
	b := c.scratch[0:8]
	put16(b[2:], 2)
	b[0] = 17
	put32(b[4:], uint32(Atom))
	return c.sendRequest(b)
}

func (c *Conn) GetAtomName(Atom Id) (*GetAtomNameReply, os.Error) {
	return c.GetAtomNameReply(c.GetAtomNameRequest(Atom))
}

type GetAtomNameReply struct {
	NameLen uint16
	Name    []byte
}

func (c *Conn) GetAtomNameReply(cookie Cookie) (*GetAtomNameReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(GetAtomNameReply)
	v.NameLen = get16(b[8:])
	offset := 32
	v.Name = make([]byte, int(v.NameLen))
	copy(v.Name[0:len(v.Name)], b[offset:])
	offset += len(v.Name) * 1
	return v, nil
}

const (
	PropModeReplace = 0
	PropModePrepend = 1
	PropModeAppend  = 2
)

func (c *Conn) ChangeProperty(Mode byte, Window Id, Property Id, Type Id, Format byte, Data []byte) {
	b := c.scratch[0:24]
	n := 24
	n += pad(((len(Data) * int(Format)) / 8) * 1)
	put16(b[2:], uint16(n/4))
	b[0] = 18
	b[1] = Mode
	put32(b[4:], uint32(Window))
	put32(b[8:], uint32(Property))
	put32(b[12:], uint32(Type))
	b[16] = Format
	put32(b[20:], uint32(len(Data)))
	c.sendRequest(b)
	c.sendBytes(Data[0:((len(Data) * int(Format)) / 8)])
}

func (c *Conn) DeleteProperty(Window Id, Property Id) {
	b := c.scratch[0:12]
	put16(b[2:], 3)
	b[0] = 19
	put32(b[4:], uint32(Window))
	put32(b[8:], uint32(Property))
	c.sendRequest(b)
}

const (
	GetPropertyTypeAny = 0
)

func (c *Conn) GetPropertyRequest(Delete byte, Window Id, Property Id, Type Id, LongOffset uint32, LongLength uint32) Cookie {
	b := c.scratch[0:24]
	put16(b[2:], 6)
	b[0] = 20
	b[1] = Delete
	put32(b[4:], uint32(Window))
	put32(b[8:], uint32(Property))
	put32(b[12:], uint32(Type))
	put32(b[16:], LongOffset)
	put32(b[20:], LongLength)
	return c.sendRequest(b)
}

func (c *Conn) GetProperty(Delete byte, Window Id, Property Id, Type Id, LongOffset uint32, LongLength uint32) (*GetPropertyReply, os.Error) {
	return c.GetPropertyReply(c.GetPropertyRequest(Delete, Window, Property, Type, LongOffset, LongLength))
}

type GetPropertyReply struct {
	Format     byte
	Type       Id
	BytesAfter uint32
	ValueLen   uint32
	Value      []byte
}

func (c *Conn) GetPropertyReply(cookie Cookie) (*GetPropertyReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(GetPropertyReply)
	v.Format = b[1]
	v.Type = Id(get32(b[8:]))
	v.BytesAfter = get32(b[12:])
	v.ValueLen = get32(b[16:])
	offset := 32
	v.Value = make([]byte, (int(v.ValueLen) * (int(v.Format) / 8)))
	copy(v.Value[0:len(v.Value)], b[offset:])
	offset += len(v.Value) * 1
	return v, nil
}

func (c *Conn) ListPropertiesRequest(Window Id) Cookie {
	b := c.scratch[0:8]
	put16(b[2:], 2)
	b[0] = 21
	put32(b[4:], uint32(Window))
	return c.sendRequest(b)
}

func (c *Conn) ListProperties(Window Id) (*ListPropertiesReply, os.Error) {
	return c.ListPropertiesReply(c.ListPropertiesRequest(Window))
}

type ListPropertiesReply struct {
	AtomsLen uint16
	Atoms    []Id
}

func (c *Conn) ListPropertiesReply(cookie Cookie) (*ListPropertiesReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(ListPropertiesReply)
	v.AtomsLen = get16(b[8:])
	offset := 32
	v.Atoms = make([]Id, int(v.AtomsLen))
	for i := 0; i < len(v.Atoms); i++ {
		v.Atoms[i] = Id(get32(b[offset+i*4:]))
	}
	offset += len(v.Atoms) * 4
	return v, nil
}

func (c *Conn) SetSelectionOwner(Owner Id, Selection Id, Time Timestamp) {
	b := c.scratch[0:16]
	put16(b[2:], 4)
	b[0] = 22
	put32(b[4:], uint32(Owner))
	put32(b[8:], uint32(Selection))
	put32(b[12:], uint32(Time))
	c.sendRequest(b)
}

func (c *Conn) GetSelectionOwnerRequest(Selection Id) Cookie {
	b := c.scratch[0:8]
	put16(b[2:], 2)
	b[0] = 23
	put32(b[4:], uint32(Selection))
	return c.sendRequest(b)
}

func (c *Conn) GetSelectionOwner(Selection Id) (*GetSelectionOwnerReply, os.Error) {
	return c.GetSelectionOwnerReply(c.GetSelectionOwnerRequest(Selection))
}

type GetSelectionOwnerReply struct {
	Owner Id
}

func (c *Conn) GetSelectionOwnerReply(cookie Cookie) (*GetSelectionOwnerReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(GetSelectionOwnerReply)
	v.Owner = Id(get32(b[8:]))
	return v, nil
}

func (c *Conn) ConvertSelection(Requestor Id, Selection Id, Target Id, Property Id, Time Timestamp) {
	b := c.scratch[0:24]
	put16(b[2:], 6)
	b[0] = 24
	put32(b[4:], uint32(Requestor))
	put32(b[8:], uint32(Selection))
	put32(b[12:], uint32(Target))
	put32(b[16:], uint32(Property))
	put32(b[20:], uint32(Time))
	c.sendRequest(b)
}

const (
	SendEventDestPointerWindow = 0
	SendEventDestItemFocus     = 1
)

func (c *Conn) SendEvent(Propagate byte, Destination Id, EventMask uint32, Event []byte) {
	b := make([]byte, 44)
	put16(b[2:], 11)
	b[0] = 25
	b[1] = Propagate
	put32(b[4:], uint32(Destination))
	put32(b[8:], EventMask)
	copy(b[12:44], Event)
	c.sendRequest(b)
}

const (
	GrabModeSync  = 0
	GrabModeAsync = 1
)

const (
	GrabStatusSuccess        = 0
	GrabStatusAlreadyGrabbed = 1
	GrabStatusInvalidTime    = 2
	GrabStatusNotViewable    = 3
	GrabStatusFrozen         = 4
)

const (
	CursorNone = 0
)

func (c *Conn) GrabPointerRequest(OwnerEvents byte, GrabWindow Id, EventMask uint16, PointerMode byte, KeyboardMode byte, ConfineTo Id, Cursor Id, Time Timestamp) Cookie {
	b := c.scratch[0:24]
	put16(b[2:], 6)
	b[0] = 26
	b[1] = OwnerEvents
	put32(b[4:], uint32(GrabWindow))
	put16(b[8:], EventMask)
	b[10] = PointerMode
	b[11] = KeyboardMode
	put32(b[12:], uint32(ConfineTo))
	put32(b[16:], uint32(Cursor))
	put32(b[20:], uint32(Time))
	return c.sendRequest(b)
}

func (c *Conn) GrabPointer(OwnerEvents byte, GrabWindow Id, EventMask uint16, PointerMode byte, KeyboardMode byte, ConfineTo Id, Cursor Id, Time Timestamp) (*GrabPointerReply, os.Error) {
	return c.GrabPointerReply(c.GrabPointerRequest(OwnerEvents, GrabWindow, EventMask, PointerMode, KeyboardMode, ConfineTo, Cursor, Time))
}

type GrabPointerReply struct {
	Status byte
}

func (c *Conn) GrabPointerReply(cookie Cookie) (*GrabPointerReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(GrabPointerReply)
	v.Status = b[1]
	return v, nil
}

func (c *Conn) UngrabPointer(Time Timestamp) {
	b := c.scratch[0:8]
	put16(b[2:], 2)
	b[0] = 27
	put32(b[4:], uint32(Time))
	c.sendRequest(b)
}

const (
	ButtonIndexAny = 0
	ButtonIndex1   = 1
	ButtonIndex2   = 2
	ButtonIndex3   = 3
	ButtonIndex4   = 4
	ButtonIndex5   = 5
)

func (c *Conn) GrabButton(OwnerEvents byte, GrabWindow Id, EventMask uint16, PointerMode byte, KeyboardMode byte, ConfineTo Id, Cursor Id, Button byte, Modifiers uint16) {
	b := c.scratch[0:24]
	put16(b[2:], 6)
	b[0] = 28
	b[1] = OwnerEvents
	put32(b[4:], uint32(GrabWindow))
	put16(b[8:], EventMask)
	b[10] = PointerMode
	b[11] = KeyboardMode
	put32(b[12:], uint32(ConfineTo))
	put32(b[16:], uint32(Cursor))
	b[20] = Button
	put16(b[22:], Modifiers)
	c.sendRequest(b)
}

func (c *Conn) UngrabButton(Button byte, GrabWindow Id, Modifiers uint16) {
	b := c.scratch[0:12]
	put16(b[2:], 3)
	b[0] = 29
	b[1] = Button
	put32(b[4:], uint32(GrabWindow))
	put16(b[8:], Modifiers)
	c.sendRequest(b)
}

func (c *Conn) ChangeActivePointerGrab(Cursor Id, Time Timestamp, EventMask uint16) {
	b := c.scratch[0:16]
	put16(b[2:], 4)
	b[0] = 30
	put32(b[4:], uint32(Cursor))
	put32(b[8:], uint32(Time))
	put16(b[12:], EventMask)
	c.sendRequest(b)
}

func (c *Conn) GrabKeyboardRequest(OwnerEvents byte, GrabWindow Id, Time Timestamp, PointerMode byte, KeyboardMode byte) Cookie {
	b := c.scratch[0:16]
	put16(b[2:], 4)
	b[0] = 31
	b[1] = OwnerEvents
	put32(b[4:], uint32(GrabWindow))
	put32(b[8:], uint32(Time))
	b[12] = PointerMode
	b[13] = KeyboardMode
	return c.sendRequest(b)
}

func (c *Conn) GrabKeyboard(OwnerEvents byte, GrabWindow Id, Time Timestamp, PointerMode byte, KeyboardMode byte) (*GrabKeyboardReply, os.Error) {
	return c.GrabKeyboardReply(c.GrabKeyboardRequest(OwnerEvents, GrabWindow, Time, PointerMode, KeyboardMode))
}

type GrabKeyboardReply struct {
	Status byte
}

func (c *Conn) GrabKeyboardReply(cookie Cookie) (*GrabKeyboardReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(GrabKeyboardReply)
	v.Status = b[1]
	return v, nil
}

func (c *Conn) UngrabKeyboard(Time Timestamp) {
	b := c.scratch[0:8]
	put16(b[2:], 2)
	b[0] = 32
	put32(b[4:], uint32(Time))
	c.sendRequest(b)
}

const (
	GrabAny = 0
)

func (c *Conn) GrabKey(OwnerEvents byte, GrabWindow Id, Modifiers uint16, Key byte, PointerMode byte, KeyboardMode byte) {
	b := c.scratch[0:16]
	put16(b[2:], 4)
	b[0] = 33
	b[1] = OwnerEvents
	put32(b[4:], uint32(GrabWindow))
	put16(b[8:], Modifiers)
	b[10] = Key
	b[11] = PointerMode
	b[12] = KeyboardMode
	c.sendRequest(b)
}

func (c *Conn) UngrabKey(Key byte, GrabWindow Id, Modifiers uint16) {
	b := c.scratch[0:12]
	put16(b[2:], 3)
	b[0] = 34
	b[1] = Key
	put32(b[4:], uint32(GrabWindow))
	put16(b[8:], Modifiers)
	c.sendRequest(b)
}

const (
	AllowAsyncPointer   = 0
	AllowSyncPointer    = 1
	AllowReplayPointer  = 2
	AllowAsyncKeyboard  = 3
	AllowSyncKeyboard   = 4
	AllowReplayKeyboard = 5
	AllowAsyncBoth      = 6
	AllowSyncBoth       = 7
)

func (c *Conn) AllowEvents(Mode byte, Time Timestamp) {
	b := c.scratch[0:8]
	put16(b[2:], 2)
	b[0] = 35
	b[1] = Mode
	put32(b[4:], uint32(Time))
	c.sendRequest(b)
}

func (c *Conn) GrabServer() {
	b := c.scratch[0:4]
	put16(b[2:], 1)
	b[0] = 36
	c.sendRequest(b)
}

func (c *Conn) UngrabServer() {
	b := c.scratch[0:4]
	put16(b[2:], 1)
	b[0] = 37
	c.sendRequest(b)
}

func (c *Conn) QueryPointerRequest(Window Id) Cookie {
	b := c.scratch[0:8]
	put16(b[2:], 2)
	b[0] = 38
	put32(b[4:], uint32(Window))
	return c.sendRequest(b)
}

func (c *Conn) QueryPointer(Window Id) (*QueryPointerReply, os.Error) {
	return c.QueryPointerReply(c.QueryPointerRequest(Window))
}

type QueryPointerReply struct {
	SameScreen byte
	Root       Id
	Child      Id
	RootX      int16
	RootY      int16
	WinX       int16
	WinY       int16
	Mask       uint16
}

func (c *Conn) QueryPointerReply(cookie Cookie) (*QueryPointerReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(QueryPointerReply)
	v.SameScreen = b[1]
	v.Root = Id(get32(b[8:]))
	v.Child = Id(get32(b[12:]))
	v.RootX = int16(get16(b[16:]))
	v.RootY = int16(get16(b[18:]))
	v.WinX = int16(get16(b[20:]))
	v.WinY = int16(get16(b[22:]))
	v.Mask = get16(b[24:])
	return v, nil
}

type Timecoord struct {
	Time Timestamp
	X    int16
	Y    int16
}

func getTimecoord(b []byte, v *Timecoord) int {
	v.Time = Timestamp(get32(b[0:]))
	v.X = int16(get16(b[4:]))
	v.Y = int16(get16(b[6:]))
	return 8
}

func (c *Conn) sendTimecoordList(list []Timecoord, count int) {
	b0 := make([]byte, 8*count)
	for k := 0; k < count; k++ {
		b := b0[k*8:]
		put32(b[0:], uint32(list[k].Time))
		put16(b[4:], uint16(list[k].X))
		put16(b[6:], uint16(list[k].Y))
	}
	c.sendBytes(b0)
}

func (c *Conn) GetMotionEventsRequest(Window Id, Start Timestamp, Stop Timestamp) Cookie {
	b := c.scratch[0:16]
	put16(b[2:], 4)
	b[0] = 39
	put32(b[4:], uint32(Window))
	put32(b[8:], uint32(Start))
	put32(b[12:], uint32(Stop))
	return c.sendRequest(b)
}

func (c *Conn) GetMotionEvents(Window Id, Start Timestamp, Stop Timestamp) (*GetMotionEventsReply, os.Error) {
	return c.GetMotionEventsReply(c.GetMotionEventsRequest(Window, Start, Stop))
}

type GetMotionEventsReply struct {
	EventsLen uint32
	Events    []Timecoord
}

func (c *Conn) GetMotionEventsReply(cookie Cookie) (*GetMotionEventsReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(GetMotionEventsReply)
	v.EventsLen = get32(b[8:])
	offset := 32
	v.Events = make([]Timecoord, int(v.EventsLen))
	for i := 0; i < int(v.EventsLen); i++ {
		offset += getTimecoord(b[offset:], &v.Events[i])
	}
	return v, nil
}

func (c *Conn) TranslateCoordinatesRequest(SrcWindow Id, DstWindow Id, SrcX int16, SrcY int16) Cookie {
	b := c.scratch[0:16]
	put16(b[2:], 4)
	b[0] = 40
	put32(b[4:], uint32(SrcWindow))
	put32(b[8:], uint32(DstWindow))
	put16(b[12:], uint16(SrcX))
	put16(b[14:], uint16(SrcY))
	return c.sendRequest(b)
}

func (c *Conn) TranslateCoordinates(SrcWindow Id, DstWindow Id, SrcX int16, SrcY int16) (*TranslateCoordinatesReply, os.Error) {
	return c.TranslateCoordinatesReply(c.TranslateCoordinatesRequest(SrcWindow, DstWindow, SrcX, SrcY))
}

type TranslateCoordinatesReply struct {
	SameScreen byte
	Child      Id
	DstX       uint16
	DstY       uint16
}

func (c *Conn) TranslateCoordinatesReply(cookie Cookie) (*TranslateCoordinatesReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(TranslateCoordinatesReply)
	v.SameScreen = b[1]
	v.Child = Id(get32(b[8:]))
	v.DstX = get16(b[12:])
	v.DstY = get16(b[14:])
	return v, nil
}

func (c *Conn) WarpPointer(SrcWindow Id, DstWindow Id, SrcX int16, SrcY int16, SrcWidth uint16, SrcHeight uint16, DstX int16, DstY int16) {
	b := c.scratch[0:24]
	put16(b[2:], 6)
	b[0] = 41
	put32(b[4:], uint32(SrcWindow))
	put32(b[8:], uint32(DstWindow))
	put16(b[12:], uint16(SrcX))
	put16(b[14:], uint16(SrcY))
	put16(b[16:], SrcWidth)
	put16(b[18:], SrcHeight)
	put16(b[20:], uint16(DstX))
	put16(b[22:], uint16(DstY))
	c.sendRequest(b)
}

const (
	InputFocusNone           = 0
	InputFocusPointerRoot    = 1
	InputFocusParent         = 2
	InputFocusFollowKeyboard = 3
)

func (c *Conn) SetInputFocus(RevertTo byte, Focus Id, Time Timestamp) {
	b := c.scratch[0:12]
	put16(b[2:], 3)
	b[0] = 42
	b[1] = RevertTo
	put32(b[4:], uint32(Focus))
	put32(b[8:], uint32(Time))
	c.sendRequest(b)
}

func (c *Conn) GetInputFocusRequest() Cookie {
	b := c.scratch[0:4]
	put16(b[2:], 1)
	b[0] = 43
	return c.sendRequest(b)
}

func (c *Conn) GetInputFocus() (*GetInputFocusReply, os.Error) {
	return c.GetInputFocusReply(c.GetInputFocusRequest())
}

type GetInputFocusReply struct {
	RevertTo byte
	Focus    Id
}

func (c *Conn) GetInputFocusReply(cookie Cookie) (*GetInputFocusReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(GetInputFocusReply)
	v.RevertTo = b[1]
	v.Focus = Id(get32(b[8:]))
	return v, nil
}

func (c *Conn) QueryKeymapRequest() Cookie {
	b := c.scratch[0:4]
	put16(b[2:], 1)
	b[0] = 44
	return c.sendRequest(b)
}

func (c *Conn) QueryKeymap() (*QueryKeymapReply, os.Error) {
	return c.QueryKeymapReply(c.QueryKeymapRequest())
}

type QueryKeymapReply struct {
	Keys [32]byte
}

func (c *Conn) QueryKeymapReply(cookie Cookie) (*QueryKeymapReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(QueryKeymapReply)
	copy(v.Keys[0:32], b[8:])
	return v, nil
}

func (c *Conn) OpenFont(Fid Id, Name string) {
	b := c.scratch[0:12]
	n := 12
	n += pad(len(Name) * 1)
	put16(b[2:], uint16(n/4))
	b[0] = 45
	put32(b[4:], uint32(Fid))
	put16(b[8:], uint16(len(Name)))
	c.sendRequest(b)
	c.sendString(Name)
}

func (c *Conn) CloseFont(Font Id) {
	b := c.scratch[0:8]
	put16(b[2:], 2)
	b[0] = 46
	put32(b[4:], uint32(Font))
	c.sendRequest(b)
}

const (
	FontDrawLeftToRight = 0
	FontDrawRightToLeft = 1
)

type Fontprop struct {
	Name  Id
	Value uint32
}

func getFontprop(b []byte, v *Fontprop) int {
	v.Name = Id(get32(b[0:]))
	v.Value = get32(b[4:])
	return 8
}

func (c *Conn) sendFontpropList(list []Fontprop, count int) {
	b0 := make([]byte, 8*count)
	for k := 0; k < count; k++ {
		b := b0[k*8:]
		put32(b[0:], uint32(list[k].Name))
		put32(b[4:], list[k].Value)
	}
	c.sendBytes(b0)
}

type Charinfo struct {
	LeftSideBearing  int16
	RightSideBearing int16
	CharacterWidth   int16
	Ascent           int16
	Descent          int16
	Attributes       uint16
}

func getCharinfo(b []byte, v *Charinfo) int {
	v.LeftSideBearing = int16(get16(b[0:]))
	v.RightSideBearing = int16(get16(b[2:]))
	v.CharacterWidth = int16(get16(b[4:]))
	v.Ascent = int16(get16(b[6:]))
	v.Descent = int16(get16(b[8:]))
	v.Attributes = get16(b[10:])
	return 12
}

func (c *Conn) sendCharinfoList(list []Charinfo, count int) {
	b0 := make([]byte, 12*count)
	for k := 0; k < count; k++ {
		b := b0[k*12:]
		put16(b[0:], uint16(list[k].LeftSideBearing))
		put16(b[2:], uint16(list[k].RightSideBearing))
		put16(b[4:], uint16(list[k].CharacterWidth))
		put16(b[6:], uint16(list[k].Ascent))
		put16(b[8:], uint16(list[k].Descent))
		put16(b[10:], list[k].Attributes)
	}
	c.sendBytes(b0)
}

func (c *Conn) QueryFontRequest(Font Id) Cookie {
	b := c.scratch[0:8]
	put16(b[2:], 2)
	b[0] = 47
	put32(b[4:], uint32(Font))
	return c.sendRequest(b)
}

func (c *Conn) QueryFont(Font Id) (*QueryFontReply, os.Error) {
	return c.QueryFontReply(c.QueryFontRequest(Font))
}

type QueryFontReply struct {
	MinBounds      Charinfo
	MaxBounds      Charinfo
	MinCharOrByte2 uint16
	MaxCharOrByte2 uint16
	DefaultChar    uint16
	PropertiesLen  uint16
	DrawDirection  byte
	MinByte1       byte
	MaxByte1       byte
	AllCharsExist  byte
	FontAscent     int16
	FontDescent    int16
	CharInfosLen   uint32
	Properties     []Fontprop
	CharInfos      []Charinfo
}

func (c *Conn) QueryFontReply(cookie Cookie) (*QueryFontReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(QueryFontReply)
	getCharinfo(b[8:], &v.MinBounds)
	getCharinfo(b[24:], &v.MaxBounds)
	v.MinCharOrByte2 = get16(b[40:])
	v.MaxCharOrByte2 = get16(b[42:])
	v.DefaultChar = get16(b[44:])
	v.PropertiesLen = get16(b[46:])
	v.DrawDirection = b[48]
	v.MinByte1 = b[49]
	v.MaxByte1 = b[50]
	v.AllCharsExist = b[51]
	v.FontAscent = int16(get16(b[52:]))
	v.FontDescent = int16(get16(b[54:]))
	v.CharInfosLen = get32(b[56:])
	offset := 60
	v.Properties = make([]Fontprop, int(v.PropertiesLen))
	for i := 0; i < int(v.PropertiesLen); i++ {
		offset += getFontprop(b[offset:], &v.Properties[i])
	}
	offset = pad(offset)
	v.CharInfos = make([]Charinfo, int(v.CharInfosLen))
	for i := 0; i < int(v.CharInfosLen); i++ {
		offset += getCharinfo(b[offset:], &v.CharInfos[i])
	}
	return v, nil
}

func (c *Conn) QueryTextExtentsRequest(Font Id, String []Char2b) Cookie {
	b := c.scratch[0:8]
	n := 8
	n += pad(len(String) * 2)
	put16(b[2:], uint16(n/4))
	b[0] = 48
	b[1] = byte((len(String) & 1))
	put32(b[4:], uint32(Font))
	cookie := c.sendRequest(b)
	c.sendChar2bList(String, len(String))
	return cookie
}

func (c *Conn) QueryTextExtents(Font Id, String []Char2b) (*QueryTextExtentsReply, os.Error) {
	return c.QueryTextExtentsReply(c.QueryTextExtentsRequest(Font, String))
}

type QueryTextExtentsReply struct {
	DrawDirection  byte
	FontAscent     int16
	FontDescent    int16
	OverallAscent  int16
	OverallDescent int16
	OverallWidth   int32
	OverallLeft    int32
	OverallRight   int32
}

func (c *Conn) QueryTextExtentsReply(cookie Cookie) (*QueryTextExtentsReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(QueryTextExtentsReply)
	v.DrawDirection = b[1]
	v.FontAscent = int16(get16(b[8:]))
	v.FontDescent = int16(get16(b[10:]))
	v.OverallAscent = int16(get16(b[12:]))
	v.OverallDescent = int16(get16(b[14:]))
	v.OverallWidth = int32(get32(b[16:]))
	v.OverallLeft = int32(get32(b[20:]))
	v.OverallRight = int32(get32(b[24:]))
	return v, nil
}

type Str struct {
	NameLen byte
	Name    []byte
}

func getStr(b []byte, v *Str) int {
	v.NameLen = b[0]
	offset := 1
	v.Name = make([]byte, int(v.NameLen))
	copy(v.Name[0:len(v.Name)], b[offset:])
	offset += len(v.Name) * 1
	return offset
}

// omitting variable length sendStr

func (c *Conn) ListFontsRequest(MaxNames uint16, Pattern []byte) Cookie {
	b := c.scratch[0:8]
	n := 8
	n += pad(len(Pattern) * 1)
	put16(b[2:], uint16(n/4))
	b[0] = 49
	put16(b[4:], MaxNames)
	put16(b[6:], uint16(len(Pattern)))
	cookie := c.sendRequest(b)
	c.sendBytes(Pattern[0:len(Pattern)])
	return cookie
}

func (c *Conn) ListFonts(MaxNames uint16, Pattern []byte) (*ListFontsReply, os.Error) {
	return c.ListFontsReply(c.ListFontsRequest(MaxNames, Pattern))
}

type ListFontsReply struct {
	NamesLen uint16
	Names    []Str
}

func (c *Conn) ListFontsReply(cookie Cookie) (*ListFontsReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(ListFontsReply)
	v.NamesLen = get16(b[8:])
	offset := 32
	v.Names = make([]Str, int(v.NamesLen))
	for i := 0; i < int(v.NamesLen); i++ {
		offset += getStr(b[offset:], &v.Names[i])
	}
	return v, nil
}

func (c *Conn) ListFontsWithInfoRequest(MaxNames uint16, Pattern []byte) Cookie {
	b := c.scratch[0:8]
	n := 8
	n += pad(len(Pattern) * 1)
	put16(b[2:], uint16(n/4))
	b[0] = 50
	put16(b[4:], MaxNames)
	put16(b[6:], uint16(len(Pattern)))
	cookie := c.sendRequest(b)
	c.sendBytes(Pattern[0:len(Pattern)])
	return cookie
}

func (c *Conn) ListFontsWithInfo(MaxNames uint16, Pattern []byte) (*ListFontsWithInfoReply, os.Error) {
	return c.ListFontsWithInfoReply(c.ListFontsWithInfoRequest(MaxNames, Pattern))
}

type ListFontsWithInfoReply struct {
	NameLen        byte
	MinBounds      Charinfo
	MaxBounds      Charinfo
	MinCharOrByte2 uint16
	MaxCharOrByte2 uint16
	DefaultChar    uint16
	PropertiesLen  uint16
	DrawDirection  byte
	MinByte1       byte
	MaxByte1       byte
	AllCharsExist  byte
	FontAscent     int16
	FontDescent    int16
	RepliesHint    uint32
	Properties     []Fontprop
	Name           []byte
}

func (c *Conn) ListFontsWithInfoReply(cookie Cookie) (*ListFontsWithInfoReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(ListFontsWithInfoReply)
	v.NameLen = b[1]
	getCharinfo(b[8:], &v.MinBounds)
	getCharinfo(b[24:], &v.MaxBounds)
	v.MinCharOrByte2 = get16(b[40:])
	v.MaxCharOrByte2 = get16(b[42:])
	v.DefaultChar = get16(b[44:])
	v.PropertiesLen = get16(b[46:])
	v.DrawDirection = b[48]
	v.MinByte1 = b[49]
	v.MaxByte1 = b[50]
	v.AllCharsExist = b[51]
	v.FontAscent = int16(get16(b[52:]))
	v.FontDescent = int16(get16(b[54:]))
	v.RepliesHint = get32(b[56:])
	offset := 60
	v.Properties = make([]Fontprop, int(v.PropertiesLen))
	for i := 0; i < int(v.PropertiesLen); i++ {
		offset += getFontprop(b[offset:], &v.Properties[i])
	}
	offset = pad(offset)
	v.Name = make([]byte, int(v.NameLen))
	copy(v.Name[0:len(v.Name)], b[offset:])
	offset += len(v.Name) * 1
	return v, nil
}

func (c *Conn) SetFontPath(FontQty uint16, Path []byte) {
	b := c.scratch[0:6]
	n := 6
	n += pad(len(Path) * 1)
	put16(b[2:], uint16(n/4))
	b[0] = 51
	put16(b[4:], FontQty)
	c.sendRequest(b)
	c.sendBytes(Path[0:len(Path)])
}

func (c *Conn) GetFontPathRequest() Cookie {
	b := c.scratch[0:4]
	put16(b[2:], 1)
	b[0] = 52
	return c.sendRequest(b)
}

func (c *Conn) GetFontPath() (*GetFontPathReply, os.Error) {
	return c.GetFontPathReply(c.GetFontPathRequest())
}

type GetFontPathReply struct {
	PathLen uint16
	Path    []Str
}

func (c *Conn) GetFontPathReply(cookie Cookie) (*GetFontPathReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(GetFontPathReply)
	v.PathLen = get16(b[8:])
	offset := 32
	v.Path = make([]Str, int(v.PathLen))
	for i := 0; i < int(v.PathLen); i++ {
		offset += getStr(b[offset:], &v.Path[i])
	}
	return v, nil
}

func (c *Conn) CreatePixmap(Depth byte, Pid Id, Drawable Id, Width uint16, Height uint16) {
	b := c.scratch[0:16]
	put16(b[2:], 4)
	b[0] = 53
	b[1] = Depth
	put32(b[4:], uint32(Pid))
	put32(b[8:], uint32(Drawable))
	put16(b[12:], Width)
	put16(b[14:], Height)
	c.sendRequest(b)
}

func (c *Conn) FreePixmap(Pixmap Id) {
	b := c.scratch[0:8]
	put16(b[2:], 2)
	b[0] = 54
	put32(b[4:], uint32(Pixmap))
	c.sendRequest(b)
}

const (
	GCFunction           = 1
	GCPlaneMask          = 2
	GCForeground         = 4
	GCBackground         = 8
	GCLineWidth          = 16
	GCLineStyle          = 32
	GCCapStyle           = 64
	GCJoinStyle          = 128
	GCFillStyle          = 256
	GCFillRule           = 512
	GCTile               = 1024
	GCStipple            = 2048
	GCTileStippleOriginX = 4096
	GCTileStippleOriginY = 8192
	GCFont               = 16384
	GCSubwindowMode      = 32768
	GCGraphicsExposures  = 65536
	GCClipOriginX        = 131072
	GCClipOriginY        = 262144
	GCClipMask           = 524288
	GCDashOffset         = 1048576
	GCDashList           = 2097152
	GCArcMode            = 4194304
)

const (
	GXClear        = 0
	GXAnd          = 1
	GXAndReverse   = 2
	GXCopy         = 3
	GXAndInverted  = 4
	GXNoop         = 5
	GXXor          = 6
	GXOr           = 7
	GXNor          = 8
	GXEquiv        = 9
	GXInvert       = 10
	GXOrReverse    = 11
	GXCopyInverted = 12
	GXOrInverted   = 13
	GXNand         = 14
	GXSet          = 15
)

const (
	LineStyleSolid      = 0
	LineStyleOnOffDash  = 1
	LineStyleDoubleDash = 2
)

const (
	CapStyleNotLast    = 0
	CapStyleButt       = 1
	CapStyleRound      = 2
	CapStyleProjecting = 3
)

const (
	JoinStyleMiter = 0
	JoinStyleRound = 1
	JoinStyleBevel = 2
)

const (
	FillStyleSolid          = 0
	FillStyleTiled          = 1
	FillStyleStippled       = 2
	FillStyleOpaqueStippled = 3
)

const (
	FillRuleEvenOdd = 0
	FillRuleWinding = 1
)

const (
	SubwindowModeClipByChildren   = 0
	SubwindowModeIncludeInferiors = 1
)

const (
	ArcModeChord    = 0
	ArcModePieSlice = 1
)

func (c *Conn) CreateGC(Cid Id, Drawable Id, ValueMask uint32, ValueList []uint32) {
	b := c.scratch[0:16]
	n := 16
	n += pad(popCount(int(ValueMask)) * 4)
	put16(b[2:], uint16(n/4))
	b[0] = 55
	put32(b[4:], uint32(Cid))
	put32(b[8:], uint32(Drawable))
	put32(b[12:], ValueMask)
	c.sendRequest(b)
	c.sendUInt32List(ValueList[0:popCount(int(ValueMask))])
}

func (c *Conn) ChangeGC(Gc Id, ValueMask uint32, ValueList []uint32) {
	b := c.scratch[0:12]
	n := 12
	n += pad(popCount(int(ValueMask)) * 4)
	put16(b[2:], uint16(n/4))
	b[0] = 56
	put32(b[4:], uint32(Gc))
	put32(b[8:], ValueMask)
	c.sendRequest(b)
	c.sendUInt32List(ValueList[0:popCount(int(ValueMask))])
}

func (c *Conn) CopyGC(SrcGc Id, DstGc Id, ValueMask uint32) {
	b := c.scratch[0:16]
	put16(b[2:], 4)
	b[0] = 57
	put32(b[4:], uint32(SrcGc))
	put32(b[8:], uint32(DstGc))
	put32(b[12:], ValueMask)
	c.sendRequest(b)
}

func (c *Conn) SetDashes(Gc Id, DashOffset uint16, Dashes []byte) {
	b := c.scratch[0:12]
	n := 12
	n += pad(len(Dashes) * 1)
	put16(b[2:], uint16(n/4))
	b[0] = 58
	put32(b[4:], uint32(Gc))
	put16(b[8:], DashOffset)
	put16(b[10:], uint16(len(Dashes)))
	c.sendRequest(b)
	c.sendBytes(Dashes[0:len(Dashes)])
}

const (
	ClipOrderingUnsorted = 0
	ClipOrderingYSorted  = 1
	ClipOrderingYXSorted = 2
	ClipOrderingYXBanded = 3
)

func (c *Conn) SetClipRectangles(Ordering byte, Gc Id, ClipXOrigin int16, ClipYOrigin int16, Rectangles []Rectangle) {
	b := c.scratch[0:12]
	n := 12
	n += pad(len(Rectangles) * 8)
	put16(b[2:], uint16(n/4))
	b[0] = 59
	b[1] = Ordering
	put32(b[4:], uint32(Gc))
	put16(b[8:], uint16(ClipXOrigin))
	put16(b[10:], uint16(ClipYOrigin))
	c.sendRequest(b)
	c.sendRectangleList(Rectangles, len(Rectangles))
}

func (c *Conn) FreeGC(Gc Id) {
	b := c.scratch[0:8]
	put16(b[2:], 2)
	b[0] = 60
	put32(b[4:], uint32(Gc))
	c.sendRequest(b)
}

func (c *Conn) ClearArea(Exposures byte, Window Id, X int16, Y int16, Width uint16, Height uint16) {
	b := c.scratch[0:16]
	put16(b[2:], 4)
	b[0] = 61
	b[1] = Exposures
	put32(b[4:], uint32(Window))
	put16(b[8:], uint16(X))
	put16(b[10:], uint16(Y))
	put16(b[12:], Width)
	put16(b[14:], Height)
	c.sendRequest(b)
}

func (c *Conn) CopyArea(SrcDrawable Id, DstDrawable Id, Gc Id, SrcX int16, SrcY int16, DstX int16, DstY int16, Width uint16, Height uint16) {
	b := c.scratch[0:28]
	put16(b[2:], 7)
	b[0] = 62
	put32(b[4:], uint32(SrcDrawable))
	put32(b[8:], uint32(DstDrawable))
	put32(b[12:], uint32(Gc))
	put16(b[16:], uint16(SrcX))
	put16(b[18:], uint16(SrcY))
	put16(b[20:], uint16(DstX))
	put16(b[22:], uint16(DstY))
	put16(b[24:], Width)
	put16(b[26:], Height)
	c.sendRequest(b)
}

func (c *Conn) CopyPlane(SrcDrawable Id, DstDrawable Id, Gc Id, SrcX int16, SrcY int16, DstX int16, DstY int16, Width uint16, Height uint16, BitPlane uint32) {
	b := c.scratch[0:32]
	put16(b[2:], 8)
	b[0] = 63
	put32(b[4:], uint32(SrcDrawable))
	put32(b[8:], uint32(DstDrawable))
	put32(b[12:], uint32(Gc))
	put16(b[16:], uint16(SrcX))
	put16(b[18:], uint16(SrcY))
	put16(b[20:], uint16(DstX))
	put16(b[22:], uint16(DstY))
	put16(b[24:], Width)
	put16(b[26:], Height)
	put32(b[28:], BitPlane)
	c.sendRequest(b)
}

const (
	CoordModeOrigin   = 0
	CoordModePrevious = 1
)

func (c *Conn) PolyPoint(CoordinateMode byte, Drawable Id, Gc Id, Points []Point) {
	b := c.scratch[0:12]
	n := 12
	n += pad(len(Points) * 4)
	put16(b[2:], uint16(n/4))
	b[0] = 64
	b[1] = CoordinateMode
	put32(b[4:], uint32(Drawable))
	put32(b[8:], uint32(Gc))
	c.sendRequest(b)
	c.sendPointList(Points, len(Points))
}

func (c *Conn) PolyLine(CoordinateMode byte, Drawable Id, Gc Id, Points []Point) {
	b := c.scratch[0:12]
	n := 12
	n += pad(len(Points) * 4)
	put16(b[2:], uint16(n/4))
	b[0] = 65
	b[1] = CoordinateMode
	put32(b[4:], uint32(Drawable))
	put32(b[8:], uint32(Gc))
	c.sendRequest(b)
	c.sendPointList(Points, len(Points))
}

type Segment struct {
	X1 int16
	Y1 int16
	X2 int16
	Y2 int16
}

func getSegment(b []byte, v *Segment) int {
	v.X1 = int16(get16(b[0:]))
	v.Y1 = int16(get16(b[2:]))
	v.X2 = int16(get16(b[4:]))
	v.Y2 = int16(get16(b[6:]))
	return 8
}

func (c *Conn) sendSegmentList(list []Segment, count int) {
	b0 := make([]byte, 8*count)
	for k := 0; k < count; k++ {
		b := b0[k*8:]
		put16(b[0:], uint16(list[k].X1))
		put16(b[2:], uint16(list[k].Y1))
		put16(b[4:], uint16(list[k].X2))
		put16(b[6:], uint16(list[k].Y2))
	}
	c.sendBytes(b0)
}

func (c *Conn) PolySegment(Drawable Id, Gc Id, Segments []Segment) {
	b := c.scratch[0:12]
	n := 12
	n += pad(len(Segments) * 8)
	put16(b[2:], uint16(n/4))
	b[0] = 66
	put32(b[4:], uint32(Drawable))
	put32(b[8:], uint32(Gc))
	c.sendRequest(b)
	c.sendSegmentList(Segments, len(Segments))
}

func (c *Conn) PolyRectangle(Drawable Id, Gc Id, Rectangles []Rectangle) {
	b := c.scratch[0:12]
	n := 12
	n += pad(len(Rectangles) * 8)
	put16(b[2:], uint16(n/4))
	b[0] = 67
	put32(b[4:], uint32(Drawable))
	put32(b[8:], uint32(Gc))
	c.sendRequest(b)
	c.sendRectangleList(Rectangles, len(Rectangles))
}

func (c *Conn) PolyArc(Drawable Id, Gc Id, Arcs []Arc) {
	b := c.scratch[0:12]
	n := 12
	n += pad(len(Arcs) * 12)
	put16(b[2:], uint16(n/4))
	b[0] = 68
	put32(b[4:], uint32(Drawable))
	put32(b[8:], uint32(Gc))
	c.sendRequest(b)
	c.sendArcList(Arcs, len(Arcs))
}

const (
	PolyShapeComplex   = 0
	PolyShapeNonconvex = 1
	PolyShapeConvex    = 2
)

func (c *Conn) FillPoly(Drawable Id, Gc Id, Shape byte, CoordinateMode byte, Points []Point) {
	b := c.scratch[0:16]
	n := 16
	n += pad(len(Points) * 4)
	put16(b[2:], uint16(n/4))
	b[0] = 69
	put32(b[4:], uint32(Drawable))
	put32(b[8:], uint32(Gc))
	b[12] = Shape
	b[13] = CoordinateMode
	c.sendRequest(b)
	c.sendPointList(Points, len(Points))
}

func (c *Conn) PolyFillRectangle(Drawable Id, Gc Id, Rectangles []Rectangle) {
	b := c.scratch[0:12]
	n := 12
	n += pad(len(Rectangles) * 8)
	put16(b[2:], uint16(n/4))
	b[0] = 70
	put32(b[4:], uint32(Drawable))
	put32(b[8:], uint32(Gc))
	c.sendRequest(b)
	c.sendRectangleList(Rectangles, len(Rectangles))
}

func (c *Conn) PolyFillArc(Drawable Id, Gc Id, Arcs []Arc) {
	b := c.scratch[0:12]
	n := 12
	n += pad(len(Arcs) * 12)
	put16(b[2:], uint16(n/4))
	b[0] = 71
	put32(b[4:], uint32(Drawable))
	put32(b[8:], uint32(Gc))
	c.sendRequest(b)
	c.sendArcList(Arcs, len(Arcs))
}

const (
	ImageFormatXYBitmap = 0
	ImageFormatXYPixmap = 1
	ImageFormatZPixmap  = 2
)

func (c *Conn) PutImage(Format byte, Drawable Id, Gc Id, Width uint16, Height uint16, DstX int16, DstY int16, LeftPad byte, Depth byte, Data []byte) {
	b := c.scratch[0:24]
	n := 24
	n += pad(len(Data) * 1)
	put16(b[2:], uint16(n/4))
	b[0] = 72
	b[1] = Format
	put32(b[4:], uint32(Drawable))
	put32(b[8:], uint32(Gc))
	put16(b[12:], Width)
	put16(b[14:], Height)
	put16(b[16:], uint16(DstX))
	put16(b[18:], uint16(DstY))
	b[20] = LeftPad
	b[21] = Depth
	c.sendRequest(b)
	c.sendBytes(Data[0:len(Data)])
}

func (c *Conn) GetImageRequest(Format byte, Drawable Id, X int16, Y int16, Width uint16, Height uint16, PlaneMask uint32) Cookie {
	b := c.scratch[0:20]
	put16(b[2:], 5)
	b[0] = 73
	b[1] = Format
	put32(b[4:], uint32(Drawable))
	put16(b[8:], uint16(X))
	put16(b[10:], uint16(Y))
	put16(b[12:], Width)
	put16(b[14:], Height)
	put32(b[16:], PlaneMask)
	return c.sendRequest(b)
}

func (c *Conn) GetImage(Format byte, Drawable Id, X int16, Y int16, Width uint16, Height uint16, PlaneMask uint32) (*GetImageReply, os.Error) {
	return c.GetImageReply(c.GetImageRequest(Format, Drawable, X, Y, Width, Height, PlaneMask))
}

type GetImageReply struct {
	Depth  byte
	Length uint32
	Visual Id
	Data   []byte
}

func (c *Conn) GetImageReply(cookie Cookie) (*GetImageReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(GetImageReply)
	v.Depth = b[1]
	v.Length = get32(b[4:])
	v.Visual = Id(get32(b[8:]))
	offset := 32
	v.Data = make([]byte, (int(v.Length) * 4))
	copy(v.Data[0:len(v.Data)], b[offset:])
	offset += len(v.Data) * 1
	return v, nil
}

func (c *Conn) PolyText8(Drawable Id, Gc Id, X int16, Y int16, Items []byte) {
	b := c.scratch[0:16]
	n := 16
	n += pad(len(Items) * 1)
	put16(b[2:], uint16(n/4))
	b[0] = 74
	put32(b[4:], uint32(Drawable))
	put32(b[8:], uint32(Gc))
	put16(b[12:], uint16(X))
	put16(b[14:], uint16(Y))
	c.sendRequest(b)
	c.sendBytes(Items[0:len(Items)])
}

func (c *Conn) PolyText16(Drawable Id, Gc Id, X int16, Y int16, Items []byte) {
	b := c.scratch[0:16]
	n := 16
	n += pad(len(Items) * 1)
	put16(b[2:], uint16(n/4))
	b[0] = 75
	put32(b[4:], uint32(Drawable))
	put32(b[8:], uint32(Gc))
	put16(b[12:], uint16(X))
	put16(b[14:], uint16(Y))
	c.sendRequest(b)
	c.sendBytes(Items[0:len(Items)])
}

func (c *Conn) ImageText8(Drawable Id, Gc Id, X int16, Y int16, String []byte) {
	b := c.scratch[0:16]
	n := 16
	n += pad(len(String) * 1)
	put16(b[2:], uint16(n/4))
	b[0] = 76
	b[1] = byte(len(String))
	put32(b[4:], uint32(Drawable))
	put32(b[8:], uint32(Gc))
	put16(b[12:], uint16(X))
	put16(b[14:], uint16(Y))
	c.sendRequest(b)
	c.sendBytes(String[0:len(String)])
}

func (c *Conn) ImageText16(Drawable Id, Gc Id, X int16, Y int16, String []Char2b) {
	b := c.scratch[0:16]
	n := 16
	n += pad(len(String) * 2)
	put16(b[2:], uint16(n/4))
	b[0] = 77
	b[1] = byte(len(String))
	put32(b[4:], uint32(Drawable))
	put32(b[8:], uint32(Gc))
	put16(b[12:], uint16(X))
	put16(b[14:], uint16(Y))
	c.sendRequest(b)
	c.sendChar2bList(String, len(String))
}

const (
	ColormapAllocNone = 0
	ColormapAllocAll  = 1
)

func (c *Conn) CreateColormap(Alloc byte, Mid Id, Window Id, Visual Id) {
	b := c.scratch[0:16]
	put16(b[2:], 4)
	b[0] = 78
	b[1] = Alloc
	put32(b[4:], uint32(Mid))
	put32(b[8:], uint32(Window))
	put32(b[12:], uint32(Visual))
	c.sendRequest(b)
}

func (c *Conn) FreeColormap(Cmap Id) {
	b := c.scratch[0:8]
	put16(b[2:], 2)
	b[0] = 79
	put32(b[4:], uint32(Cmap))
	c.sendRequest(b)
}

func (c *Conn) CopyColormapAndFree(Mid Id, SrcCmap Id) {
	b := c.scratch[0:12]
	put16(b[2:], 3)
	b[0] = 80
	put32(b[4:], uint32(Mid))
	put32(b[8:], uint32(SrcCmap))
	c.sendRequest(b)
}

func (c *Conn) InstallColormap(Cmap Id) {
	b := c.scratch[0:8]
	put16(b[2:], 2)
	b[0] = 81
	put32(b[4:], uint32(Cmap))
	c.sendRequest(b)
}

func (c *Conn) UninstallColormap(Cmap Id) {
	b := c.scratch[0:8]
	put16(b[2:], 2)
	b[0] = 82
	put32(b[4:], uint32(Cmap))
	c.sendRequest(b)
}

func (c *Conn) ListInstalledColormapsRequest(Window Id) Cookie {
	b := c.scratch[0:8]
	put16(b[2:], 2)
	b[0] = 83
	put32(b[4:], uint32(Window))
	return c.sendRequest(b)
}

func (c *Conn) ListInstalledColormaps(Window Id) (*ListInstalledColormapsReply, os.Error) {
	return c.ListInstalledColormapsReply(c.ListInstalledColormapsRequest(Window))
}

type ListInstalledColormapsReply struct {
	CmapsLen uint16
	Cmaps    []Id
}

func (c *Conn) ListInstalledColormapsReply(cookie Cookie) (*ListInstalledColormapsReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(ListInstalledColormapsReply)
	v.CmapsLen = get16(b[8:])
	offset := 32
	v.Cmaps = make([]Id, int(v.CmapsLen))
	for i := 0; i < len(v.Cmaps); i++ {
		v.Cmaps[i] = Id(get32(b[offset+i*4:]))
	}
	offset += len(v.Cmaps) * 4
	return v, nil
}

func (c *Conn) AllocColorRequest(Cmap Id, Red uint16, Green uint16, Blue uint16) Cookie {
	b := c.scratch[0:16]
	put16(b[2:], 4)
	b[0] = 84
	put32(b[4:], uint32(Cmap))
	put16(b[8:], Red)
	put16(b[10:], Green)
	put16(b[12:], Blue)
	return c.sendRequest(b)
}

func (c *Conn) AllocColor(Cmap Id, Red uint16, Green uint16, Blue uint16) (*AllocColorReply, os.Error) {
	return c.AllocColorReply(c.AllocColorRequest(Cmap, Red, Green, Blue))
}

type AllocColorReply struct {
	Red   uint16
	Green uint16
	Blue  uint16
	Pixel uint32
}

func (c *Conn) AllocColorReply(cookie Cookie) (*AllocColorReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(AllocColorReply)
	v.Red = get16(b[8:])
	v.Green = get16(b[10:])
	v.Blue = get16(b[12:])
	v.Pixel = get32(b[16:])
	return v, nil
}

func (c *Conn) AllocNamedColorRequest(Cmap Id, Name string) Cookie {
	b := c.scratch[0:12]
	n := 12
	n += pad(len(Name) * 1)
	put16(b[2:], uint16(n/4))
	b[0] = 85
	put32(b[4:], uint32(Cmap))
	put16(b[8:], uint16(len(Name)))
	cookie := c.sendRequest(b)
	c.sendString(Name)
	return cookie
}

func (c *Conn) AllocNamedColor(Cmap Id, Name string) (*AllocNamedColorReply, os.Error) {
	return c.AllocNamedColorReply(c.AllocNamedColorRequest(Cmap, Name))
}

type AllocNamedColorReply struct {
	Pixel       uint32
	ExactRed    uint16
	ExactGreen  uint16
	ExactBlue   uint16
	VisualRed   uint16
	VisualGreen uint16
	VisualBlue  uint16
}

func (c *Conn) AllocNamedColorReply(cookie Cookie) (*AllocNamedColorReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(AllocNamedColorReply)
	v.Pixel = get32(b[8:])
	v.ExactRed = get16(b[12:])
	v.ExactGreen = get16(b[14:])
	v.ExactBlue = get16(b[16:])
	v.VisualRed = get16(b[18:])
	v.VisualGreen = get16(b[20:])
	v.VisualBlue = get16(b[22:])
	return v, nil
}

func (c *Conn) AllocColorCellsRequest(Contiguous byte, Cmap Id, Colors uint16, Planes uint16) Cookie {
	b := c.scratch[0:12]
	put16(b[2:], 3)
	b[0] = 86
	b[1] = Contiguous
	put32(b[4:], uint32(Cmap))
	put16(b[8:], Colors)
	put16(b[10:], Planes)
	return c.sendRequest(b)
}

func (c *Conn) AllocColorCells(Contiguous byte, Cmap Id, Colors uint16, Planes uint16) (*AllocColorCellsReply, os.Error) {
	return c.AllocColorCellsReply(c.AllocColorCellsRequest(Contiguous, Cmap, Colors, Planes))
}

type AllocColorCellsReply struct {
	PixelsLen uint16
	MasksLen  uint16
	Pixels    []uint32
	Masks     []uint32
}

func (c *Conn) AllocColorCellsReply(cookie Cookie) (*AllocColorCellsReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(AllocColorCellsReply)
	v.PixelsLen = get16(b[8:])
	v.MasksLen = get16(b[10:])
	offset := 32
	v.Pixels = make([]uint32, int(v.PixelsLen))
	for i := 0; i < len(v.Pixels); i++ {
		v.Pixels[i] = get32(b[offset+i*4:])
	}
	offset += len(v.Pixels) * 4
	offset = pad(offset)
	v.Masks = make([]uint32, int(v.MasksLen))
	for i := 0; i < len(v.Masks); i++ {
		v.Masks[i] = get32(b[offset+i*4:])
	}
	offset += len(v.Masks) * 4
	return v, nil
}

func (c *Conn) AllocColorPlanesRequest(Contiguous byte, Cmap Id, Colors uint16, Reds uint16, Greens uint16, Blues uint16) Cookie {
	b := c.scratch[0:16]
	put16(b[2:], 4)
	b[0] = 87
	b[1] = Contiguous
	put32(b[4:], uint32(Cmap))
	put16(b[8:], Colors)
	put16(b[10:], Reds)
	put16(b[12:], Greens)
	put16(b[14:], Blues)
	return c.sendRequest(b)
}

func (c *Conn) AllocColorPlanes(Contiguous byte, Cmap Id, Colors uint16, Reds uint16, Greens uint16, Blues uint16) (*AllocColorPlanesReply, os.Error) {
	return c.AllocColorPlanesReply(c.AllocColorPlanesRequest(Contiguous, Cmap, Colors, Reds, Greens, Blues))
}

type AllocColorPlanesReply struct {
	PixelsLen uint16
	RedMask   uint32
	GreenMask uint32
	BlueMask  uint32
	Pixels    []uint32
}

func (c *Conn) AllocColorPlanesReply(cookie Cookie) (*AllocColorPlanesReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(AllocColorPlanesReply)
	v.PixelsLen = get16(b[8:])
	v.RedMask = get32(b[12:])
	v.GreenMask = get32(b[16:])
	v.BlueMask = get32(b[20:])
	offset := 32
	v.Pixels = make([]uint32, int(v.PixelsLen))
	for i := 0; i < len(v.Pixels); i++ {
		v.Pixels[i] = get32(b[offset+i*4:])
	}
	offset += len(v.Pixels) * 4
	return v, nil
}

func (c *Conn) FreeColors(Cmap Id, PlaneMask uint32, Pixels []uint32) {
	b := c.scratch[0:12]
	n := 12
	n += pad(len(Pixels) * 4)
	put16(b[2:], uint16(n/4))
	b[0] = 88
	put32(b[4:], uint32(Cmap))
	put32(b[8:], PlaneMask)
	c.sendRequest(b)
	c.sendUInt32List(Pixels[0:len(Pixels)])
}

const (
	ColorFlagRed   = 1
	ColorFlagGreen = 2
	ColorFlagBlue  = 4
)

type Coloritem struct {
	Pixel uint32
	Red   uint16
	Green uint16
	Blue  uint16
	Flags byte
}

func getColoritem(b []byte, v *Coloritem) int {
	v.Pixel = get32(b[0:])
	v.Red = get16(b[4:])
	v.Green = get16(b[6:])
	v.Blue = get16(b[8:])
	v.Flags = b[10]
	return 12
}

func (c *Conn) sendColoritemList(list []Coloritem, count int) {
	b0 := make([]byte, 12*count)
	for k := 0; k < count; k++ {
		b := b0[k*12:]
		put32(b[0:], list[k].Pixel)
		put16(b[4:], list[k].Red)
		put16(b[6:], list[k].Green)
		put16(b[8:], list[k].Blue)
		b[10] = list[k].Flags
	}
	c.sendBytes(b0)
}

func (c *Conn) StoreColors(Cmap Id, Items []Coloritem) {
	b := c.scratch[0:8]
	n := 8
	n += pad(len(Items) * 12)
	put16(b[2:], uint16(n/4))
	b[0] = 89
	put32(b[4:], uint32(Cmap))
	c.sendRequest(b)
	c.sendColoritemList(Items, len(Items))
}

func (c *Conn) StoreNamedColor(Flags byte, Cmap Id, Pixel uint32, Name string) {
	b := c.scratch[0:16]
	n := 16
	n += pad(len(Name) * 1)
	put16(b[2:], uint16(n/4))
	b[0] = 90
	b[1] = Flags
	put32(b[4:], uint32(Cmap))
	put32(b[8:], Pixel)
	put16(b[12:], uint16(len(Name)))
	c.sendRequest(b)
	c.sendString(Name)
}

type Rgb struct {
	Red   uint16
	Green uint16
	Blue  uint16
}

func getRgb(b []byte, v *Rgb) int {
	v.Red = get16(b[0:])
	v.Green = get16(b[2:])
	v.Blue = get16(b[4:])
	return 8
}

func (c *Conn) sendRgbList(list []Rgb, count int) {
	b0 := make([]byte, 8*count)
	for k := 0; k < count; k++ {
		b := b0[k*8:]
		put16(b[0:], list[k].Red)
		put16(b[2:], list[k].Green)
		put16(b[4:], list[k].Blue)
	}
	c.sendBytes(b0)
}

func (c *Conn) QueryColorsRequest(Cmap Id, Pixels []uint32) Cookie {
	b := c.scratch[0:8]
	n := 8
	n += pad(len(Pixels) * 4)
	put16(b[2:], uint16(n/4))
	b[0] = 91
	put32(b[4:], uint32(Cmap))
	cookie := c.sendRequest(b)
	c.sendUInt32List(Pixels[0:len(Pixels)])
	return cookie
}

func (c *Conn) QueryColors(Cmap Id, Pixels []uint32) (*QueryColorsReply, os.Error) {
	return c.QueryColorsReply(c.QueryColorsRequest(Cmap, Pixels))
}

type QueryColorsReply struct {
	ColorsLen uint16
	Colors    []Rgb
}

func (c *Conn) QueryColorsReply(cookie Cookie) (*QueryColorsReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(QueryColorsReply)
	v.ColorsLen = get16(b[8:])
	offset := 32
	v.Colors = make([]Rgb, int(v.ColorsLen))
	for i := 0; i < int(v.ColorsLen); i++ {
		offset += getRgb(b[offset:], &v.Colors[i])
	}
	return v, nil
}

func (c *Conn) LookupColorRequest(Cmap Id, Name string) Cookie {
	b := c.scratch[0:12]
	n := 12
	n += pad(len(Name) * 1)
	put16(b[2:], uint16(n/4))
	b[0] = 92
	put32(b[4:], uint32(Cmap))
	put16(b[8:], uint16(len(Name)))
	cookie := c.sendRequest(b)
	c.sendString(Name)
	return cookie
}

func (c *Conn) LookupColor(Cmap Id, Name string) (*LookupColorReply, os.Error) {
	return c.LookupColorReply(c.LookupColorRequest(Cmap, Name))
}

type LookupColorReply struct {
	ExactRed    uint16
	ExactGreen  uint16
	ExactBlue   uint16
	VisualRed   uint16
	VisualGreen uint16
	VisualBlue  uint16
}

func (c *Conn) LookupColorReply(cookie Cookie) (*LookupColorReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(LookupColorReply)
	v.ExactRed = get16(b[8:])
	v.ExactGreen = get16(b[10:])
	v.ExactBlue = get16(b[12:])
	v.VisualRed = get16(b[14:])
	v.VisualGreen = get16(b[16:])
	v.VisualBlue = get16(b[18:])
	return v, nil
}

const (
	PixmapNone = 0
)

func (c *Conn) CreateCursor(Cid Id, Source Id, Mask Id, ForeRed uint16, ForeGreen uint16, ForeBlue uint16, BackRed uint16, BackGreen uint16, BackBlue uint16, X uint16, Y uint16) {
	b := c.scratch[0:32]
	put16(b[2:], 8)
	b[0] = 93
	put32(b[4:], uint32(Cid))
	put32(b[8:], uint32(Source))
	put32(b[12:], uint32(Mask))
	put16(b[16:], ForeRed)
	put16(b[18:], ForeGreen)
	put16(b[20:], ForeBlue)
	put16(b[22:], BackRed)
	put16(b[24:], BackGreen)
	put16(b[26:], BackBlue)
	put16(b[28:], X)
	put16(b[30:], Y)
	c.sendRequest(b)
}

const (
	FontNone = 0
)

func (c *Conn) CreateGlyphCursor(Cid Id, SourceFont Id, MaskFont Id, SourceChar uint16, MaskChar uint16, ForeRed uint16, ForeGreen uint16, ForeBlue uint16, BackRed uint16, BackGreen uint16, BackBlue uint16) {
	b := c.scratch[0:32]
	put16(b[2:], 8)
	b[0] = 94
	put32(b[4:], uint32(Cid))
	put32(b[8:], uint32(SourceFont))
	put32(b[12:], uint32(MaskFont))
	put16(b[16:], SourceChar)
	put16(b[18:], MaskChar)
	put16(b[20:], ForeRed)
	put16(b[22:], ForeGreen)
	put16(b[24:], ForeBlue)
	put16(b[26:], BackRed)
	put16(b[28:], BackGreen)
	put16(b[30:], BackBlue)
	c.sendRequest(b)
}

func (c *Conn) FreeCursor(Cursor Id) {
	b := c.scratch[0:8]
	put16(b[2:], 2)
	b[0] = 95
	put32(b[4:], uint32(Cursor))
	c.sendRequest(b)
}

func (c *Conn) RecolorCursor(Cursor Id, ForeRed uint16, ForeGreen uint16, ForeBlue uint16, BackRed uint16, BackGreen uint16, BackBlue uint16) {
	b := c.scratch[0:20]
	put16(b[2:], 5)
	b[0] = 96
	put32(b[4:], uint32(Cursor))
	put16(b[8:], ForeRed)
	put16(b[10:], ForeGreen)
	put16(b[12:], ForeBlue)
	put16(b[14:], BackRed)
	put16(b[16:], BackGreen)
	put16(b[18:], BackBlue)
	c.sendRequest(b)
}

const (
	QueryShapeOfLargestCursor  = 0
	QueryShapeOfFastestTile    = 1
	QueryShapeOfFastestStipple = 2
)

func (c *Conn) QueryBestSizeRequest(Class byte, Drawable Id, Width uint16, Height uint16) Cookie {
	b := c.scratch[0:12]
	put16(b[2:], 3)
	b[0] = 97
	b[1] = Class
	put32(b[4:], uint32(Drawable))
	put16(b[8:], Width)
	put16(b[10:], Height)
	return c.sendRequest(b)
}

func (c *Conn) QueryBestSize(Class byte, Drawable Id, Width uint16, Height uint16) (*QueryBestSizeReply, os.Error) {
	return c.QueryBestSizeReply(c.QueryBestSizeRequest(Class, Drawable, Width, Height))
}

type QueryBestSizeReply struct {
	Width  uint16
	Height uint16
}

func (c *Conn) QueryBestSizeReply(cookie Cookie) (*QueryBestSizeReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(QueryBestSizeReply)
	v.Width = get16(b[8:])
	v.Height = get16(b[10:])
	return v, nil
}

func (c *Conn) QueryExtensionRequest(Name string) Cookie {
	b := c.scratch[0:8]
	n := 8
	n += pad(len(Name) * 1)
	put16(b[2:], uint16(n/4))
	b[0] = 98
	put16(b[4:], uint16(len(Name)))
	cookie := c.sendRequest(b)
	c.sendString(Name)
	return cookie
}

func (c *Conn) QueryExtension(Name string) (*QueryExtensionReply, os.Error) {
	return c.QueryExtensionReply(c.QueryExtensionRequest(Name))
}

type QueryExtensionReply struct {
	Present     byte
	MajorOpcode byte
	FirstEvent  byte
	FirstError  byte
}

func (c *Conn) QueryExtensionReply(cookie Cookie) (*QueryExtensionReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(QueryExtensionReply)
	v.Present = b[8]
	v.MajorOpcode = b[9]
	v.FirstEvent = b[10]
	v.FirstError = b[11]
	return v, nil
}

func (c *Conn) ListExtensionsRequest() Cookie {
	b := c.scratch[0:4]
	put16(b[2:], 1)
	b[0] = 99
	return c.sendRequest(b)
}

func (c *Conn) ListExtensions() (*ListExtensionsReply, os.Error) {
	return c.ListExtensionsReply(c.ListExtensionsRequest())
}

type ListExtensionsReply struct {
	NamesLen byte
	Names    []Str
}

func (c *Conn) ListExtensionsReply(cookie Cookie) (*ListExtensionsReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(ListExtensionsReply)
	v.NamesLen = b[1]
	offset := 32
	v.Names = make([]Str, int(v.NamesLen))
	for i := 0; i < int(v.NamesLen); i++ {
		offset += getStr(b[offset:], &v.Names[i])
	}
	return v, nil
}

func (c *Conn) ChangeKeyboardMapping(KeycodeCount byte, FirstKeycode byte, KeysymsPerKeycode byte, Keysyms []Keysym) {
	b := c.scratch[0:6]
	n := 6
	n += pad((int(KeycodeCount) * int(KeysymsPerKeycode)) * 4)
	put16(b[2:], uint16(n/4))
	b[0] = 100
	b[1] = KeycodeCount
	b[4] = FirstKeycode
	b[5] = KeysymsPerKeycode
	c.sendRequest(b)
	c.sendKeysymList(Keysyms, (int(KeycodeCount) * int(KeysymsPerKeycode)))
}

func (c *Conn) GetKeyboardMappingRequest(FirstKeycode byte, Count byte) Cookie {
	b := c.scratch[0:6]
	put16(b[2:], 1)
	b[0] = 101
	b[4] = FirstKeycode
	b[5] = Count
	return c.sendRequest(b)
}

func (c *Conn) GetKeyboardMapping(FirstKeycode byte, Count byte) (*GetKeyboardMappingReply, os.Error) {
	return c.GetKeyboardMappingReply(c.GetKeyboardMappingRequest(FirstKeycode, Count))
}

type GetKeyboardMappingReply struct {
	KeysymsPerKeycode byte
	Length            uint32
	Keysyms           []Keysym
}

func (c *Conn) GetKeyboardMappingReply(cookie Cookie) (*GetKeyboardMappingReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(GetKeyboardMappingReply)
	v.KeysymsPerKeycode = b[1]
	v.Length = get32(b[4:])
	offset := 32
	v.Keysyms = make([]Keysym, int(v.Length))
	for i := 0; i < len(v.Keysyms); i++ {
		v.Keysyms[i] = Keysym(get32(b[offset+i*4:]))
	}
	offset += len(v.Keysyms) * 4
	return v, nil
}

const (
	KBKeyClickPercent = 1
	KBBellPercent     = 2
	KBBellPitch       = 4
	KBBellDuration    = 8
	KBLed             = 16
	KBLedMode         = 32
	KBKey             = 64
	KBAutoRepeatMode  = 128
)

const (
	LedModeOff = 0
	LedModeOn  = 1
)

const (
	AutoRepeatModeOff     = 0
	AutoRepeatModeOn      = 1
	AutoRepeatModeDefault = 2
)

func (c *Conn) ChangeKeyboardControl(ValueMask uint32, ValueList []uint32) {
	b := c.scratch[0:8]
	n := 8
	n += pad(popCount(int(ValueMask)) * 4)
	put16(b[2:], uint16(n/4))
	b[0] = 102
	put32(b[4:], ValueMask)
	c.sendRequest(b)
	c.sendUInt32List(ValueList[0:popCount(int(ValueMask))])
}

func (c *Conn) GetKeyboardControlRequest() Cookie {
	b := c.scratch[0:4]
	put16(b[2:], 1)
	b[0] = 103
	return c.sendRequest(b)
}

func (c *Conn) GetKeyboardControl() (*GetKeyboardControlReply, os.Error) {
	return c.GetKeyboardControlReply(c.GetKeyboardControlRequest())
}

type GetKeyboardControlReply struct {
	GlobalAutoRepeat byte
	LedMask          uint32
	KeyClickPercent  byte
	BellPercent      byte
	BellPitch        uint16
	BellDuration     uint16
	AutoRepeats      [32]byte
}

func (c *Conn) GetKeyboardControlReply(cookie Cookie) (*GetKeyboardControlReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(GetKeyboardControlReply)
	v.GlobalAutoRepeat = b[1]
	v.LedMask = get32(b[8:])
	v.KeyClickPercent = b[12]
	v.BellPercent = b[13]
	v.BellPitch = get16(b[14:])
	v.BellDuration = get16(b[16:])
	copy(v.AutoRepeats[0:32], b[20:])
	return v, nil
}

func (c *Conn) Bell(Percent int8) {
	b := c.scratch[0:4]
	put16(b[2:], 1)
	b[0] = 104
	b[1] = byte(Percent)
	c.sendRequest(b)
}

func (c *Conn) ChangePointerControl(AccelerationNumerator int16, AccelerationDenominator int16, Threshold int16, DoAcceleration byte, DoThreshold byte) {
	b := c.scratch[0:12]
	put16(b[2:], 3)
	b[0] = 105
	put16(b[4:], uint16(AccelerationNumerator))
	put16(b[6:], uint16(AccelerationDenominator))
	put16(b[8:], uint16(Threshold))
	b[10] = DoAcceleration
	b[11] = DoThreshold
	c.sendRequest(b)
}

func (c *Conn) GetPointerControlRequest() Cookie {
	b := c.scratch[0:4]
	put16(b[2:], 1)
	b[0] = 106
	return c.sendRequest(b)
}

func (c *Conn) GetPointerControl() (*GetPointerControlReply, os.Error) {
	return c.GetPointerControlReply(c.GetPointerControlRequest())
}

type GetPointerControlReply struct {
	AccelerationNumerator   uint16
	AccelerationDenominator uint16
	Threshold               uint16
}

func (c *Conn) GetPointerControlReply(cookie Cookie) (*GetPointerControlReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(GetPointerControlReply)
	v.AccelerationNumerator = get16(b[8:])
	v.AccelerationDenominator = get16(b[10:])
	v.Threshold = get16(b[12:])
	return v, nil
}

const (
	BlankingNotPreferred = 0
	BlankingPreferred    = 1
	BlankingDefault      = 2
)

const (
	ExposuresNotAllowed = 0
	ExposuresAllowed    = 1
	ExposuresDefault    = 2
)

func (c *Conn) SetScreenSaver(Timeout int16, Interval int16, PreferBlanking byte, AllowExposures byte) {
	b := c.scratch[0:10]
	put16(b[2:], 2)
	b[0] = 107
	put16(b[4:], uint16(Timeout))
	put16(b[6:], uint16(Interval))
	b[8] = PreferBlanking
	b[9] = AllowExposures
	c.sendRequest(b)
}

func (c *Conn) GetScreenSaverRequest() Cookie {
	b := c.scratch[0:4]
	put16(b[2:], 1)
	b[0] = 108
	return c.sendRequest(b)
}

func (c *Conn) GetScreenSaver() (*GetScreenSaverReply, os.Error) {
	return c.GetScreenSaverReply(c.GetScreenSaverRequest())
}

type GetScreenSaverReply struct {
	Timeout        uint16
	Interval       uint16
	PreferBlanking byte
	AllowExposures byte
}

func (c *Conn) GetScreenSaverReply(cookie Cookie) (*GetScreenSaverReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(GetScreenSaverReply)
	v.Timeout = get16(b[8:])
	v.Interval = get16(b[10:])
	v.PreferBlanking = b[12]
	v.AllowExposures = b[13]
	return v, nil
}

const (
	HostModeInsert = 0
	HostModeDelete = 1
)

const (
	FamilyInternet          = 0
	FamilyDECnet            = 1
	FamilyChaos             = 2
	FamilyServerInterpreted = 5
	FamilyInternet6         = 6
)

func (c *Conn) ChangeHosts(Mode byte, Family byte, Address []byte) {
	b := c.scratch[0:8]
	n := 8
	n += pad(len(Address) * 1)
	put16(b[2:], uint16(n/4))
	b[0] = 109
	b[1] = Mode
	b[4] = Family
	put16(b[6:], uint16(len(Address)))
	c.sendRequest(b)
	c.sendBytes(Address[0:len(Address)])
}

type Host struct {
	Family     byte
	AddressLen uint16
	Address    []byte
}

func getHost(b []byte, v *Host) int {
	v.Family = b[0]
	v.AddressLen = get16(b[2:])
	offset := 4
	v.Address = make([]byte, int(v.AddressLen))
	copy(v.Address[0:len(v.Address)], b[offset:])
	offset += len(v.Address) * 1
	return offset
}

// omitting variable length sendHost

func (c *Conn) ListHostsRequest() Cookie {
	b := c.scratch[0:4]
	put16(b[2:], 1)
	b[0] = 110
	return c.sendRequest(b)
}

func (c *Conn) ListHosts() (*ListHostsReply, os.Error) {
	return c.ListHostsReply(c.ListHostsRequest())
}

type ListHostsReply struct {
	Mode     byte
	HostsLen uint16
	Hosts    []Host
}

func (c *Conn) ListHostsReply(cookie Cookie) (*ListHostsReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(ListHostsReply)
	v.Mode = b[1]
	v.HostsLen = get16(b[8:])
	offset := 32
	v.Hosts = make([]Host, int(v.HostsLen))
	for i := 0; i < int(v.HostsLen); i++ {
		offset += getHost(b[offset:], &v.Hosts[i])
	}
	return v, nil
}

const (
	AccessControlDisable = 0
	AccessControlEnable  = 1
)

func (c *Conn) SetAccessControl(Mode byte) {
	b := c.scratch[0:4]
	put16(b[2:], 1)
	b[0] = 111
	b[1] = Mode
	c.sendRequest(b)
}

const (
	CloseDownDestroyAll      = 0
	CloseDownRetainPermanent = 1
	CloseDownRetainTemporary = 2
)

func (c *Conn) SetCloseDownMode(Mode byte) {
	b := c.scratch[0:4]
	put16(b[2:], 1)
	b[0] = 112
	b[1] = Mode
	c.sendRequest(b)
}

const (
	KillAllTemporary = 0
)

func (c *Conn) KillClient(Resource uint32) {
	b := c.scratch[0:8]
	put16(b[2:], 2)
	b[0] = 113
	put32(b[4:], Resource)
	c.sendRequest(b)
}

func (c *Conn) RotateProperties(Window Id, Delta int16, Atoms []Id) {
	b := c.scratch[0:12]
	n := 12
	n += pad(len(Atoms) * 4)
	put16(b[2:], uint16(n/4))
	b[0] = 114
	put32(b[4:], uint32(Window))
	put16(b[8:], uint16(len(Atoms)))
	put16(b[10:], uint16(Delta))
	c.sendRequest(b)
	c.sendIdList(Atoms, len(Atoms))
}

const (
	ScreenSaverReset  = 0
	ScreenSaverActive = 1
)

func (c *Conn) ForceScreenSaver(Mode byte) {
	b := c.scratch[0:4]
	put16(b[2:], 1)
	b[0] = 115
	b[1] = Mode
	c.sendRequest(b)
}

const (
	MappingStatusSuccess = 0
	MappingStatusBusy    = 1
	MappingStatusFailure = 2
)

func (c *Conn) SetPointerMappingRequest(Map []byte) Cookie {
	b := c.scratch[0:4]
	n := 4
	n += pad(len(Map) * 1)
	put16(b[2:], uint16(n/4))
	b[0] = 116
	b[1] = byte(len(Map))
	cookie := c.sendRequest(b)
	c.sendBytes(Map[0:len(Map)])
	return cookie
}

func (c *Conn) SetPointerMapping(Map []byte) (*SetPointerMappingReply, os.Error) {
	return c.SetPointerMappingReply(c.SetPointerMappingRequest(Map))
}

type SetPointerMappingReply struct {
	Status byte
}

func (c *Conn) SetPointerMappingReply(cookie Cookie) (*SetPointerMappingReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(SetPointerMappingReply)
	v.Status = b[1]
	return v, nil
}

func (c *Conn) GetPointerMappingRequest() Cookie {
	b := c.scratch[0:4]
	put16(b[2:], 1)
	b[0] = 117
	return c.sendRequest(b)
}

func (c *Conn) GetPointerMapping() (*GetPointerMappingReply, os.Error) {
	return c.GetPointerMappingReply(c.GetPointerMappingRequest())
}

type GetPointerMappingReply struct {
	MapLen byte
	Map    []byte
}

func (c *Conn) GetPointerMappingReply(cookie Cookie) (*GetPointerMappingReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(GetPointerMappingReply)
	v.MapLen = b[1]
	offset := 32
	v.Map = make([]byte, int(v.MapLen))
	copy(v.Map[0:len(v.Map)], b[offset:])
	offset += len(v.Map) * 1
	return v, nil
}

const (
	MapIndexShift   = 0
	MapIndexLock    = 1
	MapIndexControl = 2
	MapIndex1       = 3
	MapIndex2       = 4
	MapIndex3       = 5
	MapIndex4       = 6
	MapIndex5       = 7
)

func (c *Conn) SetModifierMappingRequest(KeycodesPerModifier byte, Keycodes []byte) Cookie {
	b := c.scratch[0:4]
	n := 4
	n += pad((int(KeycodesPerModifier) * 8) * 1)
	put16(b[2:], uint16(n/4))
	b[0] = 118
	b[1] = KeycodesPerModifier
	cookie := c.sendRequest(b)
	c.sendBytes(Keycodes[0:(int(KeycodesPerModifier) * 8)])
	return cookie
}

func (c *Conn) SetModifierMapping(KeycodesPerModifier byte, Keycodes []byte) (*SetModifierMappingReply, os.Error) {
	return c.SetModifierMappingReply(c.SetModifierMappingRequest(KeycodesPerModifier, Keycodes))
}

type SetModifierMappingReply struct {
	Status byte
}

func (c *Conn) SetModifierMappingReply(cookie Cookie) (*SetModifierMappingReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(SetModifierMappingReply)
	v.Status = b[1]
	return v, nil
}

func (c *Conn) GetModifierMappingRequest() Cookie {
	b := c.scratch[0:4]
	put16(b[2:], 1)
	b[0] = 119
	return c.sendRequest(b)
}

func (c *Conn) GetModifierMapping() (*GetModifierMappingReply, os.Error) {
	return c.GetModifierMappingReply(c.GetModifierMappingRequest())
}

type GetModifierMappingReply struct {
	KeycodesPerModifier byte
	Keycodes            []byte
}

func (c *Conn) GetModifierMappingReply(cookie Cookie) (*GetModifierMappingReply, os.Error) {
	b, error := c.waitForReply(cookie)
	if error != nil {
		return nil, error
	}
	v := new(GetModifierMappingReply)
	v.KeycodesPerModifier = b[1]
	offset := 32
	v.Keycodes = make([]byte, (int(v.KeycodesPerModifier) * 8))
	copy(v.Keycodes[0:len(v.Keycodes)], b[offset:])
	offset += len(v.Keycodes) * 1
	return v, nil
}

func (c *Conn) NoOperation() {
	b := c.scratch[0:4]
	put16(b[2:], 1)
	b[0] = 127
	c.sendRequest(b)
}

func parseEvent(buf []byte) (Event, os.Error) {
	switch buf[0] {
	case KeyPress:
		return getKeyPressEvent(buf), nil
	case KeyRelease:
		return getKeyReleaseEvent(buf), nil
	case ButtonPress:
		return getButtonPressEvent(buf), nil
	case ButtonRelease:
		return getButtonReleaseEvent(buf), nil
	case MotionNotify:
		return getMotionNotifyEvent(buf), nil
	case EnterNotify:
		return getEnterNotifyEvent(buf), nil
	case LeaveNotify:
		return getLeaveNotifyEvent(buf), nil
	case FocusIn:
		return getFocusInEvent(buf), nil
	case FocusOut:
		return getFocusOutEvent(buf), nil
	case KeymapNotify:
		return getKeymapNotifyEvent(buf), nil
	case Expose:
		return getExposeEvent(buf), nil
	case GraphicsExposure:
		return getGraphicsExposureEvent(buf), nil
	case NoExposure:
		return getNoExposureEvent(buf), nil
	case VisibilityNotify:
		return getVisibilityNotifyEvent(buf), nil
	case CreateNotify:
		return getCreateNotifyEvent(buf), nil
	case DestroyNotify:
		return getDestroyNotifyEvent(buf), nil
	case UnmapNotify:
		return getUnmapNotifyEvent(buf), nil
	case MapNotify:
		return getMapNotifyEvent(buf), nil
	case MapRequest:
		return getMapRequestEvent(buf), nil
	case ReparentNotify:
		return getReparentNotifyEvent(buf), nil
	case ConfigureNotify:
		return getConfigureNotifyEvent(buf), nil
	case ConfigureRequest:
		return getConfigureRequestEvent(buf), nil
	case GravityNotify:
		return getGravityNotifyEvent(buf), nil
	case ResizeRequest:
		return getResizeRequestEvent(buf), nil
	case CirculateNotify:
		return getCirculateNotifyEvent(buf), nil
	case CirculateRequest:
		return getCirculateRequestEvent(buf), nil
	case PropertyNotify:
		return getPropertyNotifyEvent(buf), nil
	case SelectionClear:
		return getSelectionClearEvent(buf), nil
	case SelectionRequest:
		return getSelectionRequestEvent(buf), nil
	case SelectionNotify:
		return getSelectionNotifyEvent(buf), nil
	case ColormapNotify:
		return getColormapNotifyEvent(buf), nil
	case ClientMessage:
		return getClientMessageEvent(buf), nil
	case MappingNotify:
		return getMappingNotifyEvent(buf), nil
	}
	return nil, os.NewError("unknown event type")
}

var errorNames = map[byte]string{
	BadRequest: "Request",
	BadValue: "Value",
	BadWindow: "Window",
	BadPixmap: "Pixmap",
	BadAtom: "Atom",
	BadCursor: "Cursor",
	BadFont: "Font",
	BadMatch: "Match",
	BadDrawable: "Drawable",
	BadAccess: "Access",
	BadAlloc: "Alloc",
	BadColormap: "Colormap",
	BadGContext: "GContext",
	BadIDChoice: "IDChoice",
	BadName: "Name",
	BadLength: "Length",
	BadImplementation: "Implementation",
}