// 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",
}