From 05d8ec6a16acf88c5ae7521d86131f5ea7f9b4e4 Mon Sep 17 00:00:00 2001
From: "Andrew Gallant (Ocelot)" <Andrew.Gallant@tufts.edu>
Date: Mon, 30 Apr 2012 02:40:55 -0400
Subject: complete and total overhaul like i promised. things are much easier
 to reason about. still not working yet though.

---
 nexgb/xgbgen/type.go | 365 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 365 insertions(+)
 create mode 100644 nexgb/xgbgen/type.go

(limited to 'nexgb/xgbgen/type.go')

diff --git a/nexgb/xgbgen/type.go b/nexgb/xgbgen/type.go
new file mode 100644
index 0000000..1574922
--- /dev/null
+++ b/nexgb/xgbgen/type.go
@@ -0,0 +1,365 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+)
+
+type Type interface {
+	Initialize(p *Protocol)
+	SrcName() string
+	XmlName() string
+	Size() Size
+
+	Define(c *Context)
+}
+
+// Translation is used *only* when transitioning from XML types to
+// our better representation. They are placeholders for the real types (below)
+// that will replace them.
+type Translation struct {
+	xmlName string
+}
+
+func newTranslation(name string) *Translation {
+	return &Translation{xmlName: name}
+}
+
+// RealType takes 'XmlName' and finds its real concrete type in our Protocol.
+// It is an error if we can't find such a type.
+func (t *Translation) RealType(p *Protocol) Type {
+	// Check to see if there is a namespace. If so, strip it and use it to
+	// make sure we only look for a type in that protocol.
+	namespace, typeName := "", t.XmlName()
+	if ni := strings.Index(t.XmlName(), ":"); ni > -1 {
+		namespace, typeName = strings.ToLower(typeName[:ni]), typeName[ni+1:]
+	}
+
+	if len(namespace) == 0 || namespace == strings.ToLower(p.Name) {
+		for _, typ := range p.Types {
+			if typeName == typ.XmlName() {
+				return typ
+			}
+		}
+	}
+	for _, imp := range p.Imports {
+		if len(namespace) == 0 || namespace == strings.ToLower(imp.Name) {
+			for _, typ := range imp.Types {
+				if typeName == typ.XmlName() {
+					return typ
+				}
+			}
+		}
+	}
+	panic("Could not find real type for translation type: " + t.XmlName())
+}
+
+func (t *Translation) SrcName() string {
+	panic("it is illegal to call SrcName on a translation type")
+}
+
+func (t *Translation) XmlName() string {
+	return t.xmlName
+}
+
+func (t *Translation) Size() Size {
+	panic("it is illegal to call Size on a translation type")
+}
+
+func (t *Translation) Define(c *Context) {
+	panic("it is illegal to call Define on a translation type")
+}
+
+func (t *Translation) Initialize(p *Protocol) {
+	panic("it is illegal to call Initialize on a translation type")
+}
+
+type Base struct {
+	srcName string
+	xmlName string
+	size Size
+}
+
+func (b *Base) SrcName() string {
+	return b.srcName
+}
+
+func (b *Base) XmlName() string {
+	return b.xmlName
+}
+
+func (b *Base) Size() Size {
+	return b.size
+}
+
+func (b *Base) Initialize(p *Protocol) {
+	b.srcName = TypeSrcName(p, b)
+}
+
+type Enum struct {
+	srcName string
+	xmlName string
+	Items []*EnumItem
+}
+
+type EnumItem struct {
+	srcName string
+	xmlName string
+	Expr Expression
+}
+
+func (enum *Enum) SrcName() string {
+	return enum.srcName
+}
+
+func (enum *Enum) XmlName() string {
+	return enum.xmlName
+}
+
+func (enum *Enum) Size() Size {
+	panic("Cannot take size of enum")
+}
+
+func (enum *Enum) Initialize(p *Protocol) {
+	enum.srcName = TypeSrcName(p, enum)
+	for _, item := range enum.Items {
+		item.srcName = SrcName(item.xmlName)
+		if item.Expr != nil {
+			item.Expr.Initialize(p)
+		}
+	}
+}
+
+type Resource struct {
+	srcName string
+	xmlName string
+}
+
+func (r *Resource) SrcName() string {
+	return r.srcName
+}
+
+func (r *Resource) XmlName() string {
+	return r.xmlName
+}
+
+func (r *Resource) Size() Size {
+	return newFixedSize(BaseTypeSizes["Id"])
+}
+
+func (r *Resource) Initialize(p *Protocol) {
+	r.srcName = TypeSrcName(p, r)
+}
+
+type TypeDef struct {
+	srcName string
+	xmlName string
+	Old Type
+}
+
+func (t *TypeDef) SrcName() string {
+	return t.srcName
+}
+
+func (t *TypeDef) XmlName() string {
+	return t.xmlName
+}
+
+func (t *TypeDef) Size() Size {
+	return t.Old.Size()
+}
+
+func (t *TypeDef) Initialize(p *Protocol) {
+	t.Old = t.Old.(*Translation).RealType(p)
+	t.srcName = TypeSrcName(p, t)
+}
+
+type Event struct {
+	srcName string
+	xmlName string
+	Number int
+	NoSequence bool
+	Fields []Field
+}
+
+func (e *Event) SrcName() string {
+	return e.srcName
+}
+
+func (e *Event) XmlName() string {
+	return e.xmlName
+}
+
+func (e *Event) Size() Size {
+	panic("Cannot take size of Event type.")
+}
+
+func (e *Event) Initialize(p *Protocol) {
+	e.srcName = TypeSrcName(p, e)
+	for _, field := range e.Fields {
+		field.Initialize(p)
+	}
+}
+
+func (e *Event) EvType() string {
+	return fmt.Sprintf("%sEvent", e.srcName)
+}
+
+type EventCopy struct {
+	srcName string
+	xmlName string
+	Old Type
+	Number int
+}
+
+func (e *EventCopy) SrcName() string {
+	return e.srcName
+}
+
+func (e *EventCopy) XmlName() string {
+	return e.xmlName
+}
+
+func (e *EventCopy) Size() Size {
+	panic("Cannot take size of EventCopy type.")
+}
+
+func (e *EventCopy) Initialize(p *Protocol) {
+	e.srcName = TypeSrcName(p, e)
+	e.Old = e.Old.(*Translation).RealType(p)
+	if _, ok := e.Old.(*Event); !ok {
+		panic("an EventCopy's old type *must* be *Event")
+	}
+}
+
+func (e *EventCopy) EvType() string {
+	return fmt.Sprintf("%sEvent", e.srcName)
+}
+
+type Error struct {
+	srcName string
+	xmlName string
+	Number int
+	Fields []Field
+}
+
+func (e *Error) SrcName() string {
+	return e.srcName
+}
+
+func (e *Error) XmlName() string {
+	return e.xmlName
+}
+
+func (e *Error) Size() Size {
+	panic("Cannot take size of Error type.")
+}
+
+func (e *Error) Initialize(p *Protocol) {
+	e.srcName = TypeSrcName(p, e)
+}
+
+func (e *Error) ErrConst() string {
+	return fmt.Sprintf("Bad%s", e.srcName)
+}
+
+func (e *Error) ErrType() string {
+	return fmt.Sprintf("%sError", e.srcName)
+}
+
+type ErrorCopy struct {
+	srcName string
+	xmlName string
+	Old Type
+	Number int
+}
+
+func (e *ErrorCopy) SrcName() string {
+	return e.srcName
+}
+
+func (e *ErrorCopy) XmlName() string {
+	return e.xmlName
+}
+
+func (e *ErrorCopy) Size() Size {
+	panic("Cannot take size of ErrorCopy type.")
+}
+
+func (e *ErrorCopy) Initialize(p *Protocol) {
+	e.srcName = TypeSrcName(p, e)
+	e.Old = e.Old.(*Translation).RealType(p)
+	if _, ok := e.Old.(*Error); !ok {
+		panic("an ErrorCopy's old type *must* be *Event")
+	}
+}
+
+func (e *ErrorCopy) ErrConst() string {
+	return fmt.Sprintf("Bad%s", e.srcName)
+}
+
+func (e *ErrorCopy) ErrType() string {
+	return fmt.Sprintf("%sError", e.srcName)
+}
+
+type Struct struct {
+	srcName string
+	xmlName string
+	Fields []Field
+}
+
+func (s *Struct) SrcName() string {
+	return s.srcName
+}
+
+func (s *Struct) XmlName() string {
+	return s.xmlName
+}
+
+func (s *Struct) Size() Size {
+	size := newFixedSize(0)
+	for _, field := range s.Fields {
+		size = size.Add(field.Size())
+	}
+	return size
+}
+
+func (s *Struct) Initialize(p *Protocol) {
+	s.srcName = TypeSrcName(p, s)
+	for _, field := range s.Fields {
+		field.Initialize(p)
+	}
+}
+
+type Union struct {
+	srcName string
+	xmlName string
+	Fields []Field
+}
+
+func (u *Union) SrcName() string {
+	return u.srcName
+}
+
+func (u *Union) XmlName() string {
+	return u.xmlName
+}
+
+// Size for Union is broken. At least, it's broken for XKB.
+// It *looks* like the protocol inherently relies on some amount of
+// memory unsafety, since some members of unions in XKB are *variable* in
+// length! The only thing I can come up with, maybe, is when a union has
+// variable size, simply return the raw bytes. Then it's up to the user to
+// pass those raw bytes into the appropriate New* constructor. GROSS!
+// As of now, just pluck out the first field and return that size. This
+// should work for union elements in randr.xml and xproto.xml.
+func (u *Union) Size() Size {
+	return u.Fields[0].Size()
+}
+
+func (u *Union) Initialize(p *Protocol) {
+	u.srcName = TypeSrcName(p, u)
+	for _, field := range u.Fields {
+		field.Initialize(p)
+	}
+}
-- 
cgit v1.2.3-70-g09d2


From 2a2d8653b3a7918dfb00dcca8937b0e878279c70 Mon Sep 17 00:00:00 2001
From: "Andrew Gallant (Ocelot)" <Andrew.Gallant@tufts.edu>
Date: Mon, 30 Apr 2012 02:44:31 -0400
Subject: gofmt

---
 nexgb/xgbgen/bufcount.go       | 15 --------
 nexgb/xgbgen/context.go        |  4 +--
 nexgb/xgbgen/expression.go     | 11 +++---
 nexgb/xgbgen/field.go          | 19 +++++-----
 nexgb/xgbgen/go.go             | 57 +++++++++++++++--------------
 nexgb/xgbgen/main.go           |  1 -
 nexgb/xgbgen/morph.go          | 50 --------------------------
 nexgb/xgbgen/representation.go | 17 +++++----
 nexgb/xgbgen/size.go           |  1 -
 nexgb/xgbgen/translation.go    | 75 +++++++++++++++++++-------------------
 nexgb/xgbgen/type.go           | 32 ++++++++---------
 nexgb/xgbgen/xml.go            | 81 +++++++++++++++++++++---------------------
 nexgb/xgbgen/xml_expression.go | 16 ++++-----
 nexgb/xgbgen/xml_fields.go     | 17 ++++-----
 14 files changed, 163 insertions(+), 233 deletions(-)
 delete mode 100644 nexgb/xgbgen/bufcount.go
 delete mode 100644 nexgb/xgbgen/morph.go

(limited to 'nexgb/xgbgen/type.go')

diff --git a/nexgb/xgbgen/bufcount.go b/nexgb/xgbgen/bufcount.go
deleted file mode 100644
index c3a5645..0000000
--- a/nexgb/xgbgen/bufcount.go
+++ /dev/null
@@ -1,15 +0,0 @@
-package main
-
-/*
-	A buffer count is a mechanism by which to keep track of which byte one
-	is reading or writing to/from the wire.
-
-	It's an abstraction over the fact that while such a counter is usually
-	fixed, it can be made variable based on values at run-time.
-*/
-
-type BufCount struct {
-	Fixed int
-	Exprs []*Expression
-}
-
diff --git a/nexgb/xgbgen/context.go b/nexgb/xgbgen/context.go
index d3cbb81..67801c7 100644
--- a/nexgb/xgbgen/context.go
+++ b/nexgb/xgbgen/context.go
@@ -9,7 +9,7 @@ import (
 
 type Context struct {
 	protocol *Protocol
-	out *bytes.Buffer
+	out      *bytes.Buffer
 }
 
 func newContext() *Context {
@@ -20,7 +20,7 @@ func newContext() *Context {
 
 // Putln calls put and adds a new line to the end of 'format'.
 func (c *Context) Putln(format string, v ...interface{}) {
-	c.Put(format + "\n", v...)
+	c.Put(format+"\n", v...)
 }
 
 // Put is a short alias to write to 'out'.
diff --git a/nexgb/xgbgen/expression.go b/nexgb/xgbgen/expression.go
index a163692..7099c25 100644
--- a/nexgb/xgbgen/expression.go
+++ b/nexgb/xgbgen/expression.go
@@ -14,7 +14,7 @@ type Expression interface {
 }
 
 type BinaryOp struct {
-	Op string
+	Op    string
 	Expr1 Expression
 	Expr2 Expression
 }
@@ -23,7 +23,7 @@ func newBinaryOp(op string, expr1, expr2 Expression) Expression {
 	switch {
 	case expr1 != nil && expr2 != nil:
 		return &BinaryOp{
-			Op: op,
+			Op:    op,
 			Expr1: expr1,
 			Expr2: expr2,
 		}
@@ -79,7 +79,7 @@ func (e *BinaryOp) Initialize(p *Protocol) {
 }
 
 type UnaryOp struct {
-	Op string
+	Op   string
 	Expr Expression
 }
 
@@ -159,7 +159,7 @@ func (e *Value) String() string {
 	return e.Reduce("", "")
 }
 
-func (e *Value) Initialize(p *Protocol) { }
+func (e *Value) Initialize(p *Protocol) {}
 
 type Bit struct {
 	b uint
@@ -181,7 +181,7 @@ func (e *Bit) String() string {
 	return e.Reduce("", "")
 }
 
-func (e *Bit) Initialize(p *Protocol) { }
+func (e *Bit) Initialize(p *Protocol) {}
 
 type FieldRef struct {
 	Name string
@@ -273,4 +273,3 @@ func (e *SumOf) String() string {
 func (e *SumOf) Initialize(p *Protocol) {
 	e.Name = SrcName(e.Name)
 }
-
diff --git a/nexgb/xgbgen/field.go b/nexgb/xgbgen/field.go
index a659e6e..ed113e0 100644
--- a/nexgb/xgbgen/field.go
+++ b/nexgb/xgbgen/field.go
@@ -31,7 +31,7 @@ func (p *PadField) Size() Size {
 type SingleField struct {
 	srcName string
 	xmlName string
-	Type Type
+	Type    Type
 }
 
 func (f *SingleField) Initialize(p *Protocol) {
@@ -52,9 +52,9 @@ func (f *SingleField) Size() Size {
 }
 
 type ListField struct {
-	srcName string
-	xmlName string
-	Type Type
+	srcName    string
+	xmlName    string
+	Type       Type
 	LengthExpr Expression
 }
 
@@ -85,8 +85,8 @@ type LocalField struct {
 type ExprField struct {
 	srcName string
 	xmlName string
-	Type Type
-	Expr Expression
+	Type    Type
+	Expr    Expression
 }
 
 func (f *ExprField) SrcName() string {
@@ -132,8 +132,8 @@ func (f *ValueField) Initialize(p *Protocol) {
 }
 
 type SwitchField struct {
-	Name string
-	Expr Expression
+	Name     string
+	Expr     Expression
 	Bitcases []*Bitcase
 }
 
@@ -165,6 +165,5 @@ func (f *SwitchField) Initialize(p *Protocol) {
 
 type Bitcase struct {
 	Fields []Field
-	Expr Expression
+	Expr   Expression
 }
-
diff --git a/nexgb/xgbgen/go.go b/nexgb/xgbgen/go.go
index ac3ed2c..014b76b 100644
--- a/nexgb/xgbgen/go.go
+++ b/nexgb/xgbgen/go.go
@@ -16,37 +16,37 @@ var xgbGenResourceIdName = "Id"
 // XML protocol description will produce an invalid Go program.
 // The types on the left *never* show themselves in the source.
 var BaseTypeMap = map[string]string{
-	"CARD8": "byte",
+	"CARD8":  "byte",
 	"CARD16": "uint16",
 	"CARD32": "uint32",
-	"INT8": "int8",
-	"INT16": "int16",
-	"INT32": "int32",
-	"BYTE": "byte",
-	"BOOL": "bool",
-	"float": "float64",
+	"INT8":   "int8",
+	"INT16":  "int16",
+	"INT32":  "int32",
+	"BYTE":   "byte",
+	"BOOL":   "bool",
+	"float":  "float64",
 	"double": "float64",
-	"char": "byte",
-	"void": "byte",
-	"Id": "Id",
+	"char":   "byte",
+	"void":   "byte",
+	"Id":     "Id",
 }
 
 // BaseTypeSizes should have precisely the same keys as in BaseTypeMap,
 // and the values should correspond to the size of the type in bytes.
 var BaseTypeSizes = map[string]uint{
-	"CARD8": 1,
+	"CARD8":  1,
 	"CARD16": 2,
 	"CARD32": 4,
-	"INT8": 1,
-	"INT16": 2,
-	"INT32": 4,
-	"BYTE": 1,
-	"BOOL": 1,
-	"float": 4,
+	"INT8":   1,
+	"INT16":  2,
+	"INT32":  4,
+	"BYTE":   1,
+	"BOOL":   1,
+	"float":  4,
 	"double": 8,
-	"char": 1,
-	"void": 1,
-	"Id": 4,
+	"char":   1,
+	"void":   1,
+	"Id":     4,
 }
 
 // TypeMap is a map from types in the XML to type names that is used
@@ -54,13 +54,13 @@ var BaseTypeSizes = map[string]uint{
 // type is replaced with the value type.
 var TypeMap = map[string]string{
 	"VISUALTYPE": "VisualInfo",
-	"DEPTH": "DepthInfo",
-	"SCREEN": "ScreenInfo",
-	"Setup": "SetupInfo",
+	"DEPTH":      "DepthInfo",
+	"SCREEN":     "ScreenInfo",
+	"Setup":      "SetupInfo",
 }
 
 // NameMap is the same as TypeMap, but for names.
-var NameMap = map[string]string{ }
+var NameMap = map[string]string{}
 
 // Reading, writing and defining...
 
@@ -151,8 +151,8 @@ func (s *Struct) ReadList(c *Context) {
 	c.Putln("consumed := 0")
 	c.Putln("consumed = 0 + consumed // no-op") // dirty hack for a no-op
 	c.Putln("for i := 0; i < length; i++ {")
-		c.Putln("v[i], consumed = New%s(buf[b:])", s.SrcName())
-		c.Putln("b += consumed")
+	c.Putln("v[i], consumed = New%s(buf[b:])", s.SrcName())
+	c.Putln("b += consumed")
 	c.Putln("}")
 
 	c.Putln("return v, pad(b)")
@@ -347,14 +347,14 @@ func (f *ListField) Read(c *Context) {
 		length := f.LengthExpr.Reduce("v.", "")
 		c.Putln("v.%s = make([]Id, %s)", f.SrcName(), length)
 		c.Putln("for i := 0; i < %s; i++ {", length)
-			ReadSimpleSingleField(c, fmt.Sprintf("v.%s[i]", f.SrcName()), t)
+		ReadSimpleSingleField(c, fmt.Sprintf("v.%s[i]", f.SrcName()), t)
 		c.Putln("}")
 		c.Putln("")
 	case *Base:
 		length := f.LengthExpr.Reduce("v.", "")
 		c.Putln("v.%s = make([]%s, %s)", f.SrcName(), t.SrcName(), length)
 		c.Putln("for i := 0; i < %s; i++ {", length)
-			ReadSimpleSingleField(c, fmt.Sprintf("v.%s[i]", f.SrcName()), t)
+		ReadSimpleSingleField(c, fmt.Sprintf("v.%s[i]", f.SrcName()), t)
 		c.Putln("}")
 		c.Putln("")
 	case *Struct:
@@ -408,4 +408,3 @@ func (f *SwitchField) Define(c *Context) {
 func (f *SwitchField) Read(c *Context) {
 	c.Putln("// reading switch field: %s (%s)", f.Name, f.Expr)
 }
-
diff --git a/nexgb/xgbgen/main.go b/nexgb/xgbgen/main.go
index 33f7971..fd5eac7 100644
--- a/nexgb/xgbgen/main.go
+++ b/nexgb/xgbgen/main.go
@@ -62,4 +62,3 @@ func main() {
 		}
 	}
 }
-
diff --git a/nexgb/xgbgen/morph.go b/nexgb/xgbgen/morph.go
deleted file mode 100644
index c39b333..0000000
--- a/nexgb/xgbgen/morph.go
+++ /dev/null
@@ -1,50 +0,0 @@
-
-// Morph cascades down all of the XML and calls each type's corresponding
-// Morph function with itself as an argument (the context).
-func (x *XML) Morph(c *Context) {
-	// Start the header...
-	c.Putln("package xgb")
-	c.Putln("/*")
-	c.Putln("\tX protocol API for '%s.xml'.", c.xml.Header)
-	c.Putln("\tThis file is automatically generated. Edit at your own peril!")
-	c.Putln("\tGenerated on %s",
-		time.Now().Format("Jan 2, 2006 at 3:04:05pm MST"))
-	c.Putln("*/")
-	c.Putln("")
-
-	x.Imports.Morph(c)
-	c.Putln("")
-
-	x.Enums.Morph(c)
-	c.Putln("")
-
-	x.Xids.Morph(c)
-	c.Putln("")
-
-	x.XidUnions.Morph(c)
-	c.Putln("")
-
-	x.TypeDefs.Morph(c)
-	c.Putln("")
-
-	x.Structs.Morph(c)
-	c.Putln("")
-
-	x.Unions.Morph(c)
-	c.Putln("")
-
-	x.Requests.Morph(c)
-	c.Putln("")
-
-	x.Errors.Morph(c)
-	c.Putln("")
-
-	x.ErrorCopies.Morph(c)
-	c.Putln("")
-
-	x.Events.Morph(c)
-	c.Putln("")
-
-	x.EventCopies.Morph(c)
-	c.Putln("")
-}
diff --git a/nexgb/xgbgen/representation.go b/nexgb/xgbgen/representation.go
index 928e219..2d33a45 100644
--- a/nexgb/xgbgen/representation.go
+++ b/nexgb/xgbgen/representation.go
@@ -1,14 +1,14 @@
 package main
 
 type Protocol struct {
-	Name string
-	ExtXName string
-	ExtName string
+	Name         string
+	ExtXName     string
+	ExtName      string
 	MajorVersion string
 	MinorVersion string
 
-	Imports []*Protocol
-	Types []Type
+	Imports  []*Protocol
+	Types    []Type
 	Requests []*Request
 }
 
@@ -28,10 +28,10 @@ func (p *Protocol) Initialize() {
 type Request struct {
 	srcName string
 	xmlName string
-	Opcode int
+	Opcode  int
 	Combine bool
-	Fields []Field
-	Reply *Reply
+	Fields  []Field
+	Reply   *Reply
 }
 
 func (r *Request) Initialize(p *Protocol) {
@@ -53,4 +53,3 @@ func (r *Reply) Initialize(p *Protocol) {
 		field.Initialize(p)
 	}
 }
-
diff --git a/nexgb/xgbgen/size.go b/nexgb/xgbgen/size.go
index d00e297..70edb8f 100644
--- a/nexgb/xgbgen/size.go
+++ b/nexgb/xgbgen/size.go
@@ -19,4 +19,3 @@ func (s1 Size) Add(s2 Size) Size {
 func (s1 Size) Multiply(s2 Size) Size {
 	return Size{newBinaryOp("*", s1, s2)}
 }
-
diff --git a/nexgb/xgbgen/translation.go b/nexgb/xgbgen/translation.go
index 85e756d..36daa8b 100644
--- a/nexgb/xgbgen/translation.go
+++ b/nexgb/xgbgen/translation.go
@@ -1,4 +1,5 @@
 package main
+
 /*
 	translation.go provides a 'Translate' method on every XML type that converts
 	the XML type into our "better" representation.
@@ -19,14 +20,14 @@ import (
 
 func (xml *XML) Translate() *Protocol {
 	protocol := &Protocol{
-		Name: xml.Header,
-		ExtXName: xml.ExtensionXName,
-		ExtName: xml.ExtensionName,
+		Name:         xml.Header,
+		ExtXName:     xml.ExtensionXName,
+		ExtName:      xml.ExtensionName,
 		MajorVersion: xml.MajorVersion,
 		MinorVersion: xml.MinorVersion,
 
-		Imports: make([]*Protocol, 0),
-		Types: make([]Type, 0),
+		Imports:  make([]*Protocol, 0),
+		Types:    make([]Type, 0),
 		Requests: make([]*Request, len(xml.Requests)),
 	}
 
@@ -40,7 +41,7 @@ func (xml *XML) Translate() *Protocol {
 		newBaseType := &Base{
 			srcName: srcName,
 			xmlName: xmlName,
-			size: newFixedSize(BaseTypeSizes[xmlName]),
+			size:    newFixedSize(BaseTypeSizes[xmlName]),
 		}
 		protocol.Types = append(protocol.Types, newBaseType)
 	}
@@ -105,12 +106,12 @@ func (xml *XML) Translate() *Protocol {
 func (x *XMLEnum) Translate() *Enum {
 	enum := &Enum{
 		xmlName: x.Name,
-		Items: make([]*EnumItem, len(x.Items)),
+		Items:   make([]*EnumItem, len(x.Items)),
 	}
 	for i, item := range x.Items {
 		enum.Items[i] = &EnumItem{
 			xmlName: item.Name,
-			Expr: item.Expr.Translate(),
+			Expr:    item.Expr.Translate(),
 		}
 	}
 	return enum
@@ -125,16 +126,16 @@ func (x *XMLXid) Translate() *Resource {
 func (x *XMLTypeDef) Translate() *TypeDef {
 	return &TypeDef{
 		xmlName: x.New,
-		Old: newTranslation(x.Old),
+		Old:     newTranslation(x.Old),
 	}
 }
 
 func (x *XMLEvent) Translate() *Event {
 	ev := &Event{
-		xmlName: x.Name,
-		Number: x.Number,
+		xmlName:    x.Name,
+		Number:     x.Number,
 		NoSequence: x.NoSequence,
-		Fields: make([]Field, len(x.Fields)),
+		Fields:     make([]Field, len(x.Fields)),
 	}
 	for i, field := range x.Fields {
 		ev.Fields[i] = field.Translate()
@@ -145,16 +146,16 @@ func (x *XMLEvent) Translate() *Event {
 func (x *XMLEventCopy) Translate() *EventCopy {
 	return &EventCopy{
 		xmlName: x.Name,
-		Number: x.Number,
-		Old: newTranslation(x.Ref),
+		Number:  x.Number,
+		Old:     newTranslation(x.Ref),
 	}
 }
 
 func (x *XMLError) Translate() *Error {
 	err := &Error{
 		xmlName: x.Name,
-		Number: x.Number,
-		Fields: make([]Field, len(x.Fields)),
+		Number:  x.Number,
+		Fields:  make([]Field, len(x.Fields)),
 	}
 	for i, field := range x.Fields {
 		err.Fields[i] = field.Translate()
@@ -165,15 +166,15 @@ func (x *XMLError) Translate() *Error {
 func (x *XMLErrorCopy) Translate() *ErrorCopy {
 	return &ErrorCopy{
 		xmlName: x.Name,
-		Number: x.Number,
-		Old: newTranslation(x.Ref),
+		Number:  x.Number,
+		Old:     newTranslation(x.Ref),
 	}
 }
 
 func (x *XMLStruct) Translate() *Struct {
 	s := &Struct{
 		xmlName: x.Name,
-		Fields: make([]Field, len(x.Fields)),
+		Fields:  make([]Field, len(x.Fields)),
 	}
 	for i, field := range x.Fields {
 		s.Fields[i] = field.Translate()
@@ -184,7 +185,7 @@ func (x *XMLStruct) Translate() *Struct {
 func (x *XMLUnion) Translate() *Union {
 	u := &Union{
 		xmlName: x.Name,
-		Fields: make([]Field, len(x.Fields)),
+		Fields:  make([]Field, len(x.Fields)),
 	}
 	for i, field := range x.Fields {
 		u.Fields[i] = field.Translate()
@@ -195,10 +196,10 @@ func (x *XMLUnion) Translate() *Union {
 func (x *XMLRequest) Translate() *Request {
 	r := &Request{
 		xmlName: x.Name,
-		Opcode: x.Opcode,
+		Opcode:  x.Opcode,
 		Combine: x.Combine,
-		Fields: make([]Field, len(x.Fields)),
-		Reply: x.Reply.Translate(),
+		Fields:  make([]Field, len(x.Fields)),
+		Reply:   x.Reply.Translate(),
 	}
 	for i, field := range x.Fields {
 		r.Fields[i] = field.Translate()
@@ -211,7 +212,7 @@ func (x *XMLRequest) Translate() *Request {
 	// (i.e., a parameter in the caller but does not get send over the wire.)
 	stringLenLocal := &LocalField{&SingleField{
 		xmlName: "string_len",
-		Type: newTranslation("CARD16"),
+		Type:    newTranslation("CARD16"),
 	}}
 	r.Fields = append(r.Fields, stringLenLocal)
 
@@ -243,7 +244,7 @@ func (x *XMLExpression) Translate() Expression {
 			log.Panicf("'op' found %d expressions; expected 2.", len(x.Exprs))
 		}
 		return &BinaryOp{
-			Op: x.Op,
+			Op:    x.Op,
 			Expr1: x.Exprs[0].Translate(),
 			Expr2: x.Exprs[1].Translate(),
 		}
@@ -252,7 +253,7 @@ func (x *XMLExpression) Translate() Expression {
 			log.Panicf("'unop' found %d expressions; expected 1.", len(x.Exprs))
 		}
 		return &UnaryOp{
-			Op: x.Op,
+			Op:   x.Op,
 			Expr: x.Exprs[0].Translate(),
 		}
 	case "popcount":
@@ -279,7 +280,7 @@ func (x *XMLExpression) Translate() Expression {
 				x.Data)
 		}
 		if bit < 0 || bit > 31 {
-			log.Panicf("A 'bit' literal must be in the range [0, 31], but " +
+			log.Panicf("A 'bit' literal must be in the range [0, 31], but "+
 				" is %d", bit)
 		}
 		return &Bit{
@@ -300,7 +301,7 @@ func (x *XMLExpression) Translate() Expression {
 		}
 	}
 
-	log.Panicf("Unrecognized tag '%s' in expression context. Expected one of " +
+	log.Panicf("Unrecognized tag '%s' in expression context. Expected one of "+
 		"op, fieldref, value, bit, enumref, unop, sumof or popcount.",
 		x.XMLName.Local)
 	panic("unreachable")
@@ -315,24 +316,24 @@ func (x *XMLField) Translate() Field {
 	case "field":
 		return &SingleField{
 			xmlName: x.Name,
-			Type: newTranslation(x.Type),
+			Type:    newTranslation(x.Type),
 		}
 	case "list":
 		return &ListField{
-			xmlName: x.Name,
-			Type: newTranslation(x.Type),
+			xmlName:    x.Name,
+			Type:       newTranslation(x.Type),
 			LengthExpr: x.Expr.Translate(),
 		}
 	case "localfield":
 		return &LocalField{&SingleField{
 			xmlName: x.Name,
-			Type: newTranslation(x.Type),
+			Type:    newTranslation(x.Type),
 		}}
 	case "exprfield":
 		return &ExprField{
 			xmlName: x.Name,
-			Type: newTranslation(x.Type),
-			Expr: x.Expr.Translate(),
+			Type:    newTranslation(x.Type),
+			Expr:    x.Expr.Translate(),
 		}
 	case "valueparam":
 		return &ValueField{
@@ -342,8 +343,8 @@ func (x *XMLField) Translate() Field {
 		}
 	case "switch":
 		swtch := &SwitchField{
-			Name: x.Name,
-			Expr: x.Expr.Translate(),
+			Name:     x.Name,
+			Expr:     x.Expr.Translate(),
 			Bitcases: make([]*Bitcase, len(x.Bitcases)),
 		}
 		for i, bitcase := range x.Bitcases {
@@ -358,7 +359,7 @@ func (x *XMLField) Translate() Field {
 
 func (x *XMLBitcase) Translate() *Bitcase {
 	b := &Bitcase{
-		Expr: x.Expr().Translate(),
+		Expr:   x.Expr().Translate(),
 		Fields: make([]Field, len(x.Fields)),
 	}
 	for i, field := range x.Fields {
diff --git a/nexgb/xgbgen/type.go b/nexgb/xgbgen/type.go
index 1574922..9fbef65 100644
--- a/nexgb/xgbgen/type.go
+++ b/nexgb/xgbgen/type.go
@@ -77,7 +77,7 @@ func (t *Translation) Initialize(p *Protocol) {
 type Base struct {
 	srcName string
 	xmlName string
-	size Size
+	size    Size
 }
 
 func (b *Base) SrcName() string {
@@ -99,13 +99,13 @@ func (b *Base) Initialize(p *Protocol) {
 type Enum struct {
 	srcName string
 	xmlName string
-	Items []*EnumItem
+	Items   []*EnumItem
 }
 
 type EnumItem struct {
 	srcName string
 	xmlName string
-	Expr Expression
+	Expr    Expression
 }
 
 func (enum *Enum) SrcName() string {
@@ -154,7 +154,7 @@ func (r *Resource) Initialize(p *Protocol) {
 type TypeDef struct {
 	srcName string
 	xmlName string
-	Old Type
+	Old     Type
 }
 
 func (t *TypeDef) SrcName() string {
@@ -175,11 +175,11 @@ func (t *TypeDef) Initialize(p *Protocol) {
 }
 
 type Event struct {
-	srcName string
-	xmlName string
-	Number int
+	srcName    string
+	xmlName    string
+	Number     int
 	NoSequence bool
-	Fields []Field
+	Fields     []Field
 }
 
 func (e *Event) SrcName() string {
@@ -208,8 +208,8 @@ func (e *Event) EvType() string {
 type EventCopy struct {
 	srcName string
 	xmlName string
-	Old Type
-	Number int
+	Old     Type
+	Number  int
 }
 
 func (e *EventCopy) SrcName() string {
@@ -239,8 +239,8 @@ func (e *EventCopy) EvType() string {
 type Error struct {
 	srcName string
 	xmlName string
-	Number int
-	Fields []Field
+	Number  int
+	Fields  []Field
 }
 
 func (e *Error) SrcName() string {
@@ -270,8 +270,8 @@ func (e *Error) ErrType() string {
 type ErrorCopy struct {
 	srcName string
 	xmlName string
-	Old Type
-	Number int
+	Old     Type
+	Number  int
 }
 
 func (e *ErrorCopy) SrcName() string {
@@ -305,7 +305,7 @@ func (e *ErrorCopy) ErrType() string {
 type Struct struct {
 	srcName string
 	xmlName string
-	Fields []Field
+	Fields  []Field
 }
 
 func (s *Struct) SrcName() string {
@@ -334,7 +334,7 @@ func (s *Struct) Initialize(p *Protocol) {
 type Union struct {
 	srcName string
 	xmlName string
-	Fields []Field
+	Fields  []Field
 }
 
 func (u *Union) SrcName() string {
diff --git a/nexgb/xgbgen/xml.go b/nexgb/xgbgen/xml.go
index 7e50831..f219c2d 100644
--- a/nexgb/xgbgen/xml.go
+++ b/nexgb/xgbgen/xml.go
@@ -8,29 +8,29 @@ import (
 
 type XML struct {
 	// Root 'xcb' element properties.
-	XMLName xml.Name `xml:"xcb"`
-	Header string `xml:"header,attr"`
-	ExtensionXName string `xml:"extension-xname,attr"`
-	ExtensionName string `xml:"extension-name,attr"`
-	MajorVersion string `xml:"major-version,attr"`
-	MinorVersion string `xml:"minor-version,attr"`
+	XMLName        xml.Name `xml:"xcb"`
+	Header         string   `xml:"header,attr"`
+	ExtensionXName string   `xml:"extension-xname,attr"`
+	ExtensionName  string   `xml:"extension-name,attr"`
+	MajorVersion   string   `xml:"major-version,attr"`
+	MinorVersion   string   `xml:"minor-version,attr"`
 
 	// Types for all top-level elements.
 	// First are the simple ones.
-	Imports XMLImports `xml:"import"`
-	Enums XMLEnums `xml:"enum"`
-	Xids XMLXids `xml:"xidtype"`
-	XidUnions XMLXids `xml:"xidunion"`
-	TypeDefs XMLTypeDefs `xml:"typedef"`
+	Imports     XMLImports     `xml:"import"`
+	Enums       XMLEnums       `xml:"enum"`
+	Xids        XMLXids        `xml:"xidtype"`
+	XidUnions   XMLXids        `xml:"xidunion"`
+	TypeDefs    XMLTypeDefs    `xml:"typedef"`
 	EventCopies XMLEventCopies `xml:"eventcopy"`
 	ErrorCopies XMLErrorCopies `xml:"errorcopy"`
 
 	// Here are the complex ones, i.e., anything with "structure contents"
-	Structs XMLStructs `xml:"struct"`
-	Unions XMLUnions `xml:"union"`
+	Structs  XMLStructs  `xml:"struct"`
+	Unions   XMLUnions   `xml:"union"`
 	Requests XMLRequests `xml:"request"`
-	Events XMLEvents `xml:"event"`
-	Errors XMLErrors `xml:"error"`
+	Events   XMLEvents   `xml:"event"`
+	Errors   XMLErrors   `xml:"error"`
 }
 
 type XMLImports []*XMLImport
@@ -39,14 +39,14 @@ func (imports XMLImports) Eval() {
 	for _, imp := range imports {
 		xmlBytes, err := ioutil.ReadFile(*protoPath + "/" + imp.Name + ".xml")
 		if err != nil {
-			log.Fatalf("Could not read X protocol description for import " +
+			log.Fatalf("Could not read X protocol description for import "+
 				"'%s' because: %s", imp.Name, err)
 		}
 
 		imp.xml = &XML{}
 		err = xml.Unmarshal(xmlBytes, imp.xml)
 		if err != nil {
-			log.Fatal("Could not parse X protocol description for import " +
+			log.Fatal("Could not parse X protocol description for import "+
 				"'%s' because: %s", imp.Name, err)
 		}
 
@@ -57,18 +57,18 @@ func (imports XMLImports) Eval() {
 
 type XMLImport struct {
 	Name string `xml:",chardata"`
-	xml *XML `xml:"-"`
+	xml  *XML   `xml:"-"`
 }
 
 type XMLEnums []XMLEnum
 
 type XMLEnum struct {
-	Name string `xml:"name,attr"`
+	Name  string         `xml:"name,attr"`
 	Items []*XMLEnumItem `xml:"item"`
 }
 
 type XMLEnumItem struct {
-	Name string `xml:"name,attr"`
+	Name string         `xml:"name,attr"`
 	Expr *XMLExpression `xml:",any"`
 }
 
@@ -76,7 +76,7 @@ type XMLXids []*XMLXid
 
 type XMLXid struct {
 	XMLName xml.Name
-	Name string `xml:"name,attr"`
+	Name    string `xml:"name,attr"`
 }
 
 type XMLTypeDefs []*XMLTypeDef
@@ -89,41 +89,41 @@ type XMLTypeDef struct {
 type XMLEventCopies []*XMLEventCopy
 
 type XMLEventCopy struct {
-	Name string `xml:"name,attr"`
-	Number int `xml:"number,attr"`
-	Ref string `xml:"ref,attr"`
+	Name   string `xml:"name,attr"`
+	Number int    `xml:"number,attr"`
+	Ref    string `xml:"ref,attr"`
 }
 
 type XMLErrorCopies []*XMLErrorCopy
 
 type XMLErrorCopy struct {
-	Name string `xml:"name,attr"`
-	Number int `xml:"number,attr"`
-	Ref string `xml:"ref,attr"`
+	Name   string `xml:"name,attr"`
+	Number int    `xml:"number,attr"`
+	Ref    string `xml:"ref,attr"`
 }
 
 type XMLStructs []*XMLStruct
 
 type XMLStruct struct {
-	Name string `xml:"name,attr"`
+	Name   string    `xml:"name,attr"`
 	Fields XMLFields `xml:",any"`
 }
 
 type XMLUnions []*XMLUnion
 
 type XMLUnion struct {
-	Name string `xml:"name,attr"`
+	Name   string    `xml:"name,attr"`
 	Fields XMLFields `xml:",any"`
 }
 
 type XMLRequests []*XMLRequest
 
 type XMLRequest struct {
-	Name string `xml:"name,attr"`
-	Opcode int `xml:"opcode,attr"`
-	Combine bool `xml:"combine-adjacent,attr"`
-	Fields XMLFields `xml:",any"`
-	Reply *XMLReply `xml:"reply"`
+	Name    string    `xml:"name,attr"`
+	Opcode  int       `xml:"opcode,attr"`
+	Combine bool      `xml:"combine-adjacent,attr"`
+	Fields  XMLFields `xml:",any"`
+	Reply   *XMLReply `xml:"reply"`
 }
 
 type XMLReply struct {
@@ -133,17 +133,16 @@ type XMLReply struct {
 type XMLEvents []*XMLEvent
 
 type XMLEvent struct {
-	Name string `xml:"name,attr"`
-	Number int `xml:"number,attr"`
-	NoSequence bool `xml:"no-sequence-number,true"`
-	Fields XMLFields `xml:",any"`
+	Name       string    `xml:"name,attr"`
+	Number     int       `xml:"number,attr"`
+	NoSequence bool      `xml:"no-sequence-number,true"`
+	Fields     XMLFields `xml:",any"`
 }
 
 type XMLErrors []*XMLError
 
 type XMLError struct {
-	Name string `xml:"name,attr"`
-	Number int `xml:"number,attr"`
+	Name   string    `xml:"name,attr"`
+	Number int       `xml:"number,attr"`
 	Fields XMLFields `xml:",any"`
 }
-
diff --git a/nexgb/xgbgen/xml_expression.go b/nexgb/xgbgen/xml_expression.go
index 57ff62e..2989668 100644
--- a/nexgb/xgbgen/xml_expression.go
+++ b/nexgb/xgbgen/xml_expression.go
@@ -13,14 +13,14 @@ type XMLExpression struct {
 	Exprs []*XMLExpression `xml:",any"`
 
 	Data string `xml:",chardata"`
-	Op string `xml:"op,attr"`
-	Ref string `xml:"ref,attr"`
+	Op   string `xml:"op,attr"`
+	Ref  string `xml:"ref,attr"`
 }
 
 func newValueExpression(v uint) *XMLExpression {
 	return &XMLExpression{
 		XMLName: xml.Name{Local: "value"},
-		Data: fmt.Sprintf("%d", v),
+		Data:    fmt.Sprintf("%d", v),
 	}
 }
 
@@ -87,22 +87,22 @@ func (e *XMLExpression) Eval() uint {
 				e.Data)
 		}
 		if bit < 0 || bit > 31 {
-			log.Panicf("A 'bit' literal must be in the range [0, 31], but " +
+			log.Panicf("A 'bit' literal must be in the range [0, 31], but "+
 				" is %d", bit)
 		}
 		return 1 << uint(bit)
 	case "fieldref":
-		log.Panicf("Cannot compute concrete value of 'fieldref' in " +
+		log.Panicf("Cannot compute concrete value of 'fieldref' in "+
 			"expression '%s'.", e)
 	case "enumref":
-		log.Panicf("Cannot compute concrete value of 'enumref' in " +
+		log.Panicf("Cannot compute concrete value of 'enumref' in "+
 			"expression '%s'.", e)
 	case "sumof":
-		log.Panicf("Cannot compute concrete value of 'sumof' in " +
+		log.Panicf("Cannot compute concrete value of 'sumof' in "+
 			"expression '%s'.", e)
 	}
 
-	log.Panicf("Unrecognized tag '%s' in expression context. Expected one of " +
+	log.Panicf("Unrecognized tag '%s' in expression context. Expected one of "+
 		"op, fieldref, value, bit, enumref, unop, sumof or popcount.",
 		e.XMLName.Local)
 	panic("unreachable")
diff --git a/nexgb/xgbgen/xml_fields.go b/nexgb/xgbgen/xml_fields.go
index d6d99c5..991141b 100644
--- a/nexgb/xgbgen/xml_fields.go
+++ b/nexgb/xgbgen/xml_fields.go
@@ -1,4 +1,5 @@
 package main
+
 /*
 	A series of fields should be taken as "structure contents", and *not*
 	just the single 'field' elements. Namely, 'fields' subsumes 'field'
@@ -50,8 +51,8 @@ type XMLField struct {
 
 	// I don't know which elements these are for. The documentation is vague.
 	// They also seem to be completely optional.
-	OptEnum string `xml:"enum,attr"`
-	OptMask string `xml:"mask,attr"`
+	OptEnum    string `xml:"enum,attr"`
+	OptMask    string `xml:"mask,attr"`
 	OptAltEnum string `xml:"altenum,attr"`
 }
 
@@ -103,14 +104,14 @@ type XMLBitcase struct {
 
 	// All the different expressions.
 	// When it comes time to choose one, use the 'Expr' method.
-	ExprOp *XMLExpression `xml:"op"`
-	ExprUnOp *XMLExpression `xml:"unop"`
+	ExprOp    *XMLExpression `xml:"op"`
+	ExprUnOp  *XMLExpression `xml:"unop"`
 	ExprField *XMLExpression `xml:"fieldref"`
 	ExprValue *XMLExpression `xml:"value"`
-	ExprBit *XMLExpression `xml:"bit"`
-	ExprEnum *XMLExpression `xml:"enumref"`
-	ExprSum *XMLExpression `xml:"sumof"`
-	ExprPop *XMLExpression `xml:"popcount"`
+	ExprBit   *XMLExpression `xml:"bit"`
+	ExprEnum  *XMLExpression `xml:"enumref"`
+	ExprSum   *XMLExpression `xml:"sumof"`
+	ExprPop   *XMLExpression `xml:"popcount"`
 }
 
 // StringPrefix is for debugging purposes only.
-- 
cgit v1.2.3-70-g09d2


From 83a71d464887f4b6cf9124d2f8c565e6f17f2bd3 Mon Sep 17 00:00:00 2001
From: "Andrew Gallant (Ocelot)" <Andrew.Gallant@tufts.edu>
Date: Tue, 1 May 2012 01:08:03 -0400
Subject: unions, events and errors... oh my

---
 nexgb/xgbgen/field.go           |  27 +++++++-
 nexgb/xgbgen/go_error.go        |  30 +++++++--
 nexgb/xgbgen/go_event.go        |  97 ++++++++++++++++++++++++++---
 nexgb/xgbgen/go_list.go         |  10 +--
 nexgb/xgbgen/go_single_field.go |  36 +++++++++--
 nexgb/xgbgen/go_struct.go       |   9 +--
 nexgb/xgbgen/go_union.go        | 134 +++++++++++++++++++++++++++++++++++++++-
 nexgb/xgbgen/type.go            |   4 +-
 8 files changed, 313 insertions(+), 34 deletions(-)

(limited to 'nexgb/xgbgen/type.go')

diff --git a/nexgb/xgbgen/field.go b/nexgb/xgbgen/field.go
index 0f2323e..6d39af2 100644
--- a/nexgb/xgbgen/field.go
+++ b/nexgb/xgbgen/field.go
@@ -9,6 +9,7 @@ type Field interface {
 	Initialize(p *Protocol)
 	SrcName() string
 	XmlName() string
+	SrcType() string
 	Size() Size
 
 	Define(c *Context)
@@ -30,6 +31,10 @@ func (p *PadField) XmlName() string {
 	panic("illegal to take XML name of a pad field")
 }
 
+func (f *PadField) SrcType() string {
+	panic("it is illegal to call SrcType on a SwitchField field")
+}
+
 func (p *PadField) Size() Size {
 	return newFixedSize(p.Bytes)
 }
@@ -53,6 +58,10 @@ func (f *SingleField) XmlName() string {
 	return f.xmlName
 }
 
+func (f *SingleField) SrcType() string {
+	return f.Type.SrcName()
+}
+
 func (f *SingleField) Size() Size {
 	return f.Type.Size()
 }
@@ -72,9 +81,9 @@ func (f *ListField) XmlName() string {
 	return f.xmlName
 }
 
-// func (f *ListField) Size() Size { 
-	// return newExpressionSize(f.LengthExpr).Multiply(f.Type.Size()) 
-// } 
+func (f *ListField) SrcType() string {
+	return fmt.Sprintf("[]%s", f.Type.SrcName())
+}
 
 func (f *ListField) Size() Size {
 	simpleLen := &Function{
@@ -126,6 +135,10 @@ func (f *ExprField) XmlName() string {
 	return f.xmlName
 }
 
+func (f *ExprField) SrcType() string {
+	return f.Type.SrcName()
+}
+
 func (f *ExprField) Size() Size {
 	return f.Type.Size()
 }
@@ -150,6 +163,10 @@ func (f *ValueField) XmlName() string {
 	panic("it is illegal to call XmlName on a ValueField field")
 }
 
+func (f *ValueField) SrcType() string {
+	return f.MaskType.SrcName()
+}
+
 func (f *ValueField) Size() Size {
 	return f.MaskType.Size()
 }
@@ -174,6 +191,10 @@ func (f *SwitchField) XmlName() string {
 	panic("it is illegal to call XmlName on a SwitchField field")
 }
 
+func (f *SwitchField) SrcType() string {
+	panic("it is illegal to call SrcType on a SwitchField field")
+}
+
 // XXX: This is a bit tricky. The size has to be represented as a non-concrete
 // expression that finds *which* bitcase fields are included, and sums the
 // sizes of those fields.
diff --git a/nexgb/xgbgen/go_error.go b/nexgb/xgbgen/go_error.go
index 0cb77cc..493a8b9 100644
--- a/nexgb/xgbgen/go_error.go
+++ b/nexgb/xgbgen/go_error.go
@@ -22,18 +22,36 @@ func (e *ErrorCopy) Define(c *Context) {
 	c.Putln("")
 	c.Putln("type %s %s", e.ErrType(), e.Old.(*Error).ErrType())
 	c.Putln("")
+
+	// Read defines a function that transforms a byte slice into this
+	// error struct.
+	e.Read(c)
+
+	// Write defines a function that transoforms this error struct into
+	// a byte slice.
+	e.Write(c)
+
+	// Makes sure that this error type is an Error interface.
+	c.Putln("func (err %s) ImplementsError() { }", e.ErrType())
+	c.Putln("")
+
+	// Let's the XGB know how to read this error.
+	c.Putln("func init() {")
+	c.Putln("newErrorFuncs[%d] = New%s", e.Number, e.SrcName())
+	c.Putln("}")
+	c.Putln("")
+}
+
+func (e *ErrorCopy) Read(c *Context) {
 	c.Putln("func New%s(buf []byte) %s {", e.SrcName(), e.ErrType())
 	c.Putln("return (%s)(New%s(buf))", e.ErrType(), e.Old.SrcName())
 	c.Putln("}")
 	c.Putln("")
-	c.Putln("func (err %s) ImplementsError() { }", e.ErrType())
-	c.Putln("")
+}
+
+func (e *ErrorCopy) Write(c *Context) {
 	c.Putln("func (err %s) Bytes() []byte {", e.ErrType())
 	c.Putln("return (%s)(err).Bytes()", e.Old.(*Error).ErrType())
 	c.Putln("}")
 	c.Putln("")
-	c.Putln("func init() {")
-	c.Putln("newErrorFuncs[%d] = New%s", e.Number, e.SrcName())
-	c.Putln("}")
-	c.Putln("")
 }
diff --git a/nexgb/xgbgen/go_event.go b/nexgb/xgbgen/go_event.go
index d91fd7a..e6d40b0 100644
--- a/nexgb/xgbgen/go_event.go
+++ b/nexgb/xgbgen/go_event.go
@@ -3,14 +3,75 @@ package main
 // Event types
 func (e *Event) Define(c *Context) {
 	c.Putln("// Event definition %s (%d)", e.SrcName(), e.Number)
+	c.Putln("// Size: %s", e.Size())
+	c.Putln("type %s struct {", e.EvType())
+	c.Putln("Sequence uint16")
+	for _, field := range e.Fields {
+		field.Define(c)
+	}
+	c.Putln("}")
+	c.Putln("")
+
+	// Read defines a function that transforms a byte slice into this
+	// event struct.
+	e.Read(c)
+
+	// Write defines a function that transoforms this event struct into
+	// a byte slice.
+	e.Write(c)
+
+	// Makes sure that this event type is an Event interface.
+	c.Putln("func (v %s) ImplementsEvent() { }", e.EvType())
+	c.Putln("")
+
+	// Let's the XGB event loop read this event.
+	c.Putln("func init() {")
+	c.Putln("newEventFuncs[%d] = New%s", e.Number, e.SrcName())
+	c.Putln("}")
+	c.Putln("")
 }
 
-func (e *Event) Read(c *Context, prefix string) {
+func (e *Event) Read(c *Context) {
 	c.Putln("// Event read %s", e.SrcName())
+	c.Putln("func New%s(buf []byte) %s {", e.SrcName(), e.EvType())
+	c.Putln("v := %s{}", e.EvType())
+	c.Putln("b := 1 // don't read event number")
+	c.Putln("")
+	for i, field := range e.Fields {
+		if i == 1 && !e.NoSequence {
+			c.Putln("v.Sequence = get16(buf[b:])")
+			c.Putln("b += 2")
+			c.Putln("")
+		}
+		field.Read(c)
+		c.Putln("")
+	}
+	c.Putln("return v")
+	c.Putln("}")
+	c.Putln("")
 }
 
-func (e *Event) Write(c *Context, prefix string) {
+func (e *Event) Write(c *Context) {
 	c.Putln("// Event write %s", e.SrcName())
+	c.Putln("func (v %s) Bytes() []byte {", e.EvType())
+	c.Putln("buf := make([]byte, %s)", e.Size())
+	c.Putln("b := 0")
+	c.Putln("")
+	c.Putln("// write event number")
+	c.Putln("buf[b] = %d", e.Number)
+	c.Putln("b += 1")
+	c.Putln("")
+	for i, field := range e.Fields {
+		if i == 1 && !e.NoSequence {
+			c.Putln("b += 2 // skip sequence number")
+			c.Putln("")
+		}
+		field.Write(c)
+		c.Putln("")
+	}
+	c.Putln("return buf")
+	c.Putln("}")
+	c.Putln("")
 }
 
 // EventCopy types
@@ -21,18 +82,36 @@ func (e *EventCopy) Define(c *Context) {
 	c.Putln("")
 	c.Putln("type %s %s", e.EvType(), e.Old.(*Event).EvType())
 	c.Putln("")
+
+	// Read defines a function that transforms a byte slice into this
+	// event struct.
+	e.Read(c)
+
+	// Write defines a function that transoforms this event struct into
+	// a byte slice.
+	e.Write(c)
+
+	// Makes sure that this event type is an Event interface.
+	c.Putln("func (v %s) ImplementsEvent() { }", e.EvType())
+	c.Putln("")
+
+	// Let's the XGB event loop read this event.
+	c.Putln("func init() {")
+	c.Putln("newEventFuncs[%d] = New%s", e.Number, e.SrcName())
+	c.Putln("}")
+	c.Putln("")
+}
+
+func (e *EventCopy) Read(c *Context) {
 	c.Putln("func New%s(buf []byte) %s {", e.SrcName(), e.EvType())
 	c.Putln("return (%s)(New%s(buf))", e.EvType(), e.Old.SrcName())
 	c.Putln("}")
 	c.Putln("")
-	c.Putln("func (ev %s) ImplementsEvent() { }", e.EvType())
-	c.Putln("")
-	c.Putln("func (ev %s) Bytes() []byte {", e.EvType())
+}
+
+func (e *EventCopy) Write(c *Context) {
+	c.Putln("func (v %s) Bytes() []byte {", e.EvType())
 	c.Putln("return (%s)(ev).Bytes()", e.Old.(*Event).EvType())
 	c.Putln("}")
 	c.Putln("")
-	c.Putln("func init() {")
-	c.Putln("newEventFuncs[%d] = New%s", e.Number, e.SrcName())
-	c.Putln("}")
-	c.Putln("")
 }
diff --git a/nexgb/xgbgen/go_list.go b/nexgb/xgbgen/go_list.go
index 03da22e..a95ba71 100644
--- a/nexgb/xgbgen/go_list.go
+++ b/nexgb/xgbgen/go_list.go
@@ -12,8 +12,6 @@ func (f *ListField) Define(c *Context) {
 }
 
 func (f *ListField) Read(c *Context) {
-	c.Putln("")
-
 	switch t := f.Type.(type) {
 	case *Resource:
 		length := f.LengthExpr.Reduce("v.", "")
@@ -34,6 +32,10 @@ func (f *ListField) Read(c *Context) {
 			c.Putln("}")
 			c.Putln("b = pad(b)")
 		}
+	case *Union:
+		c.Putln("v.%s = make([]%s, %s)",
+			f.SrcName(), t.SrcName(), f.LengthExpr.Reduce("v.", ""))
+		c.Putln("b += Read%sList(buf[b:], v.%s)", t.SrcName(), f.SrcName())
 	case *Struct:
 		c.Putln("v.%s = make([]%s, %s)",
 			f.SrcName(), t.SrcName(), f.LengthExpr.Reduce("v.", ""))
@@ -45,8 +47,6 @@ func (f *ListField) Read(c *Context) {
 }
 
 func (f *ListField) Write(c *Context) {
-	c.Putln("")
-
 	switch t := f.Type.(type) {
 	case *Resource:
 		length := f.LengthExpr.Reduce("v.", "")
@@ -65,6 +65,8 @@ func (f *ListField) Write(c *Context) {
 			c.Putln("}")
 			c.Putln("b = pad(b)")
 		}
+	case *Union:
+		c.Putln("b += %sListBytes(buf[b:], v.%s)", t.SrcName(), f.SrcName())
 	case *Struct:
 		c.Putln("b += %sListBytes(buf[b:], v.%s)", t.SrcName(), f.SrcName())
 	default:
diff --git a/nexgb/xgbgen/go_single_field.go b/nexgb/xgbgen/go_single_field.go
index 3c354e7..bf31259 100644
--- a/nexgb/xgbgen/go_single_field.go
+++ b/nexgb/xgbgen/go_single_field.go
@@ -25,6 +25,16 @@ func ReadSimpleSingleField(c *Context, name string, typ Type) {
 			c.Putln("%s = %s(get64(buf[b:]))", name, t.SrcName())
 		}
 	case *Base:
+		// If this is a bool, stop short and do something special.
+		if t.SrcName() == "bool" {
+			c.Putln("if buf[b] == 1 {")
+			c.Putln("%s = true", name)
+			c.Putln("} else {")
+			c.Putln("%s = false", name)
+			c.Putln("}")
+			break
+		}
+
 		var val string
 		switch t.Size().Eval() {
 		case 1:
@@ -44,7 +54,7 @@ func ReadSimpleSingleField(c *Context, name string, typ Type) {
 		}
 		c.Putln("%s = %s", name, val)
 	default:
-		log.Fatalf("Cannot read field '%s' as a simple field with %T type.",
+		log.Panicf("Cannot read field '%s' as a simple field with %T type.",
 			name, typ)
 	}
 
@@ -62,9 +72,11 @@ func (f *SingleField) Read(c *Context) {
 	case *Struct:
 		c.Putln("v.%s = %s{}", f.SrcName(), t.SrcName())
 		c.Putln("b += Read%s(buf[b:], &v.%s)", t.SrcName(), f.SrcName())
-		c.Putln("")
+	case *Union:
+		c.Putln("v.%s = %s{}", f.SrcName(), t.SrcName())
+		c.Putln("b += Read%s(buf[b:], &v.%s)", t.SrcName(), f.SrcName())
 	default:
-		log.Fatalf("Cannot read field '%s' with %T type.", f.XmlName(), f.Type)
+		log.Panicf("Cannot read field '%s' with %T type.", f.XmlName(), f.Type)
 	}
 }
 
@@ -84,6 +96,16 @@ func WriteSimpleSingleField(c *Context, name string, typ Type) {
 			c.Putln("put64(buf[b:], uint64(%s))", name)
 		}
 	case *Base:
+		// If this is a bool, stop short and do something special.
+		if t.SrcName() == "bool" {
+			c.Putln("if %s {", name)
+			c.Putln("buf[b] = 1")
+			c.Putln("} else {")
+			c.Putln("buf[b] = 0")
+			c.Putln("}")
+			break
+		}
+
 		switch t.Size().Eval() {
 		case 1:
 			if t.SrcName() != "byte" {
@@ -126,11 +148,17 @@ func (f *SingleField) Write(c *Context) {
 		ReadSimpleSingleField(c, fmt.Sprintf("v.%s", f.SrcName()), t)
 	case *Base:
 		ReadSimpleSingleField(c, fmt.Sprintf("v.%s", f.SrcName()), t)
+	case *Union:
+		c.Putln("{")
+		c.Putln("unionBytes := v.%s.Bytes()", f.SrcName())
+		c.Putln("copy(buf[b:], unionBytes)")
+		c.Putln("b += pad(len(unionBytes))")
+		c.Putln("}")
 	case *Struct:
 		c.Putln("{")
 		c.Putln("structBytes := v.%s.Bytes()", f.SrcName())
 		c.Putln("copy(buf[b:], structBytes)")
-		c.Putln("b += len(structBytes)")
+		c.Putln("b += pad(len(structBytes))")
 		c.Putln("}")
 	default:
 		log.Fatalf("Cannot read field '%s' with %T type.", f.XmlName(), f.Type)
diff --git a/nexgb/xgbgen/go_struct.go b/nexgb/xgbgen/go_struct.go
index 6925c88..600ebaf 100644
--- a/nexgb/xgbgen/go_struct.go
+++ b/nexgb/xgbgen/go_struct.go
@@ -13,7 +13,7 @@ func (s *Struct) Define(c *Context) {
 	// Write function that reads bytes and produces this struct.
 	s.Read(c)
 
-	// Write function that reads a list of this structs.
+	// Write function that reads bytes and produces a list of this struct.
 	s.ReadList(c)
 
 	// Write function that writes bytes given this struct.
@@ -68,7 +68,7 @@ func (s *Struct) ReadList(c *Context) {
 func (s *Struct) Write(c *Context) {
 	c.Putln("// Struct write %s", s.SrcName())
 	c.Putln("func (v %s) Bytes() []byte {", s.SrcName())
-	c.Putln("buf := make([]byte, %s)", s.Size().Reduce("s.", ""))
+	c.Putln("buf := make([]byte, %s)", s.Size().Reduce("v.", ""))
 	c.Putln("b := 0")
 	c.Putln("")
 	for _, field := range s.Fields {
@@ -88,10 +88,11 @@ func (s *Struct) WriteList(c *Context) {
 	c.Putln("for _, item := range list {")
 	c.Putln("structBytes = item.Bytes()")
 	c.Putln("copy(buf[b:], len(structBytes))")
-	c.Putln("b += len(structBytes)")
+	c.Putln("b += pad(len(structBytes))")
 	c.Putln("}")
 	c.Putln("return b")
 	c.Putln("}")
+	c.Putln("")
 }
 
 func (s *Struct) WriteListSize(c *Context) {
@@ -101,7 +102,7 @@ func (s *Struct) WriteListSize(c *Context) {
 	c.Putln("for _, item := range list {")
 	c.Putln("size += %s", s.Size().Reduce("item.", ""))
 	c.Putln("}")
-	c.Putln("return pad(size)")
+	c.Putln("return size")
 	c.Putln("}")
 	c.Putln("")
 }
diff --git a/nexgb/xgbgen/go_union.go b/nexgb/xgbgen/go_union.go
index 5721c49..3b7365d 100644
--- a/nexgb/xgbgen/go_union.go
+++ b/nexgb/xgbgen/go_union.go
@@ -3,13 +3,143 @@ package main
 // Union types
 func (u *Union) Define(c *Context) {
 	c.Putln("// Union definition %s", u.SrcName())
+	c.Putln("// Note that to *create* a Union, you should *never* create")
+	c.Putln("// this struct directly (unless you know what you're doing).")
+	c.Putln("// Instead use one of the following constructors for '%s':",
+		u.SrcName())
+	for _, field := range u.Fields {
+		c.Putln("//     New%s%s(%s %s) %s", u.SrcName(), field.SrcName(),
+			field.SrcName(), field.SrcType(), u.SrcName())
+	}
+
+	c.Putln("type %s struct {", u.SrcName())
+	for _, field := range u.Fields {
+		field.Define(c)
+	}
+	c.Putln("}")
+	c.Putln("")
+
+	// Write functions for each field that create instances of this
+	// union using the corresponding field.
+	u.New(c)
+
+	// Write function that reads bytes and produces this union.
+	u.Read(c)
+
+	// Write function that reads bytes and produces a list of this union.
+	u.ReadList(c)
+
+	// Write function that writes bytes given this union.
+	u.Write(c)
+
+	// Write function that writes a list of this union.
+	u.WriteList(c)
+
+	// Write function that computes the size of a list of these unions.
+	u.WriteListSize(c)
 }
 
-func (u *Union) Read(c *Context, prefix string) {
+func (u *Union) New(c *Context) {
+	for _, field := range u.Fields {
+		c.Putln("// Union constructor for %s for field %s.",
+			u.SrcName(), field.SrcName())
+		c.Putln("func New%s%s(%s %s) %s {",
+			u.SrcName(), field.SrcName(), field.SrcName(),
+			field.SrcType(), u.SrcName())
+		c.Putln("var b int")
+		c.Putln("buf := make([]byte, %s)", u.Size())
+		c.Putln("")
+		field.Write(c)
+		c.Putln("")
+		c.Putln("// Create the Union type")
+		c.Putln("v := %s{}", u.SrcName())
+		c.Putln("")
+		c.Putln("// Now copy buf into all fields")
+		c.Putln("")
+		for _, field2 := range u.Fields {
+			c.Putln("b = 0 // always read the same bytes")
+			field2.Read(c)
+			c.Putln("")
+		}
+		c.Putln("return v")
+		c.Putln("}")
+		c.Putln("")
+	}
+}
+
+func (u *Union) Read(c *Context) {
 	c.Putln("// Union read %s", u.SrcName())
+	c.Putln("func Read%s(buf []byte, v *%s) int {", u.SrcName(), u.SrcName())
+	c.Putln("var b int")
+	c.Putln("")
+	for _, field := range u.Fields {
+		c.Putln("b = 0 // re-read the same bytes")
+		field.Read(c)
+		c.Putln("")
+	}
+	c.Putln("return %s", u.Size())
+	c.Putln("}")
+	c.Putln("")
+}
+
+func (u *Union) ReadList(c *Context) {
+	c.Putln("// Union list read %s", u.SrcName())
+	c.Putln("func Read%sList(buf []byte, dest []%s) int {",
+		u.SrcName(), u.SrcName())
+	c.Putln("b := 0")
+	c.Putln("for i := 0; i < len(dest); i++ {")
+	c.Putln("dest[i] = %s{}", u.SrcName())
+	c.Putln("b += Read%s(buf[b:], &dest[i])", u.SrcName())
+	c.Putln("}")
+	c.Putln("return pad(b)")
+	c.Putln("}")
+	c.Putln("")
 }
 
-func (u *Union) Write(c *Context, prefix string) {
+// This is a bit tricky since writing from a Union implies that only
+// the data inside ONE of the elements is actually written.
+// However, we only currently support unions where every field has the
+// *same* *fixed* size. Thus, we make sure to always read bytes into
+// every field which allows us to simply pick the first field and write it.
+func (u *Union) Write(c *Context) {
 	c.Putln("// Union write %s", u.SrcName())
+	c.Putln("// Each field in a union must contain the same data.")
+	c.Putln("// So simply pick the first field and write that to the wire.")
+	c.Putln("func (v %s) Bytes() []byte {", u.SrcName())
+	c.Putln("buf := make([]byte, %s)", u.Size().Reduce("v.", ""))
+	c.Putln("b := 0")
+	c.Putln("")
+	u.Fields[0].Write(c)
+	c.Putln("return buf")
+	c.Putln("}")
+	c.Putln("")
+}
+
+func (u *Union) WriteList(c *Context) {
+	c.Putln("// Union list write %s", u.SrcName())
+	c.Putln("func %sListBytes(buf []byte, list []%s) int {",
+		u.SrcName(), u.SrcName())
+	c.Putln("b := 0")
+	c.Putln("var unionBytes []byte")
+	c.Putln("for _, item := range list {")
+	c.Putln("unionBytes = item.Bytes()")
+	c.Putln("copy(buf[b:], len(unionBytes))")
+	c.Putln("b += pad(len(unionBytes))")
+	c.Putln("}")
+	c.Putln("return b")
+	c.Putln("}")
+	c.Putln("")
+}
+
+func (u *Union) WriteListSize(c *Context) {
+	c.Putln("// Union list size %s", u.SrcName())
+	c.Putln("func %sListSize(list []%s) int {", u.SrcName(), u.SrcName())
+	c.Putln("size := 0")
+	c.Putln("for _, item := range list {")
+	c.Putln("size += %s", u.Size().Reduce("item.", ""))
+	c.Putln("}")
+	c.Putln("return size")
+	c.Putln("}")
+	c.Putln("")
 }
 
diff --git a/nexgb/xgbgen/type.go b/nexgb/xgbgen/type.go
index 9fbef65..1e06bda 100644
--- a/nexgb/xgbgen/type.go
+++ b/nexgb/xgbgen/type.go
@@ -191,7 +191,7 @@ func (e *Event) XmlName() string {
 }
 
 func (e *Event) Size() Size {
-	panic("Cannot take size of Event type.")
+	return newExpressionSize(&Value{v: 32})
 }
 
 func (e *Event) Initialize(p *Protocol) {
@@ -358,7 +358,7 @@ func (u *Union) Size() Size {
 }
 
 func (u *Union) Initialize(p *Protocol) {
-	u.srcName = TypeSrcName(p, u)
+	u.srcName = fmt.Sprintf("%sUnion", TypeSrcName(p, u))
 	for _, field := range u.Fields {
 		field.Initialize(p)
 	}
-- 
cgit v1.2.3-70-g09d2


From 39507f86ab0468292c24081a80f41c1799d6b477 Mon Sep 17 00:00:00 2001
From: "Andrew Gallant (Ocelot)" <Andrew.Gallant@tufts.edu>
Date: Wed, 2 May 2012 01:46:30 -0400
Subject: finally starting on the crescendo: requests and replies.

---
 nexgb/xgbgen/context.go        |  3 ++
 nexgb/xgbgen/field.go          |  4 ++-
 nexgb/xgbgen/go.go             |  9 ------
 nexgb/xgbgen/go_error.go       | 65 ++++++++++++++++++++++++++++++------------
 nexgb/xgbgen/go_event.go       | 21 ++++++++------
 nexgb/xgbgen/go_list.go        |  4 +--
 nexgb/xgbgen/go_reply.go       | 19 ++++++++++++
 nexgb/xgbgen/representation.go | 53 ++++++++++++++++++++++++++++++++++
 nexgb/xgbgen/translation.go    | 12 ++++----
 nexgb/xgbgen/type.go           |  9 ++++--
 nexgb/xgbgen/xml.go            |  2 +-
 11 files changed, 153 insertions(+), 48 deletions(-)
 create mode 100644 nexgb/xgbgen/go_reply.go

(limited to 'nexgb/xgbgen/type.go')

diff --git a/nexgb/xgbgen/context.go b/nexgb/xgbgen/context.go
index 67801c7..33641b3 100644
--- a/nexgb/xgbgen/context.go
+++ b/nexgb/xgbgen/context.go
@@ -51,4 +51,7 @@ func (c *Context) Morph(xmlBytes []byte) {
 	for _, typ := range c.protocol.Types {
 		typ.Define(c)
 	}
+	for _, req := range c.protocol.Requests {
+		req.Define(c)
+	}
 }
diff --git a/nexgb/xgbgen/field.go b/nexgb/xgbgen/field.go
index 6d39af2..8d8412c 100644
--- a/nexgb/xgbgen/field.go
+++ b/nexgb/xgbgen/field.go
@@ -102,8 +102,10 @@ func (f *ListField) Size() Size {
 		return newExpressionSize(simpleLen)
 	case *Resource:
 		return newExpressionSize(simpleLen)
+	case *TypeDef:
+		return newExpressionSize(simpleLen)
 	default:
-		log.Fatalf("Cannot compute list size with type '%T'.", f.Type)
+		log.Panicf("Cannot compute list size with type '%T'.", f.Type)
 	}
 	panic("unreachable")
 }
diff --git a/nexgb/xgbgen/go.go b/nexgb/xgbgen/go.go
index 11e413b..b7b153e 100644
--- a/nexgb/xgbgen/go.go
+++ b/nexgb/xgbgen/go.go
@@ -105,57 +105,48 @@ func (f *PadField) Write(c *Context) {
 // Local fields
 func (f *LocalField) Define(c *Context) {
 	c.Putln("// local field: %s %s", f.SrcName(), f.Type.SrcName())
-	panic("todo")
 }
 
 func (f *LocalField) Read(c *Context) {
 	c.Putln("// reading local field: %s (%s) :: %s",
 		f.SrcName(), f.Size(), f.Type.SrcName())
-	panic("todo")
 }
 
 func (f *LocalField) Write(c *Context) {
 	c.Putln("// writing local field: %s (%s) :: %s",
 		f.SrcName(), f.Size(), f.Type.SrcName())
-	panic("todo")
 }
 
 // Expr fields
 func (f *ExprField) Define(c *Context) {
 	c.Putln("// expression field: %s %s (%s)",
 		f.SrcName(), f.Type.SrcName(), f.Expr)
-	panic("todo")
 }
 
 func (f *ExprField) Read(c *Context) {
 	c.Putln("// reading expression field: %s (%s) (%s) :: %s",
 		f.SrcName(), f.Size(), f.Expr, f.Type.SrcName())
-	panic("todo")
 }
 
 func (f *ExprField) Write(c *Context) {
 	c.Putln("// writing expression field: %s (%s) (%s) :: %s",
 		f.SrcName(), f.Size(), f.Expr, f.Type.SrcName())
-	panic("todo")
 }
 
 // Value field
 func (f *ValueField) Define(c *Context) {
 	c.Putln("// valueparam field: type: %s, mask name: %s, list name: %s",
 		f.MaskType.SrcName(), f.MaskName, f.ListName)
-	panic("todo")
 }
 
 func (f *ValueField) Read(c *Context) {
 	c.Putln("// reading valueparam: type: %s, mask name: %s, list name: %s",
 		f.MaskType.SrcName(), f.MaskName, f.ListName)
-	panic("todo")
 }
 
 func (f *ValueField) Write(c *Context) {
 	c.Putln("// writing valueparam: type: %s, mask name: %s, list name: %s",
 		f.MaskType.SrcName(), f.MaskName, f.ListName)
-	panic("todo")
 }
 
 // Switch field
diff --git a/nexgb/xgbgen/go_error.go b/nexgb/xgbgen/go_error.go
index 493a8b9..17c0db5 100644
--- a/nexgb/xgbgen/go_error.go
+++ b/nexgb/xgbgen/go_error.go
@@ -3,15 +3,53 @@ package main
 // Error types
 func (e *Error) Define(c *Context) {
 	c.Putln("// Error definition %s (%d)", e.SrcName(), e.Number)
+	c.Putln("// Size: %s", e.Size())
+	c.Putln("")
+	c.Putln("const %s = %d", e.ErrConst(), e.Number)
+	c.Putln("")
+	c.Putln("type %s struct {", e.ErrType())
+	c.Putln("Sequence uint16")
+	c.Putln("NiceName string")
+	for _, field := range e.Fields {
+		field.Define(c)
+	}
+	c.Putln("}")
 	c.Putln("")
-}
 
-func (e *Error) Read(c *Context, prefix string) {
-	c.Putln("// Error read %s", e.SrcName())
+	// Read defines a function that transforms a byte slice into this
+	// error struct.
+	e.Read(c)
+
+	// Makes sure that this error type is an Error interface.
+	c.Putln("func (v %s) ImplementsError() { }", e.ErrType())
+	c.Putln("")
+
+	// Let's the XGB event loop read this error.
+	c.Putln("func init() {")
+	c.Putln("newErrorFuncs[%d] = New%s", e.Number, e.ErrType())
+	c.Putln("}")
+	c.Putln("")
 }
 
-func (e *Error) Write(c *Context, prefix string) {
-	c.Putln("// Error write %s", e.SrcName())
+func (e *Error) Read(c *Context) {
+	c.Putln("// Error read %s", e.SrcName())
+	c.Putln("func New%s(buf []byte) %s {", e.ErrType(), e.ErrType())
+	c.Putln("v := %s{}", e.ErrType())
+	c.Putln("v.NiceName = \"%s\"", e.SrcName())
+	c.Putln("")
+	c.Putln("b := 1 // skip error determinant")
+	c.Putln("b += 1 // don't read error number")
+	c.Putln("")
+	c.Putln("v.Sequence = get16(buf[b:])")
+	c.Putln("b += 2")
+	c.Putln("")
+	for _, field := range e.Fields {
+		field.Read(c)
+		c.Putln("")
+	}
+	c.Putln("return v")
+	c.Putln("}")
+	c.Putln("")
 }
 
 // ErrorCopy types
@@ -27,31 +65,20 @@ func (e *ErrorCopy) Define(c *Context) {
 	// error struct.
 	e.Read(c)
 
-	// Write defines a function that transoforms this error struct into
-	// a byte slice.
-	e.Write(c)
-
 	// Makes sure that this error type is an Error interface.
 	c.Putln("func (err %s) ImplementsError() { }", e.ErrType())
 	c.Putln("")
 
 	// Let's the XGB know how to read this error.
 	c.Putln("func init() {")
-	c.Putln("newErrorFuncs[%d] = New%s", e.Number, e.SrcName())
+	c.Putln("newErrorFuncs[%d] = New%s", e.Number, e.ErrType())
 	c.Putln("}")
 	c.Putln("")
 }
 
 func (e *ErrorCopy) Read(c *Context) {
-	c.Putln("func New%s(buf []byte) %s {", e.SrcName(), e.ErrType())
-	c.Putln("return (%s)(New%s(buf))", e.ErrType(), e.Old.SrcName())
-	c.Putln("}")
-	c.Putln("")
-}
-
-func (e *ErrorCopy) Write(c *Context) {
-	c.Putln("func (err %s) Bytes() []byte {", e.ErrType())
-	c.Putln("return (%s)(err).Bytes()", e.Old.(*Error).ErrType())
+	c.Putln("func New%s(buf []byte) %s {", e.ErrType(), e.ErrType())
+	c.Putln("return %s(New%s(buf))", e.ErrType(), e.Old.(*Error).ErrType())
 	c.Putln("}")
 	c.Putln("")
 }
diff --git a/nexgb/xgbgen/go_event.go b/nexgb/xgbgen/go_event.go
index e6d40b0..fe2a77e 100644
--- a/nexgb/xgbgen/go_event.go
+++ b/nexgb/xgbgen/go_event.go
@@ -4,8 +4,13 @@ package main
 func (e *Event) Define(c *Context) {
 	c.Putln("// Event definition %s (%d)", e.SrcName(), e.Number)
 	c.Putln("// Size: %s", e.Size())
+	c.Putln("")
+	c.Putln("const %s = %d", e.SrcName(), e.Number)
+	c.Putln("")
 	c.Putln("type %s struct {", e.EvType())
-	c.Putln("Sequence uint16")
+	if !e.NoSequence {
+		c.Putln("Sequence uint16")
+	}
 	for _, field := range e.Fields {
 		field.Define(c)
 	}
@@ -16,7 +21,7 @@ func (e *Event) Define(c *Context) {
 	// event struct.
 	e.Read(c)
 
-	// Write defines a function that transoforms this event struct into
+	// Write defines a function that transforms this event struct into
 	// a byte slice.
 	e.Write(c)
 
@@ -26,14 +31,14 @@ func (e *Event) Define(c *Context) {
 
 	// Let's the XGB event loop read this event.
 	c.Putln("func init() {")
-	c.Putln("newEventFuncs[%d] = New%s", e.Number, e.SrcName())
+	c.Putln("newEventFuncs[%d] = New%s", e.Number, e.EvType())
 	c.Putln("}")
 	c.Putln("")
 }
 
 func (e *Event) Read(c *Context) {
 	c.Putln("// Event read %s", e.SrcName())
-	c.Putln("func New%s(buf []byte) %s {", e.SrcName(), e.EvType())
+	c.Putln("func New%s(buf []byte) %s {", e.EvType(), e.EvType())
 	c.Putln("v := %s{}", e.EvType())
 	c.Putln("b := 1 // don't read event number")
 	c.Putln("")
@@ -97,21 +102,21 @@ func (e *EventCopy) Define(c *Context) {
 
 	// Let's the XGB event loop read this event.
 	c.Putln("func init() {")
-	c.Putln("newEventFuncs[%d] = New%s", e.Number, e.SrcName())
+	c.Putln("newEventFuncs[%d] = New%s", e.Number, e.EvType())
 	c.Putln("}")
 	c.Putln("")
 }
 
 func (e *EventCopy) Read(c *Context) {
-	c.Putln("func New%s(buf []byte) %s {", e.SrcName(), e.EvType())
-	c.Putln("return (%s)(New%s(buf))", e.EvType(), e.Old.SrcName())
+	c.Putln("func New%s(buf []byte) %s {", e.EvType(), e.EvType())
+	c.Putln("return %s(New%s(buf))", e.EvType(), e.Old.(*Event).EvType())
 	c.Putln("}")
 	c.Putln("")
 }
 
 func (e *EventCopy) Write(c *Context) {
 	c.Putln("func (v %s) Bytes() []byte {", e.EvType())
-	c.Putln("return (%s)(ev).Bytes()", e.Old.(*Event).EvType())
+	c.Putln("return %s(ev).Bytes()", e.Old.(*Event).EvType())
 	c.Putln("}")
 	c.Putln("")
 }
diff --git a/nexgb/xgbgen/go_list.go b/nexgb/xgbgen/go_list.go
index a95ba71..67ecd34 100644
--- a/nexgb/xgbgen/go_list.go
+++ b/nexgb/xgbgen/go_list.go
@@ -41,7 +41,7 @@ func (f *ListField) Read(c *Context) {
 			f.SrcName(), t.SrcName(), f.LengthExpr.Reduce("v.", ""))
 		c.Putln("b += Read%sList(buf[b:], v.%s)", t.SrcName(), f.SrcName())
 	default:
-		log.Fatalf("Cannot read list field '%s' with %T type.",
+		log.Panicf("Cannot read list field '%s' with %T type.",
 			f.XmlName(), f.Type)
 	}
 }
@@ -70,7 +70,7 @@ func (f *ListField) Write(c *Context) {
 	case *Struct:
 		c.Putln("b += %sListBytes(buf[b:], v.%s)", t.SrcName(), f.SrcName())
 	default:
-		log.Fatalf("Cannot read list field '%s' with %T type.",
+		log.Panicf("Cannot read list field '%s' with %T type.",
 			f.XmlName(), f.Type)
 	}
 }
diff --git a/nexgb/xgbgen/go_reply.go b/nexgb/xgbgen/go_reply.go
new file mode 100644
index 0000000..e561d9c
--- /dev/null
+++ b/nexgb/xgbgen/go_reply.go
@@ -0,0 +1,19 @@
+package main
+
+func (r *Request) Define(c *Context) {
+	c.Putln("// Request %s", r.SrcName())
+	c.Putln("// size: %s", r.Size(c))
+	c.Putln("")
+	if r.Reply != nil {
+		c.Putln("// Request reply for %s", r.SrcName())
+		c.Putln("// size: %s", r.Reply.Size())
+		c.Putln("type %s struct {", r.ReplyName())
+		c.Putln("Sequence uint16")
+		for _, field := range r.Reply.Fields {
+			field.Define(c)
+		}
+		c.Putln("}")
+		c.Putln("")
+	}
+}
+
diff --git a/nexgb/xgbgen/representation.go b/nexgb/xgbgen/representation.go
index 2d33a45..e5d2202 100644
--- a/nexgb/xgbgen/representation.go
+++ b/nexgb/xgbgen/representation.go
@@ -1,5 +1,10 @@
 package main
 
+import (
+	"fmt"
+	"log"
+)
+
 type Protocol struct {
 	Name         string
 	ExtXName     string
@@ -44,10 +49,58 @@ func (r *Request) Initialize(p *Protocol) {
 	}
 }
 
+func (r *Request) SrcName() string {
+	return r.srcName
+}
+
+func (r *Request) XmlName() string {
+	return r.xmlName
+}
+
+func (r *Request) ReplyName() string {
+	if r.Reply == nil {
+		log.Panicf("Cannot call 'ReplyName' on request %s, which has no reply.",
+			r.SrcName())
+	}
+	return fmt.Sprintf("%sReply", r.SrcName())
+}
+
+// Size for Request needs a context.
+// Namely, if this is an extension, we need to account for *four* bytes
+// of a header (extension opcode, request opcode, and the sequence number).
+// If it's a core protocol request, then we only account for *three*
+// bytes of the header (remove the extension opcode).
+func (r *Request) Size(c *Context) Size {
+	size := newFixedSize(0)
+
+	if c.protocol.Name == "xproto" {
+		size = size.Add(newFixedSize(3))
+	} else {
+		size = size.Add(newFixedSize(4))
+	}
+
+	for _, field := range r.Fields {
+		size = size.Add(field.Size())
+	}
+	return size
+}
+
 type Reply struct {
 	Fields []Field
 }
 
+func (r *Reply) Size() Size {
+	size := newFixedSize(0)
+
+	// Account for reply discriminant, sequence number and reply length
+	size = size.Add(newFixedSize(7))
+
+	for _, field := range r.Fields {
+		size = size.Add(field.Size())
+	}
+	return size
+}
+
 func (r *Reply) Initialize(p *Protocol) {
 	for _, field := range r.Fields {
 		field.Initialize(p)
diff --git a/nexgb/xgbgen/translation.go b/nexgb/xgbgen/translation.go
index 36daa8b..9c7603b 100644
--- a/nexgb/xgbgen/translation.go
+++ b/nexgb/xgbgen/translation.go
@@ -210,11 +210,13 @@ func (x *XMLRequest) Translate() *Request {
 	// computation of the 'odd_length' field. However, 'string_len' is not
 	// defined. Therefore, let's forcefully add it as a 'local field'.
 	// (i.e., a parameter in the caller but does not get send over the wire.)
-	stringLenLocal := &LocalField{&SingleField{
-		xmlName: "string_len",
-		Type:    newTranslation("CARD16"),
-	}}
-	r.Fields = append(r.Fields, stringLenLocal)
+	if x.Name == "QueryTextExtents" {
+		stringLenLocal := &LocalField{&SingleField{
+			xmlName: "string_len",
+			Type:    newTranslation("CARD16"),
+		}}
+		r.Fields = append(r.Fields, stringLenLocal)
+	}
 
 	return r
 }
diff --git a/nexgb/xgbgen/type.go b/nexgb/xgbgen/type.go
index 1e06bda..d8e76a2 100644
--- a/nexgb/xgbgen/type.go
+++ b/nexgb/xgbgen/type.go
@@ -221,7 +221,7 @@ func (e *EventCopy) XmlName() string {
 }
 
 func (e *EventCopy) Size() Size {
-	panic("Cannot take size of EventCopy type.")
+	return newExpressionSize(&Value{v: 32})
 }
 
 func (e *EventCopy) Initialize(p *Protocol) {
@@ -252,11 +252,14 @@ func (e *Error) XmlName() string {
 }
 
 func (e *Error) Size() Size {
-	panic("Cannot take size of Error type.")
+	return newExpressionSize(&Value{v: 32})
 }
 
 func (e *Error) Initialize(p *Protocol) {
 	e.srcName = TypeSrcName(p, e)
+	for _, field := range e.Fields {
+		field.Initialize(p)
+	}
 }
 
 func (e *Error) ErrConst() string {
@@ -283,7 +286,7 @@ func (e *ErrorCopy) XmlName() string {
 }
 
 func (e *ErrorCopy) Size() Size {
-	panic("Cannot take size of ErrorCopy type.")
+	return newExpressionSize(&Value{v: 32})
 }
 
 func (e *ErrorCopy) Initialize(p *Protocol) {
diff --git a/nexgb/xgbgen/xml.go b/nexgb/xgbgen/xml.go
index f219c2d..1b2f89a 100644
--- a/nexgb/xgbgen/xml.go
+++ b/nexgb/xgbgen/xml.go
@@ -135,7 +135,7 @@ type XMLEvents []*XMLEvent
 type XMLEvent struct {
 	Name       string    `xml:"name,attr"`
 	Number     int       `xml:"number,attr"`
-	NoSequence bool      `xml:"no-sequence-number,true"`
+	NoSequence bool      `xml:"no-sequence-number,attr"`
 	Fields     XMLFields `xml:",any"`
 }
 
-- 
cgit v1.2.3-70-g09d2


From 5cdae5950c357564300c0ee3fb4dc9e7bbf4946b Mon Sep 17 00:00:00 2001
From: "Andrew Gallant (Ocelot)" <Andrew.Gallant@tufts.edu>
Date: Thu, 3 May 2012 01:00:01 -0400
Subject: holy toldeo... things might actually be working

---
 nexgb/xgb.go                     |    72 +-
 nexgb/xgb_help.go                |    82 +-
 nexgb/xgbgen/context.go          |    21 +
 nexgb/xgbgen/expression.go       |    73 +-
 nexgb/xgbgen/field.go            |    75 +-
 nexgb/xgbgen/go.go               |    53 +-
 nexgb/xgbgen/go_error.go         |    88 +-
 nexgb/xgbgen/go_event.go         |    15 +-
 nexgb/xgbgen/go_list.go          |    97 +-
 nexgb/xgbgen/go_reply.go         |    19 -
 nexgb/xgbgen/go_request_reply.go |   140 +
 nexgb/xgbgen/go_single_field.go  |    62 +-
 nexgb/xgbgen/go_struct.go        |    19 +-
 nexgb/xgbgen/go_union.go         |    17 +-
 nexgb/xgbgen/representation.go   |    19 +-
 nexgb/xgbgen/translation.go      |    17 +-
 nexgb/xgbgen/type.go             |    12 +
 nexgb/xproto.go                  | 11215 +++++++++++++++++++++++++++++++++++++
 18 files changed, 11831 insertions(+), 265 deletions(-)
 delete mode 100644 nexgb/xgbgen/go_reply.go
 create mode 100644 nexgb/xgbgen/go_request_reply.go
 create mode 100644 nexgb/xproto.go

(limited to 'nexgb/xgbgen/type.go')

diff --git a/nexgb/xgb.go b/nexgb/xgb.go
index ce2cc54..0dd8163 100644
--- a/nexgb/xgb.go
+++ b/nexgb/xgb.go
@@ -95,31 +95,20 @@ type Event interface {
 
 // newEventFuncs is a map from event numbers to functions that create
 // the corresponding event.
-var newEventFuncs map[int]func(buf []byte) Event
-
-// Error contains protocol errors returned to us by the X server.
-type Error struct {
-	Detail uint8
-	Major  uint8
-	Minor  uint16
-	Cookie uint16
-	Id     Id
-}
+var newEventFuncs = map[int]func(buf []byte) Event{}
 
-// Error2 is an interface that can contain any of the errors returned by
+// Error is an interface that can contain any of the errors returned by
 // the server. Use a type assertion switch to extract the Error structs.
-type Error2 interface {
+type Error interface {
 	ImplementsError()
+	SequenceId() uint16
+	BadId() Id
+	Error() string
 }
 
 // newErrorFuncs is a map from error numbers to functions that create
 // the corresponding error.
-var newErrorFuncs map[int]func(buf []byte) Error2
-
-func (e *Error) Error() string {
-	return fmt.Sprintf("Bad%s (major=%d minor=%d cookie=%d id=0x%x)",
-		errorNames[e.Detail], e.Major, e.Minor, e.Cookie, e.Id)
-}
+var newErrorFuncs = map[int]func(buf []byte) Error{}
 
 // NewID generates a new unused ID for use with requests like CreateWindow.
 func (c *Conn) NewId() Id {
@@ -136,7 +125,7 @@ func (c *Conn) NewId() Id {
 // the extensions map.
 func (c *Conn) RegisterExtension(name string) error {
 	nameUpper := strings.ToUpper(name)
-	reply, err := c.QueryExtension(nameUpper)
+	reply, err := c.QueryExtension(uint16(len(nameUpper)), nameUpper)
 
 	switch {
 	case err != nil:
@@ -253,25 +242,26 @@ func (c *Conn) newReadChannels() {
 
 			switch buf[0] {
 			case 0:
-				err := &Error{
-					Detail: buf[1],
-					Cookie: uint16(get16(buf[2:])),
-					Id:     Id(get32(buf[4:])),
-					Minor:  get16(buf[8:]),
-					Major:  buf[10],
-				}
-				if cookie, ok := c.cookies[err.Cookie]; ok {
+				// err := &Error{ 
+					// Detail: buf[1], 
+					// Cookie: uint16(get16(buf[2:])), 
+					// Id:     Id(get32(buf[4:])), 
+					// Minor:  get16(buf[8:]), 
+					// Major:  buf[10], 
+				// } 
+				err := newErrorFuncs[int(buf[1])](buf)
+				if cookie, ok := c.cookies[err.SequenceId()]; ok {
 					cookie.errorChan <- err
 				} else {
 					fmt.Fprintf(os.Stderr, "x protocol error: %s\n", err)
 				}
 			case 1:
-				seq := uint16(get16(buf[2:]))
+				seq := uint16(Get16(buf[2:]))
 				if _, ok := c.cookies[seq]; !ok {
 					continue
 				}
 
-				size := get32(buf[4:])
+				size := Get32(buf[4:])
 				if size > 0 {
 					bigbuf := make([]byte, 32+size*4, 32+size*4)
 					copy(bigbuf[0:32], buf)
@@ -317,7 +307,8 @@ func (c *Conn) waitForReply(cookie *Cookie) ([]byte, error) {
 func (c *Conn) WaitForEvent() (Event, error) {
 	for {
 		if reply := c.events.dequeue(c); reply != nil {
-			return parseEvent(reply)
+			evCode := reply[0] & 0x7f
+			return newEventFuncs[int(evCode)](reply), nil
 		}
 		if !<-c.eventChan {
 			return nil, errors.New("Event channel has been closed.")
@@ -331,7 +322,8 @@ func (c *Conn) WaitForEvent() (Event, error) {
 // Only use this function to empty the queue without blocking.
 func (c *Conn) PollForEvent() (Event, error) {
 	if reply := c.events.dequeue(c); reply != nil {
-		return parseEvent(reply)
+		evCode := reply[0] & 0x7f
+		return newEventFuncs[int(evCode)](reply), nil
 	}
 	return nil, nil
 }
@@ -369,11 +361,11 @@ func Dial(display string) (*Conn, error) {
 	buf := make([]byte, 12+pad(len(authName))+pad(len(authData)))
 	buf[0] = 0x6c
 	buf[1] = 0
-	put16(buf[2:], 11)
-	put16(buf[4:], 0)
-	put16(buf[6:], uint16(len(authName)))
-	put16(buf[8:], uint16(len(authData)))
-	put16(buf[10:], 0)
+	Put16(buf[2:], 11)
+	Put16(buf[4:], 0)
+	Put16(buf[6:], uint16(len(authName)))
+	Put16(buf[8:], uint16(len(authData)))
+	Put16(buf[10:], 0)
 	copy(buf[12:], []byte(authName))
 	copy(buf[12+pad(len(authName)):], authData)
 	if _, err = c.conn.Write(buf); err != nil {
@@ -386,9 +378,9 @@ func Dial(display string) (*Conn, error) {
 	}
 	code := head[0]
 	reasonLen := head[1]
-	major := get16(head[2:])
-	minor := get16(head[4:])
-	dataLen := get16(head[6:])
+	major := Get16(head[2:])
+	minor := Get16(head[4:])
+	dataLen := Get16(head[6:])
 
 	if major != 11 || minor != 0 {
 		return nil, errors.New(fmt.Sprintf("x protocol version mismatch: %d.%d", major, minor))
@@ -405,7 +397,7 @@ func Dial(display string) (*Conn, error) {
 		return nil, errors.New(fmt.Sprintf("x protocol authentication refused: %s", string(reason)))
 	}
 
-	getSetupInfo(buf, &c.Setup)
+	ReadSetupInfo(buf, &c.Setup)
 
 	if c.defaultScreen >= len(c.Setup.Roots) {
 		c.defaultScreen = 0
diff --git a/nexgb/xgb_help.go b/nexgb/xgb_help.go
index acb35de..f7b4948 100644
--- a/nexgb/xgb_help.go
+++ b/nexgb/xgb_help.go
@@ -1,5 +1,10 @@
 package xgb
 
+import (
+	"fmt"
+	"strings"
+)
+
 // getExtensionOpcode retrieves the extension opcode from the extensions map.
 // If one doesn't exist, just return 0. An X error will likely result.
 func (c *Conn) getExtensionOpcode(name string) byte {
@@ -14,52 +19,50 @@ func (c *Conn) bytesString(str string) []byte {
 	return c.bytesPadding([]byte(str))
 }
 
-func (c *Conn) bytesStrList(list []Str, length int) []byte {
-	buf := make([]byte, 0)
-	for _, str := range list {
-		buf = append(buf, []byte(str.Name)...)
-	}
-	return c.bytesPadding(buf)
-}
-
-func (c *Conn) bytesUInt32List(list []uint32) []byte {
-	buf := make([]byte, len(list)*4)
-	for i, item := range list {
-		put32(buf[i*4:], item)
-	}
-	return c.bytesPadding(buf)
+// stringsJoin is an alias to strings.Join. It allows us to avoid having to
+// import 'strings' in each of the generated Go files.
+func stringsJoin(ss []string, sep string) string {
+	return strings.Join(ss, sep)
 }
 
-func (c *Conn) bytesIdList(list []Id, length int) []byte {
-	buf := make([]byte, length*4)
-	for i, item := range list {
-		put32(buf[i*4:], uint32(item))
-	}
-	return c.bytesPadding(buf)
+// sprintf is so we don't need to import 'fmt' in the generated Go files.
+func sprintf(format string, v ...interface{}) string {
+	return fmt.Sprintf(format, v...)
 }
 
 // Pad a length to align on 4 bytes.
 func pad(n int) int { return (n + 3) & ^3 }
 
-func put16(buf []byte, v uint16) {
+func Put16(buf []byte, v uint16) {
+	buf[0] = byte(v)
+	buf[1] = byte(v >> 8)
+}
+
+func Put32(buf []byte, v uint32) {
 	buf[0] = byte(v)
 	buf[1] = byte(v >> 8)
+	buf[2] = byte(v >> 16)
+	buf[3] = byte(v >> 24)
 }
 
-func put32(buf []byte, v uint32) {
+func Put64(buf []byte, v uint64) {
 	buf[0] = byte(v)
 	buf[1] = byte(v >> 8)
 	buf[2] = byte(v >> 16)
 	buf[3] = byte(v >> 24)
+	buf[4] = byte(v >> 32)
+	buf[5] = byte(v >> 40)
+	buf[6] = byte(v >> 48)
+	buf[7] = byte(v >> 56)
 }
 
-func get16(buf []byte) uint16 {
+func Get16(buf []byte) uint16 {
 	v := uint16(buf[0])
 	v |= uint16(buf[1]) << 8
 	return v
 }
 
-func get32(buf []byte) uint32 {
+func Get32(buf []byte) uint32 {
 	v := uint32(buf[0])
 	v |= uint32(buf[1]) << 8
 	v |= uint32(buf[2]) << 16
@@ -67,6 +70,18 @@ func get32(buf []byte) uint32 {
 	return v
 }
 
+func Get64(buf []byte) uint64 {
+	v := uint64(buf[0])
+	v |= uint64(buf[1]) << 8
+	v |= uint64(buf[2]) << 16
+	v |= uint64(buf[3]) << 24
+	v |= uint64(buf[4]) << 32
+	v |= uint64(buf[5]) << 40
+	v |= uint64(buf[6]) << 48
+	v |= uint64(buf[7]) << 56
+	return v
+}
+
 // Voodoo to count the number of bits set in a value list mask.
 func popCount(mask0 int) int {
 	mask := uint32(mask0)
@@ -82,22 +97,3 @@ func popCount(mask0 int) int {
 // DefaultScreen returns the Screen info for the default screen, which is
 // 0 or the one given in the display argument to Dial.
 func (c *Conn) DefaultScreen() *ScreenInfo { return &c.Setup.Roots[c.defaultScreen] }
-
-// ClientMessageData holds the data from a client message,
-// duplicated in three forms because Go doesn't have unions.
-// type ClientMessageData struct { 
-	// Data8  [20]byte 
-	// Data16 [10]uint16 
-	// Data32 [5]uint32 
-// } 
-//  
-// func getClientMessageData(b []byte, v *ClientMessageData) int { 
-	// copy(v.Data8[:], b) 
-	// for i := 0; i < 10; i++ { 
-		// v.Data16[i] = get16(b[i*2:]) 
-	// } 
-	// for i := 0; i < 5; i++ { 
-		// v.Data32[i] = get32(b[i*4:]) 
-	// } 
-	// return 20 
-// } 
diff --git a/nexgb/xgbgen/context.go b/nexgb/xgbgen/context.go
index 33641b3..3e484f3 100644
--- a/nexgb/xgbgen/context.go
+++ b/nexgb/xgbgen/context.go
@@ -5,6 +5,7 @@ import (
 	"encoding/xml"
 	"fmt"
 	"log"
+	"time"
 )
 
 type Context struct {
@@ -47,6 +48,26 @@ func (c *Context) Morph(xmlBytes []byte) {
 	// Translate XML types to nice types
 	c.protocol = parsedXml.Translate()
 
+	// Start with Go header.
+	c.Putln("package xgb")
+	c.Putln("")
+	c.Putln("/*")
+	c.Putln("\tThis file was generated by %s.xml on %s.",
+		c.protocol.Name, time.Now().Format("Jan 2 2006 3:04:05pm MST"))
+	c.Putln("\tThis file is automatically generated. Edit at your peril!")
+	c.Putln("*/")
+	c.Putln("")
+
+	// Write imports in comments
+	if len(c.protocol.Imports) > 0 {
+		c.Putln("// Imports are not necessary for XGB because everything is ")
+		c.Putln("// in one package. They are still listed here for reference.")
+		for _, imp := range c.protocol.Imports {
+			c.Putln("// import \"%s\"", imp.Name)
+		}
+		c.Putln("")
+	}
+
 	// Now write Go source code
 	for _, typ := range c.protocol.Types {
 		typ.Define(c)
diff --git a/nexgb/xgbgen/expression.go b/nexgb/xgbgen/expression.go
index a975320..12bcb19 100644
--- a/nexgb/xgbgen/expression.go
+++ b/nexgb/xgbgen/expression.go
@@ -8,7 +8,7 @@ import (
 type Expression interface {
 	Concrete() bool
 	Eval() uint
-	Reduce(prefix, fun string) string
+	Reduce(prefix string) string
 	String() string
 	Initialize(p *Protocol)
 }
@@ -29,12 +29,12 @@ func (e *Function) Eval() uint {
 	panic("unreachable")
 }
 
-func (e *Function) Reduce(prefix, fun string) string {
-	return fmt.Sprintf("%s(%s)", e.Name, e.Expr.Reduce(prefix, fun))
+func (e *Function) Reduce(prefix string) string {
+	return fmt.Sprintf("%s(%s)", e.Name, e.Expr.Reduce(prefix))
 }
 
 func (e *Function) String() string {
-	return e.Reduce("", "")
+	return e.Reduce("")
 }
 
 func (e *Function) Initialize(p *Protocol) {
@@ -89,16 +89,34 @@ func (e *BinaryOp) Eval() uint {
 	panic("unreachable")
 }
 
-func (e *BinaryOp) Reduce(prefix, fun string) string {
+func (e *BinaryOp) Reduce(prefix string) string {
 	if e.Concrete() {
 		return fmt.Sprintf("%d", e.Eval())
 	}
+
+	// An incredibly dirty hack to make sure any time we perform an operation
+	// on a field, we're dealing with ints...
+	expr1, expr2 := e.Expr1, e.Expr2
+	switch expr1.(type) {
+	case *FieldRef:
+		expr1 = &Function{
+			Name: "int",
+			Expr: expr1,
+		}
+	}
+	switch expr2.(type) {
+	case *FieldRef:
+		expr2 = &Function{
+			Name: "int",
+			Expr: expr2,
+		}
+	}
 	return fmt.Sprintf("(%s %s %s)",
-		e.Expr1.Reduce(prefix, fun), e.Op, e.Expr2.Reduce(prefix, fun))
+		expr1.Reduce(prefix), e.Op, expr2.Reduce(prefix))
 }
 
 func (e *BinaryOp) String() string {
-	return e.Reduce("", "")
+	return e.Reduce("")
 }
 
 func (e *BinaryOp) Initialize(p *Protocol) {
@@ -125,15 +143,15 @@ func (e *UnaryOp) Eval() uint {
 	panic("unreachable")
 }
 
-func (e *UnaryOp) Reduce(prefix, fun string) string {
+func (e *UnaryOp) Reduce(prefix string) string {
 	if e.Concrete() {
 		return fmt.Sprintf("%d", e.Eval())
 	}
-	return fmt.Sprintf("(%s (%s))", e.Op, e.Expr.Reduce(prefix, fun))
+	return fmt.Sprintf("(%s (%s))", e.Op, e.Expr.Reduce(prefix))
 }
 
 func (e *UnaryOp) String() string {
-	return e.Reduce("", "")
+	return e.Reduce("")
 }
 
 func (e *UnaryOp) Initialize(p *Protocol) {
@@ -152,15 +170,15 @@ func (e *PopCount) Eval() uint {
 	return popCount(e.Expr.Eval())
 }
 
-func (e *PopCount) Reduce(prefix, fun string) string {
+func (e *PopCount) Reduce(prefix string) string {
 	if e.Concrete() {
 		return fmt.Sprintf("%d", e.Eval())
 	}
-	return fmt.Sprintf("popCount(%s)", e.Expr.Reduce(prefix, fun))
+	return fmt.Sprintf("popCount(%s)", e.Expr.Reduce(prefix))
 }
 
 func (e *PopCount) String() string {
-	return e.Reduce("", "")
+	return e.Reduce("")
 }
 
 func (e *PopCount) Initialize(p *Protocol) {
@@ -179,12 +197,12 @@ func (e *Value) Eval() uint {
 	return e.v
 }
 
-func (e *Value) Reduce(prefix, fun string) string {
+func (e *Value) Reduce(prefix string) string {
 	return fmt.Sprintf("%d", e.v)
 }
 
 func (e *Value) String() string {
-	return e.Reduce("", "")
+	return e.Reduce("")
 }
 
 func (e *Value) Initialize(p *Protocol) {}
@@ -201,12 +219,12 @@ func (e *Bit) Eval() uint {
 	return 1 << e.b
 }
 
-func (e *Bit) Reduce(prefix, fun string) string {
+func (e *Bit) Reduce(prefix string) string {
 	return fmt.Sprintf("%d", e.Eval())
 }
 
 func (e *Bit) String() string {
-	return e.Reduce("", "")
+	return e.Reduce("")
 }
 
 func (e *Bit) Initialize(p *Protocol) {}
@@ -224,19 +242,16 @@ func (e *FieldRef) Eval() uint {
 	panic("unreachable")
 }
 
-func (e *FieldRef) Reduce(prefix, fun string) string {
+func (e *FieldRef) Reduce(prefix string) string {
 	val := e.Name
 	if len(prefix) > 0 {
 		val = fmt.Sprintf("%s%s", prefix, val)
 	}
-	if len(fun) > 0 {
-		val = fmt.Sprintf("%s(%s)", fun, val)
-	}
 	return val
 }
 
 func (e *FieldRef) String() string {
-	return e.Reduce("", "")
+	return e.Reduce("")
 }
 
 func (e *FieldRef) Initialize(p *Protocol) {
@@ -257,16 +272,12 @@ func (e *EnumRef) Eval() uint {
 	panic("unreachable")
 }
 
-func (e *EnumRef) Reduce(prefix, fun string) string {
-	val := fmt.Sprintf("%s%s", e.EnumKind, e.EnumItem)
-	if len(fun) > 0 {
-		val = fmt.Sprintf("%s(%s)", fun, val)
-	}
-	return val
+func (e *EnumRef) Reduce(prefix string) string {
+	return fmt.Sprintf("%s%s", e.EnumKind, e.EnumItem)
 }
 
 func (e *EnumRef) String() string {
-	return e.Reduce("", "")
+	return e.Reduce("")
 }
 
 func (e *EnumRef) Initialize(p *Protocol) {
@@ -287,7 +298,7 @@ func (e *SumOf) Eval() uint {
 	panic("unreachable")
 }
 
-func (e *SumOf) Reduce(prefix, fun string) string {
+func (e *SumOf) Reduce(prefix string) string {
 	if len(prefix) > 0 {
 		return fmt.Sprintf("sum(%s%s)", prefix, e.Name)
 	}
@@ -295,7 +306,7 @@ func (e *SumOf) Reduce(prefix, fun string) string {
 }
 
 func (e *SumOf) String() string {
-	return e.Reduce("", "")
+	return e.Reduce("")
 }
 
 func (e *SumOf) Initialize(p *Protocol) {
diff --git a/nexgb/xgbgen/field.go b/nexgb/xgbgen/field.go
index 8d8412c..ddc2028 100644
--- a/nexgb/xgbgen/field.go
+++ b/nexgb/xgbgen/field.go
@@ -3,6 +3,7 @@ package main
 import (
 	"fmt"
 	"log"
+	"strings"
 )
 
 type Field interface {
@@ -13,8 +14,8 @@ type Field interface {
 	Size() Size
 
 	Define(c *Context)
-	Read(c *Context)
-	Write(c *Context)
+	Read(c *Context, prefix string)
+	Write(c *Context, prefix string)
 }
 
 func (pad *PadField) Initialize(p *Protocol) {}
@@ -32,7 +33,7 @@ func (p *PadField) XmlName() string {
 }
 
 func (f *PadField) SrcType() string {
-	panic("it is illegal to call SrcType on a SwitchField field")
+	panic("it is illegal to call SrcType on a PadField field")
 }
 
 func (p *PadField) Size() Size {
@@ -82,22 +83,48 @@ func (f *ListField) XmlName() string {
 }
 
 func (f *ListField) SrcType() string {
+	if strings.ToLower(f.Type.XmlName()) == "char" {
+		return fmt.Sprintf("string")
+	}
 	return fmt.Sprintf("[]%s", f.Type.SrcName())
 }
 
+func (f *ListField) Length() Size {
+	if f.LengthExpr == nil {
+		return newExpressionSize(&Function{
+			Name: "len",
+			Expr: &FieldRef{
+				Name: f.SrcName(),
+			},
+		})
+	}
+	return newExpressionSize(f.LengthExpr)
+}
+
 func (f *ListField) Size() Size {
 	simpleLen := &Function{
 		Name: "pad",
-		Expr: newBinaryOp("*", f.LengthExpr, f.Type.Size().Expression),
+		Expr: newBinaryOp("*", f.Length().Expression, f.Type.Size().Expression),
 	}
 
-	switch f.Type.(type) {
+	switch field := f.Type.(type) {
 	case *Struct:
-		sizeFun := &Function{
-			Name: fmt.Sprintf("%sListSize", f.Type.SrcName()),
-			Expr: &FieldRef{Name: f.SrcName()},
+		if field.HasList() {
+			sizeFun := &Function{
+				Name: fmt.Sprintf("%sListSize", f.Type.SrcName()),
+				Expr: &FieldRef{Name: f.SrcName()},
+			}
+			return newExpressionSize(sizeFun)
+		} else {
+			return newExpressionSize(simpleLen)
 		}
-		return newExpressionSize(sizeFun)
+	case *Union:
+		return newExpressionSize(simpleLen)
+		// sizeFun := &Function{ 
+			// Name: fmt.Sprintf("%sListSize", f.Type.SrcName()), 
+			// Expr: &FieldRef{Name: f.SrcName()}, 
+		// } 
+		// return newExpressionSize(sizeFun) 
 	case *Base:
 		return newExpressionSize(simpleLen)
 	case *Resource:
@@ -152,6 +179,7 @@ func (f *ExprField) Initialize(p *Protocol) {
 }
 
 type ValueField struct {
+	Parent interface{}
 	MaskType Type
 	MaskName string
 	ListName string
@@ -170,7 +198,34 @@ func (f *ValueField) SrcType() string {
 }
 
 func (f *ValueField) Size() Size {
-	return f.MaskType.Size()
+	maskSize := f.MaskType.Size()
+	listSize := newExpressionSize(&Function{
+		Name: "pad",
+		Expr: &BinaryOp{
+			Op: "*",
+			Expr1: &Value{v: 4},
+			Expr2: &PopCount{
+				Expr: &Function{
+					Name: "int",
+					Expr: &FieldRef{
+						Name: f.MaskName,
+					},
+				},
+			},
+		},
+	})
+	return maskSize.Add(listSize)
+}
+
+func (f *ValueField) ListLength() Size {
+	return newExpressionSize(&PopCount{
+		Expr: &Function{
+			Name: "int",
+			Expr: &FieldRef{
+				Name: f.MaskName,
+			},
+		},
+	})
 }
 
 func (f *ValueField) Initialize(p *Protocol) {
diff --git a/nexgb/xgbgen/go.go b/nexgb/xgbgen/go.go
index b7b153e..771cfcf 100644
--- a/nexgb/xgbgen/go.go
+++ b/nexgb/xgbgen/go.go
@@ -1,5 +1,9 @@
 package main
 
+import (
+	"fmt"
+)
+
 // xgbResourceIdName is the name of the type used for all resource identifiers.
 // As of right now, it needs to be declared somewhere manually.
 var xgbGenResourceIdName = "Id"
@@ -94,26 +98,28 @@ func (f *PadField) Define(c *Context) {
 	c.Putln("// padding: %d bytes", f.Bytes)
 }
 
-func (f *PadField) Read(c *Context) {
+func (f *PadField) Read(c *Context, prefix string) {
 	c.Putln("b += %s // padding", f.Size())
 }
 
-func (f *PadField) Write(c *Context) {
+func (f *PadField) Write(c *Context, prefix string) {
 	c.Putln("b += %s // padding", f.Size())
 }
 
 // Local fields
 func (f *LocalField) Define(c *Context) {
 	c.Putln("// local field: %s %s", f.SrcName(), f.Type.SrcName())
+	panic("unreachable")
 }
 
-func (f *LocalField) Read(c *Context) {
+func (f *LocalField) Read(c *Context, prefix string) {
 	c.Putln("// reading local field: %s (%s) :: %s",
 		f.SrcName(), f.Size(), f.Type.SrcName())
+	panic("unreachable")
 }
 
-func (f *LocalField) Write(c *Context) {
-	c.Putln("// writing local field: %s (%s) :: %s",
+func (f *LocalField) Write(c *Context, prefix string) {
+	c.Putln("// skip writing local field: %s (%s) :: %s",
 		f.SrcName(), f.Size(), f.Type.SrcName())
 }
 
@@ -121,32 +127,49 @@ func (f *LocalField) Write(c *Context) {
 func (f *ExprField) Define(c *Context) {
 	c.Putln("// expression field: %s %s (%s)",
 		f.SrcName(), f.Type.SrcName(), f.Expr)
+	panic("unreachable")
 }
 
-func (f *ExprField) Read(c *Context) {
+func (f *ExprField) Read(c *Context, prefix string) {
 	c.Putln("// reading expression field: %s (%s) (%s) :: %s",
 		f.SrcName(), f.Size(), f.Expr, f.Type.SrcName())
+	panic("unreachable")
 }
 
-func (f *ExprField) Write(c *Context) {
-	c.Putln("// writing expression field: %s (%s) (%s) :: %s",
-		f.SrcName(), f.Size(), f.Expr, f.Type.SrcName())
+func (f *ExprField) Write(c *Context, prefix string) {
+	// Special case for bools, grrr.
+	if f.Type.SrcName() == "bool" {
+		c.Putln("buf[b] = byte(%s)", f.Expr.Reduce(prefix))
+		c.Putln("b += 1")
+	} else {
+		WriteSimpleSingleField(c, f.Expr.Reduce(prefix), f.Type)
+	}
 }
 
 // Value field
 func (f *ValueField) Define(c *Context) {
 	c.Putln("// valueparam field: type: %s, mask name: %s, list name: %s",
 		f.MaskType.SrcName(), f.MaskName, f.ListName)
+	panic("todo")
 }
 
-func (f *ValueField) Read(c *Context) {
+func (f *ValueField) Read(c *Context, prefix string) {
 	c.Putln("// reading valueparam: type: %s, mask name: %s, list name: %s",
 		f.MaskType.SrcName(), f.MaskName, f.ListName)
+	panic("todo")
 }
 
-func (f *ValueField) Write(c *Context) {
-	c.Putln("// writing valueparam: type: %s, mask name: %s, list name: %s",
-		f.MaskType.SrcName(), f.MaskName, f.ListName)
+func (f *ValueField) Write(c *Context, prefix string) {
+	// big time mofos
+	if rq, ok := f.Parent.(*Request); !ok || rq.SrcName() != "ConfigureWindow" {
+		WriteSimpleSingleField(c,
+			fmt.Sprintf("%s%s", prefix, f.MaskName), f.MaskType)
+	}
+	c.Putln("for i := 0; i < %s; i++ {", f.ListLength().Reduce(prefix))
+	c.Putln("Put32(buf[b:], %s%s[i])", prefix, f.ListName)
+	c.Putln("b += 4")
+	c.Putln("}")
+	c.Putln("b = pad(b)")
 }
 
 // Switch field
@@ -155,12 +178,12 @@ func (f *SwitchField) Define(c *Context) {
 	panic("todo")
 }
 
-func (f *SwitchField) Read(c *Context) {
+func (f *SwitchField) Read(c *Context, prefix string) {
 	c.Putln("// reading switch field: %s (%s)", f.Name, f.Expr)
 	panic("todo")
 }
 
-func (f *SwitchField) Write(c *Context) {
+func (f *SwitchField) Write(c *Context, prefix string) {
 	c.Putln("// writing switch field: %s (%s)", f.Name, f.Expr)
 	panic("todo")
 }
diff --git a/nexgb/xgbgen/go_error.go b/nexgb/xgbgen/go_error.go
index 17c0db5..5a51064 100644
--- a/nexgb/xgbgen/go_error.go
+++ b/nexgb/xgbgen/go_error.go
@@ -1,5 +1,9 @@
 package main
 
+import (
+	"fmt"
+)
+
 // Error types
 func (e *Error) Define(c *Context) {
 	c.Putln("// Error definition %s (%d)", e.SrcName(), e.Number)
@@ -20,9 +24,8 @@ func (e *Error) Define(c *Context) {
 	// error struct.
 	e.Read(c)
 
-	// Makes sure that this error type is an Error interface.
-	c.Putln("func (v %s) ImplementsError() { }", e.ErrType())
-	c.Putln("")
+	// Makes sure this error type implements the xgb.Error interface.
+	e.ImplementsError(c)
 
 	// Let's the XGB event loop read this error.
 	c.Putln("func init() {")
@@ -33,18 +36,18 @@ func (e *Error) Define(c *Context) {
 
 func (e *Error) Read(c *Context) {
 	c.Putln("// Error read %s", e.SrcName())
-	c.Putln("func New%s(buf []byte) %s {", e.ErrType(), e.ErrType())
+	c.Putln("func New%s(buf []byte) Error {", e.ErrType())
 	c.Putln("v := %s{}", e.ErrType())
 	c.Putln("v.NiceName = \"%s\"", e.SrcName())
 	c.Putln("")
 	c.Putln("b := 1 // skip error determinant")
 	c.Putln("b += 1 // don't read error number")
 	c.Putln("")
-	c.Putln("v.Sequence = get16(buf[b:])")
+	c.Putln("v.Sequence = Get16(buf[b:])")
 	c.Putln("b += 2")
 	c.Putln("")
 	for _, field := range e.Fields {
-		field.Read(c)
+		field.Read(c, "v.")
 		c.Putln("")
 	}
 	c.Putln("return v")
@@ -52,6 +55,24 @@ func (e *Error) Read(c *Context) {
 	c.Putln("")
 }
 
+// ImplementsError writes functions to implement the XGB Error interface.
+func (e *Error) ImplementsError(c *Context) {
+	c.Putln("func (err %s) ImplementsError() { }", e.ErrType())
+	c.Putln("")
+	c.Putln("func (err %s) SequenceId() uint16 {", e.ErrType())
+	c.Putln("return err.Sequence")
+	c.Putln("}")
+	c.Putln("")
+	c.Putln("func (err %s) BadId() Id {", e.ErrType())
+	c.Putln("return Id(err.BadValue)")
+	c.Putln("}")
+	c.Putln("")
+	c.Putln("func (err %s) Error() string {", e.ErrType())
+	FieldString(c, e.Fields, e.ErrConst())
+	c.Putln("}")
+	c.Putln("")
+}
+
 // ErrorCopy types
 func (e *ErrorCopy) Define(c *Context) {
 	c.Putln("// ErrorCopy definition %s (%d)", e.SrcName(), e.Number)
@@ -65,9 +86,8 @@ func (e *ErrorCopy) Define(c *Context) {
 	// error struct.
 	e.Read(c)
 
-	// Makes sure that this error type is an Error interface.
-	c.Putln("func (err %s) ImplementsError() { }", e.ErrType())
-	c.Putln("")
+	// Makes sure this error type implements the xgb.Error interface.
+	e.ImplementsError(c)
 
 	// Let's the XGB know how to read this error.
 	c.Putln("func init() {")
@@ -77,8 +97,54 @@ func (e *ErrorCopy) Define(c *Context) {
 }
 
 func (e *ErrorCopy) Read(c *Context) {
-	c.Putln("func New%s(buf []byte) %s {", e.ErrType(), e.ErrType())
-	c.Putln("return %s(New%s(buf))", e.ErrType(), e.Old.(*Error).ErrType())
+	c.Putln("func New%s(buf []byte) Error {", e.ErrType())
+	c.Putln("v := %s(New%s(buf).(%s))",
+		e.ErrType(), e.Old.(*Error).ErrType(), e.Old.(*Error).ErrType())
+	c.Putln("v.NiceName = \"%s\"", e.SrcName())
+	c.Putln("return v")
+	c.Putln("}")
+	c.Putln("")
+}
+
+// ImplementsError writes functions to implement the XGB Error interface.
+func (e *ErrorCopy) ImplementsError(c *Context) {
+	c.Putln("func (err %s) ImplementsError() { }", e.ErrType())
+	c.Putln("")
+	c.Putln("func (err %s) SequenceId() uint16 {", e.ErrType())
+	c.Putln("return err.Sequence")
 	c.Putln("}")
 	c.Putln("")
+	c.Putln("func (err %s) BadId() Id {", e.ErrType())
+	c.Putln("return Id(err.BadValue)")
+	c.Putln("}")
+	c.Putln("")
+	c.Putln("func (err %s) Error() string {", e.ErrType())
+	FieldString(c, e.Old.(*Error).Fields, e.ErrConst())
+	c.Putln("}")
+	c.Putln("")
+}
+
+// FieldString works for both Error and ErrorCopy. It assembles all of the
+// fields in an error and formats them into a single string.
+func FieldString(c *Context, fields []Field, errName string) {
+	c.Putln("fieldVals := make([]string, 0, %d)", len(fields))
+	c.Putln("fieldVals = append(fieldVals, \"NiceName: \" + err.NiceName)")
+	c.Putln("fieldVals = append(fieldVals, " +
+		"sprintf(\"Sequence: %s\", err.Sequence))", "%d")
+	for _, field := range fields {
+		switch field.(type) {
+		case *PadField:
+			continue
+		default:
+			if field.SrcType() == "string" {
+				c.Putln("fieldVals = append(fieldVals, \"%s: \" + err.%s)",
+					field.SrcName(), field.SrcName())
+			} else {
+				format := fmt.Sprintf("sprintf(\"%s: %s\", err.%s)",
+					field.SrcName(), "%d", field.SrcName())
+				c.Putln("fieldVals = append(fieldVals, %s)", format)
+			}
+		}
+	}
+	c.Putln("return \"%s {\" + stringsJoin(fieldVals, \", \") + \"}\"", errName)
 }
diff --git a/nexgb/xgbgen/go_event.go b/nexgb/xgbgen/go_event.go
index fe2a77e..71252a7 100644
--- a/nexgb/xgbgen/go_event.go
+++ b/nexgb/xgbgen/go_event.go
@@ -38,17 +38,17 @@ func (e *Event) Define(c *Context) {
 
 func (e *Event) Read(c *Context) {
 	c.Putln("// Event read %s", e.SrcName())
-	c.Putln("func New%s(buf []byte) %s {", e.EvType(), e.EvType())
+	c.Putln("func New%s(buf []byte) Event {", e.EvType())
 	c.Putln("v := %s{}", e.EvType())
 	c.Putln("b := 1 // don't read event number")
 	c.Putln("")
 	for i, field := range e.Fields {
 		if i == 1 && !e.NoSequence {
-			c.Putln("v.Sequence = get16(buf[b:])")
+			c.Putln("v.Sequence = Get16(buf[b:])")
 			c.Putln("b += 2")
 			c.Putln("")
 		}
-		field.Read(c)
+		field.Read(c, "v.")
 		c.Putln("")
 	}
 	c.Putln("return v")
@@ -71,7 +71,7 @@ func (e *Event) Write(c *Context) {
 			c.Putln("b += 2 // skip sequence number")
 			c.Putln("")
 		}
-		field.Write(c)
+		field.Write(c, "v.")
 		c.Putln("")
 	}
 	c.Putln("return buf")
@@ -108,15 +108,16 @@ func (e *EventCopy) Define(c *Context) {
 }
 
 func (e *EventCopy) Read(c *Context) {
-	c.Putln("func New%s(buf []byte) %s {", e.EvType(), e.EvType())
-	c.Putln("return %s(New%s(buf))", e.EvType(), e.Old.(*Event).EvType())
+	c.Putln("func New%s(buf []byte) Event {", e.EvType())
+	c.Putln("return %s(New%s(buf).(%s))",
+		e.EvType(), e.Old.(*Event).EvType(), e.Old.(*Event).EvType())
 	c.Putln("}")
 	c.Putln("")
 }
 
 func (e *EventCopy) Write(c *Context) {
 	c.Putln("func (v %s) Bytes() []byte {", e.EvType())
-	c.Putln("return %s(ev).Bytes()", e.Old.(*Event).EvType())
+	c.Putln("return %s(v).Bytes()", e.Old.(*Event).EvType())
 	c.Putln("}")
 	c.Putln("")
 }
diff --git a/nexgb/xgbgen/go_list.go b/nexgb/xgbgen/go_list.go
index 67ecd34..41cfb76 100644
--- a/nexgb/xgbgen/go_list.go
+++ b/nexgb/xgbgen/go_list.go
@@ -3,74 +3,107 @@ package main
 import (
 	"fmt"
 	"log"
+	"strings"
 )
 
 // List fields
 func (f *ListField) Define(c *Context) {
-	c.Putln("%s []%s // size: %s",
-		f.SrcName(), f.Type.SrcName(), f.Size())
+	c.Putln("%s %s // size: %s",
+		f.SrcName(), f.SrcType(), f.Size())
 }
 
-func (f *ListField) Read(c *Context) {
+func (f *ListField) Read(c *Context, prefix string) {
 	switch t := f.Type.(type) {
 	case *Resource:
-		length := f.LengthExpr.Reduce("v.", "")
-		c.Putln("v.%s = make([]Id, %s)", f.SrcName(), length)
-		c.Putln("for i := 0; i < %s; i++ {", length)
-		ReadSimpleSingleField(c, fmt.Sprintf("v.%s[i]", f.SrcName()), t)
+		length := f.LengthExpr.Reduce(prefix)
+		c.Putln("%s%s = make([]Id, %s)", prefix, f.SrcName(), length)
+		c.Putln("for i := 0; i < int(%s); i++ {", length)
+		ReadSimpleSingleField(c, fmt.Sprintf("%s%s[i]", prefix, f.SrcName()), t)
 		c.Putln("}")
 		c.Putln("b = pad(b)")
 	case *Base:
-		length := f.LengthExpr.Reduce("v.", "")
-		c.Putln("v.%s = make([]%s, %s)", f.SrcName(), t.SrcName(), length)
-		if t.SrcName() == "byte" {
-			c.Putln("copy(v.%s[:%s], buf[b:])", f.SrcName(), length)
-			c.Putln("b += pad(%s)", length)
+		length := f.LengthExpr.Reduce(prefix)
+		if strings.ToLower(t.XmlName()) == "char" {
+			c.Putln("{")
+			c.Putln("byteString := make([]%s, %s)", t.SrcName(), length)
+			c.Putln("copy(byteString[:%s], buf[b:])", length)
+			c.Putln("%s%s = string(byteString)", prefix, f.SrcName())
+			c.Putln("b += pad(int(%s))", length)
+			c.Putln("}")
+		} else if t.SrcName() == "byte" {
+			c.Putln("%s%s = make([]%s, %s)",
+				prefix, f.SrcName(), t.SrcName(), length)
+			c.Putln("copy(%s%s[:%s], buf[b:])", prefix, f.SrcName(), length)
+			c.Putln("b += pad(int(%s))", length)
 		} else {
-			c.Putln("for i := 0; i < %s; i++ {", length)
-			ReadSimpleSingleField(c, fmt.Sprintf("v.%s[i]", f.SrcName()), t)
+			c.Putln("%s%s = make([]%s, %s)",
+				prefix, f.SrcName(), t.SrcName(), length)
+			c.Putln("for i := 0; i < int(%s); i++ {", length)
+			ReadSimpleSingleField(c,
+				fmt.Sprintf("%s%s[i]", prefix, f.SrcName()), t)
 			c.Putln("}")
 			c.Putln("b = pad(b)")
 		}
+	case *TypeDef:
+		length := f.LengthExpr.Reduce(prefix)
+		c.Putln("%s%s = make([]%s, %s)",
+			prefix, f.SrcName(), t.SrcName(), length)
+		c.Putln("for i := 0; i < int(%s); i++ {", length)
+		ReadSimpleSingleField(c, fmt.Sprintf("%s%s[i]", prefix, f.SrcName()), t)
+		c.Putln("}")
+		c.Putln("b = pad(b)")
 	case *Union:
-		c.Putln("v.%s = make([]%s, %s)",
-			f.SrcName(), t.SrcName(), f.LengthExpr.Reduce("v.", ""))
-		c.Putln("b += Read%sList(buf[b:], v.%s)", t.SrcName(), f.SrcName())
+		c.Putln("%s%s = make([]%s, %s)",
+			prefix, f.SrcName(), t.SrcName(), f.LengthExpr.Reduce(prefix))
+		c.Putln("b += Read%sList(buf[b:], %s%s)",
+			t.SrcName(), prefix, f.SrcName())
 	case *Struct:
-		c.Putln("v.%s = make([]%s, %s)",
-			f.SrcName(), t.SrcName(), f.LengthExpr.Reduce("v.", ""))
-		c.Putln("b += Read%sList(buf[b:], v.%s)", t.SrcName(), f.SrcName())
+		c.Putln("%s%s = make([]%s, %s)",
+			prefix, f.SrcName(), t.SrcName(), f.LengthExpr.Reduce(prefix))
+		c.Putln("b += Read%sList(buf[b:], %s%s)",
+			t.SrcName(), prefix, f.SrcName())
 	default:
 		log.Panicf("Cannot read list field '%s' with %T type.",
 			f.XmlName(), f.Type)
 	}
 }
 
-func (f *ListField) Write(c *Context) {
+func (f *ListField) Write(c *Context, prefix string) {
 	switch t := f.Type.(type) {
 	case *Resource:
-		length := f.LengthExpr.Reduce("v.", "")
-		c.Putln("for i := 0; i < %s; i++", length)
-		WriteSimpleSingleField(c, fmt.Sprintf("v.%s[i]", f.SrcName()), t)
+		length := f.Length().Reduce(prefix)
+		c.Putln("for i := 0; i < int(%s); i++ {", length)
+		WriteSimpleSingleField(c,
+			fmt.Sprintf("%s%s[i]", prefix, f.SrcName()), t)
 		c.Putln("}")
 		c.Putln("b = pad(b)")
 	case *Base:
-		length := f.LengthExpr.Reduce("v.", "")
+		length := f.Length().Reduce(prefix)
 		if t.SrcName() == "byte" {
-			c.Putln("copy(buf[b:], v.%s[:%s])", f.SrcName(), length)
-			c.Putln("b += pad(%s)", length)
+			c.Putln("copy(buf[b:], %s%s[:%s])", prefix, f.SrcName(), length)
+			c.Putln("b += pad(int(%s))", length)
 		} else {
-			c.Putln("for i := 0; i < %s; i++ {", length)
-			WriteSimpleSingleField(c, fmt.Sprintf("v.%s[i]", f.SrcName()), t)
+			c.Putln("for i := 0; i < int(%s); i++ {", length)
+			WriteSimpleSingleField(c,
+				fmt.Sprintf("%s%s[i]", prefix, f.SrcName()), t)
 			c.Putln("}")
 			c.Putln("b = pad(b)")
 		}
+	case *TypeDef:
+		length := f.Length().Reduce(prefix)
+		c.Putln("for i := 0; i < int(%s); i++ {", length)
+		WriteSimpleSingleField(c,
+			fmt.Sprintf("%s%s[i]", prefix, f.SrcName()), t)
+		c.Putln("}")
+		c.Putln("b = pad(b)")
 	case *Union:
-		c.Putln("b += %sListBytes(buf[b:], v.%s)", t.SrcName(), f.SrcName())
+		c.Putln("b += %sListBytes(buf[b:], %s%s)",
+			t.SrcName(), prefix, f.SrcName())
 	case *Struct:
-		c.Putln("b += %sListBytes(buf[b:], v.%s)", t.SrcName(), f.SrcName())
+		c.Putln("b += %sListBytes(buf[b:], %s%s)",
+			t.SrcName(), prefix, f.SrcName())
 	default:
-		log.Panicf("Cannot read list field '%s' with %T type.",
+		log.Panicf("Cannot write list field '%s' with %T type.",
 			f.XmlName(), f.Type)
 	}
 }
diff --git a/nexgb/xgbgen/go_reply.go b/nexgb/xgbgen/go_reply.go
deleted file mode 100644
index e561d9c..0000000
--- a/nexgb/xgbgen/go_reply.go
+++ /dev/null
@@ -1,19 +0,0 @@
-package main
-
-func (r *Request) Define(c *Context) {
-	c.Putln("// Request %s", r.SrcName())
-	c.Putln("// size: %s", r.Size(c))
-	c.Putln("")
-	if r.Reply != nil {
-		c.Putln("// Request reply for %s", r.SrcName())
-		c.Putln("// size: %s", r.Reply.Size())
-		c.Putln("type %s struct {", r.ReplyName())
-		c.Putln("Sequence uint16")
-		for _, field := range r.Reply.Fields {
-			field.Define(c)
-		}
-		c.Putln("}")
-		c.Putln("")
-	}
-}
-
diff --git a/nexgb/xgbgen/go_request_reply.go b/nexgb/xgbgen/go_request_reply.go
new file mode 100644
index 0000000..e6180a1
--- /dev/null
+++ b/nexgb/xgbgen/go_request_reply.go
@@ -0,0 +1,140 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (r *Request) Define(c *Context) {
+	c.Putln("// Request %s", r.SrcName())
+	c.Putln("// size: %s", r.Size(c))
+	if r.Reply != nil {
+		c.Putln("func (c *Conn) %s(%s) (*%s, error) {",
+			r.SrcName(), r.ParamNameTypes(), r.ReplyName())
+		c.Putln("return c.%s(c.%s(%s))",
+			r.ReplyName(), r.ReqName(), r.ParamNames())
+		c.Putln("}")
+		c.Putln("")
+
+		r.WriteRequest(c)
+		r.ReadReply(c)
+	} else {
+		c.Putln("// Write request to wire for %s", r.SrcName())
+		c.Putln("func (c *Conn) %s(%s) {", r.SrcName(), r.ParamNameTypes())
+		r.WriteRequestFields(c)
+		c.Putln("c.sendRequest(false, buf)")
+		c.Putln("}")
+		c.Putln("")
+	}
+}
+
+func (r *Request) ReadReply(c *Context) {
+	c.Putln("// Request reply for %s", r.SrcName())
+	c.Putln("// size: %s", r.Reply.Size())
+	c.Putln("type %s struct {", r.ReplyName())
+	c.Putln("Sequence uint16")
+	c.Putln("Length uint32")
+	for _, field := range r.Reply.Fields {
+		field.Define(c)
+	}
+	c.Putln("}")
+	c.Putln("")
+
+	c.Putln("// Read reply %s", r.SrcName())
+	c.Putln("func (c *Conn) %s(cook *Cookie) (*%s, error) {",
+		r.ReplyName(), r.ReplyName())
+	c.Putln("buf, err := c.waitForReply(cook)")
+	c.Putln("if err != nil {")
+	c.Putln("return nil, err")
+	c.Putln("}")
+	c.Putln("")
+	c.Putln("v := new(%s)", r.ReplyName())
+	c.Putln("b := 1 // skip reply determinant")
+	c.Putln("")
+	for i, field := range r.Reply.Fields {
+		if i == 1 {
+			c.Putln("v.Sequence = Get16(buf[b:])")
+			c.Putln("b += 2")
+			c.Putln("")
+			c.Putln("v.Length = Get32(buf[b:]) // 4-byte units")
+			c.Putln("b += 4")
+			c.Putln("")
+		}
+		field.Read(c, "v.")
+		c.Putln("")
+	}
+	c.Putln("return v, nil")
+	c.Putln("}")
+	c.Putln("")
+}
+
+func (r *Request) WriteRequest(c *Context) {
+	c.Putln("// Write request to wire for %s", r.SrcName())
+	c.Putln("func (c *Conn) %s(%s) *Cookie {", r.ReqName(), r.ParamNameTypes())
+	r.WriteRequestFields(c)
+	c.Putln("return c.sendRequest(true, buf)")
+	c.Putln("}")
+	c.Putln("")
+}
+
+func (r *Request) WriteRequestFields(c *Context) {
+	c.Putln("size := %s", r.Size(c))
+	c.Putln("b := 0")
+	c.Putln("buf := make([]byte, size)")
+	c.Putln("")
+	c.Putln("buf[b] = %d // request opcode", r.Opcode)
+	c.Putln("b += 1")
+	c.Putln("")
+	for i, field := range r.Fields {
+		if i == 1 {
+			c.Putln("Put16(buf[b:], uint16(size / 4)) "+
+				"// write request size in 4-byte units")
+			c.Putln("b += 2")
+			c.Putln("")
+		}
+		field.Write(c, "")
+		c.Putln("")
+	}
+}
+
+func (r *Request) ParamNames() string {
+	names := make([]string, 0, len(r.Fields))
+	for _, field := range r.Fields {
+		switch f := field.(type) {
+		case *ValueField:
+			names = append(names, f.MaskName)
+			names = append(names, f.ListName)
+		case *PadField:
+			continue
+		case *ExprField:
+			continue
+		default:
+			names = append(names, fmt.Sprintf("%s", field.SrcName()))
+		}
+	}
+	return strings.Join(names, ",")
+}
+
+func (r *Request) ParamNameTypes() string {
+	nameTypes := make([]string, 0, len(r.Fields))
+	for _, field := range r.Fields {
+		switch f := field.(type) {
+		case *ValueField:
+			// mofos...
+			if r.SrcName() != "ConfigureWindow" {
+				nameTypes = append(nameTypes,
+					fmt.Sprintf("%s %s", f.MaskName, f.MaskType.SrcName()))
+			}
+			nameTypes = append(nameTypes,
+				fmt.Sprintf("%s []uint32", f.ListName))
+		case *PadField:
+			continue
+		case *ExprField:
+			continue
+		default:
+			nameTypes = append(nameTypes,
+				fmt.Sprintf("%s %s", field.SrcName(), field.SrcType()))
+		}
+	}
+	return strings.Join(nameTypes, ",")
+}
diff --git a/nexgb/xgbgen/go_single_field.go b/nexgb/xgbgen/go_single_field.go
index bf31259..ea43d55 100644
--- a/nexgb/xgbgen/go_single_field.go
+++ b/nexgb/xgbgen/go_single_field.go
@@ -12,17 +12,17 @@ func (f *SingleField) Define(c *Context) {
 func ReadSimpleSingleField(c *Context, name string, typ Type) {
 	switch t := typ.(type) {
 	case *Resource:
-		c.Putln("%s = get32(buf[b:])", name)
+		c.Putln("%s = Id(Get32(buf[b:]))", name)
 	case *TypeDef:
 		switch t.Size().Eval() {
 		case 1:
 			c.Putln("%s = %s(buf[b])", name, t.SrcName())
 		case 2:
-			c.Putln("%s = %s(get16(buf[b:]))", name, t.SrcName())
+			c.Putln("%s = %s(Get16(buf[b:]))", name, t.SrcName())
 		case 4:
-			c.Putln("%s = %s(get32(buf[b:]))", name, t.SrcName())
+			c.Putln("%s = %s(Get32(buf[b:]))", name, t.SrcName())
 		case 8:
-			c.Putln("%s = %s(get64(buf[b:]))", name, t.SrcName())
+			c.Putln("%s = %s(Get64(buf[b:]))", name, t.SrcName())
 		}
 	case *Base:
 		// If this is a bool, stop short and do something special.
@@ -40,11 +40,11 @@ func ReadSimpleSingleField(c *Context, name string, typ Type) {
 		case 1:
 			val = fmt.Sprintf("buf[b]")
 		case 2:
-			val = fmt.Sprintf("get16(buf[b:])")
+			val = fmt.Sprintf("Get16(buf[b:])")
 		case 4:
-			val = fmt.Sprintf("get32(buf[b:])")
+			val = fmt.Sprintf("Get32(buf[b:])")
 		case 8:
-			val = fmt.Sprintf("get64(buf[b:])")
+			val = fmt.Sprintf("Get64(buf[b:])")
 		}
 
 		// We need to convert base types if they aren't uintXX or byte
@@ -61,20 +61,20 @@ func ReadSimpleSingleField(c *Context, name string, typ Type) {
 	c.Putln("b += %s", typ.Size())
 }
 
-func (f *SingleField) Read(c *Context) {
+func (f *SingleField) Read(c *Context, prefix string) {
 	switch t := f.Type.(type) {
 	case *Resource:
-		ReadSimpleSingleField(c, fmt.Sprintf("v.%s", f.SrcName()), t)
+		ReadSimpleSingleField(c, fmt.Sprintf("%s%s", prefix, f.SrcName()), t)
 	case *TypeDef:
-		ReadSimpleSingleField(c, fmt.Sprintf("v.%s", f.SrcName()), t)
+		ReadSimpleSingleField(c, fmt.Sprintf("%s%s", prefix, f.SrcName()), t)
 	case *Base:
-		ReadSimpleSingleField(c, fmt.Sprintf("v.%s", f.SrcName()), t)
+		ReadSimpleSingleField(c, fmt.Sprintf("%s%s", prefix, f.SrcName()), t)
 	case *Struct:
-		c.Putln("v.%s = %s{}", f.SrcName(), t.SrcName())
-		c.Putln("b += Read%s(buf[b:], &v.%s)", t.SrcName(), f.SrcName())
+		c.Putln("%s%s = %s{}", prefix, f.SrcName(), t.SrcName())
+		c.Putln("b += Read%s(buf[b:], &%s%s)", t.SrcName(), prefix, f.SrcName())
 	case *Union:
-		c.Putln("v.%s = %s{}", f.SrcName(), t.SrcName())
-		c.Putln("b += Read%s(buf[b:], &v.%s)", t.SrcName(), f.SrcName())
+		c.Putln("%s%s = %s{}", prefix, f.SrcName(), t.SrcName())
+		c.Putln("b += Read%s(buf[b:], &%s%s)", t.SrcName(), prefix, f.SrcName())
 	default:
 		log.Panicf("Cannot read field '%s' with %T type.", f.XmlName(), f.Type)
 	}
@@ -83,17 +83,17 @@ func (f *SingleField) Read(c *Context) {
 func WriteSimpleSingleField(c *Context, name string, typ Type) {
 	switch t := typ.(type) {
 	case *Resource:
-		c.Putln("put32(buf[b:], uint32(%s))", name)
+		c.Putln("Put32(buf[b:], uint32(%s))", name)
 	case *TypeDef:
 		switch t.Size().Eval() {
 		case 1:
 			c.Putln("buf[b] = byte(%s)", name)
 		case 2:
-			c.Putln("put16(buf[b:], uint16(%s))", name)
+			c.Putln("Put16(buf[b:], uint16(%s))", name)
 		case 4:
-			c.Putln("put32(buf[b:], uint32(%s))", name)
+			c.Putln("Put32(buf[b:], uint32(%s))", name)
 		case 8:
-			c.Putln("put64(buf[b:], uint64(%s))", name)
+			c.Putln("Put64(buf[b:], uint64(%s))", name)
 		}
 	case *Base:
 		// If this is a bool, stop short and do something special.
@@ -115,21 +115,21 @@ func WriteSimpleSingleField(c *Context, name string, typ Type) {
 			}
 		case 2:
 			if t.SrcName() != "uint16" {
-				c.Putln("put16(buf[b:], uint16(%s))", name)
+				c.Putln("Put16(buf[b:], uint16(%s))", name)
 			} else {
-				c.Putln("put16(buf[b:], %s)", name)
+				c.Putln("Put16(buf[b:], %s)", name)
 			}
 		case 4:
 			if t.SrcName() != "uint32" {
-				c.Putln("put32(buf[b:], uint32(%s))", name)
+				c.Putln("Put32(buf[b:], uint32(%s))", name)
 			} else {
-				c.Putln("put32(buf[b:], %s)", name)
+				c.Putln("Put32(buf[b:], %s)", name)
 			}
 		case 8:
 			if t.SrcName() != "uint64" {
-				c.Putln("put64(buf[b:], uint64(%s))", name)
+				c.Putln("Put64(buf[b:], uint64(%s))", name)
 			} else {
-				c.Putln("put64(buf[b:], %s)", name)
+				c.Putln("Put64(buf[b:], %s)", name)
 			}
 		}
 	default:
@@ -140,23 +140,23 @@ func WriteSimpleSingleField(c *Context, name string, typ Type) {
 	c.Putln("b += %s", typ.Size())
 }
 
-func (f *SingleField) Write(c *Context) {
+func (f *SingleField) Write(c *Context, prefix string) {
 	switch t := f.Type.(type) {
 	case *Resource:
-		ReadSimpleSingleField(c, fmt.Sprintf("v.%s", f.SrcName()), t)
+		WriteSimpleSingleField(c, fmt.Sprintf("%s%s", prefix, f.SrcName()), t)
 	case *TypeDef:
-		ReadSimpleSingleField(c, fmt.Sprintf("v.%s", f.SrcName()), t)
+		WriteSimpleSingleField(c, fmt.Sprintf("%s%s", prefix, f.SrcName()), t)
 	case *Base:
-		ReadSimpleSingleField(c, fmt.Sprintf("v.%s", f.SrcName()), t)
+		WriteSimpleSingleField(c, fmt.Sprintf("%s%s", prefix, f.SrcName()), t)
 	case *Union:
 		c.Putln("{")
-		c.Putln("unionBytes := v.%s.Bytes()", f.SrcName())
+		c.Putln("unionBytes := %s%s.Bytes()", prefix, f.SrcName())
 		c.Putln("copy(buf[b:], unionBytes)")
 		c.Putln("b += pad(len(unionBytes))")
 		c.Putln("}")
 	case *Struct:
 		c.Putln("{")
-		c.Putln("structBytes := v.%s.Bytes()", f.SrcName())
+		c.Putln("structBytes := %s%s.Bytes()", prefix, f.SrcName())
 		c.Putln("copy(buf[b:], structBytes)")
 		c.Putln("b += pad(len(structBytes))")
 		c.Putln("}")
diff --git a/nexgb/xgbgen/go_struct.go b/nexgb/xgbgen/go_struct.go
index 600ebaf..1e43199 100644
--- a/nexgb/xgbgen/go_struct.go
+++ b/nexgb/xgbgen/go_struct.go
@@ -22,8 +22,11 @@ func (s *Struct) Define(c *Context) {
 	// Write function that writes a list of this struct.
 	s.WriteList(c)
 
-	// Write function that computes the size of a list of these structs.
-	s.WriteListSize(c)
+	// Write function that computes the size of a list of these structs,
+	// IF there is a list field in this struct.
+	if s.HasList() {
+		s.WriteListSize(c)
+	}
 }
 
 // Read for a struct creates a function 'ReadStructName' that takes a source 
@@ -37,7 +40,8 @@ func (s *Struct) Read(c *Context) {
 	c.Putln("b := 0")
 	c.Putln("")
 	for _, field := range s.Fields {
-		field.Read(c)
+		field.Read(c, "v.")
+		c.Putln("")
 	}
 	c.Putln("return b")
 
@@ -68,11 +72,12 @@ func (s *Struct) ReadList(c *Context) {
 func (s *Struct) Write(c *Context) {
 	c.Putln("// Struct write %s", s.SrcName())
 	c.Putln("func (v %s) Bytes() []byte {", s.SrcName())
-	c.Putln("buf := make([]byte, %s)", s.Size().Reduce("v.", ""))
+	c.Putln("buf := make([]byte, %s)", s.Size().Reduce("v."))
 	c.Putln("b := 0")
 	c.Putln("")
 	for _, field := range s.Fields {
-		field.Write(c)
+		field.Write(c, "v.")
+		c.Putln("")
 	}
 	c.Putln("return buf")
 	c.Putln("}")
@@ -87,7 +92,7 @@ func (s *Struct) WriteList(c *Context) {
 	c.Putln("var structBytes []byte")
 	c.Putln("for _, item := range list {")
 	c.Putln("structBytes = item.Bytes()")
-	c.Putln("copy(buf[b:], len(structBytes))")
+	c.Putln("copy(buf[b:], structBytes)")
 	c.Putln("b += pad(len(structBytes))")
 	c.Putln("}")
 	c.Putln("return b")
@@ -100,7 +105,7 @@ func (s *Struct) WriteListSize(c *Context) {
 	c.Putln("func %sListSize(list []%s) int {", s.SrcName(), s.SrcName())
 	c.Putln("size := 0")
 	c.Putln("for _, item := range list {")
-	c.Putln("size += %s", s.Size().Reduce("item.", ""))
+	c.Putln("size += %s", s.Size().Reduce("item."))
 	c.Putln("}")
 	c.Putln("return size")
 	c.Putln("}")
diff --git a/nexgb/xgbgen/go_union.go b/nexgb/xgbgen/go_union.go
index 3b7365d..9f339af 100644
--- a/nexgb/xgbgen/go_union.go
+++ b/nexgb/xgbgen/go_union.go
@@ -34,9 +34,6 @@ func (u *Union) Define(c *Context) {
 
 	// Write function that writes a list of this union.
 	u.WriteList(c)
-
-	// Write function that computes the size of a list of these unions.
-	u.WriteListSize(c)
 }
 
 func (u *Union) New(c *Context) {
@@ -49,7 +46,7 @@ func (u *Union) New(c *Context) {
 		c.Putln("var b int")
 		c.Putln("buf := make([]byte, %s)", u.Size())
 		c.Putln("")
-		field.Write(c)
+		field.Write(c, "")
 		c.Putln("")
 		c.Putln("// Create the Union type")
 		c.Putln("v := %s{}", u.SrcName())
@@ -58,7 +55,7 @@ func (u *Union) New(c *Context) {
 		c.Putln("")
 		for _, field2 := range u.Fields {
 			c.Putln("b = 0 // always read the same bytes")
-			field2.Read(c)
+			field2.Read(c, "v.")
 			c.Putln("")
 		}
 		c.Putln("return v")
@@ -74,7 +71,7 @@ func (u *Union) Read(c *Context) {
 	c.Putln("")
 	for _, field := range u.Fields {
 		c.Putln("b = 0 // re-read the same bytes")
-		field.Read(c)
+		field.Read(c, "v.")
 		c.Putln("")
 	}
 	c.Putln("return %s", u.Size())
@@ -106,10 +103,10 @@ func (u *Union) Write(c *Context) {
 	c.Putln("// Each field in a union must contain the same data.")
 	c.Putln("// So simply pick the first field and write that to the wire.")
 	c.Putln("func (v %s) Bytes() []byte {", u.SrcName())
-	c.Putln("buf := make([]byte, %s)", u.Size().Reduce("v.", ""))
+	c.Putln("buf := make([]byte, %s)", u.Size().Reduce("v."))
 	c.Putln("b := 0")
 	c.Putln("")
-	u.Fields[0].Write(c)
+	u.Fields[0].Write(c, "v.")
 	c.Putln("return buf")
 	c.Putln("}")
 	c.Putln("")
@@ -123,7 +120,7 @@ func (u *Union) WriteList(c *Context) {
 	c.Putln("var unionBytes []byte")
 	c.Putln("for _, item := range list {")
 	c.Putln("unionBytes = item.Bytes()")
-	c.Putln("copy(buf[b:], len(unionBytes))")
+	c.Putln("copy(buf[b:], unionBytes)")
 	c.Putln("b += pad(len(unionBytes))")
 	c.Putln("}")
 	c.Putln("return b")
@@ -136,7 +133,7 @@ func (u *Union) WriteListSize(c *Context) {
 	c.Putln("func %sListSize(list []%s) int {", u.SrcName(), u.SrcName())
 	c.Putln("size := 0")
 	c.Putln("for _, item := range list {")
-	c.Putln("size += %s", u.Size().Reduce("item.", ""))
+	c.Putln("size += %s", u.Size().Reduce("item."))
 	c.Putln("}")
 	c.Putln("return size")
 	c.Putln("}")
diff --git a/nexgb/xgbgen/representation.go b/nexgb/xgbgen/representation.go
index e5d2202..ef62157 100644
--- a/nexgb/xgbgen/representation.go
+++ b/nexgb/xgbgen/representation.go
@@ -65,6 +65,10 @@ func (r *Request) ReplyName() string {
 	return fmt.Sprintf("%sReply", r.SrcName())
 }
 
+func (r *Request) ReqName() string {
+	return fmt.Sprintf("%sRequest", r.SrcName())
+}
+
 // Size for Request needs a context.
 // Namely, if this is an extension, we need to account for *four* bytes
 // of a header (extension opcode, request opcode, and the sequence number).
@@ -80,7 +84,20 @@ func (r *Request) Size(c *Context) Size {
 	}
 
 	for _, field := range r.Fields {
-		size = size.Add(field.Size())
+		switch field.(type) {
+		case *LocalField:
+			continue
+		case *SingleField:
+			// mofos!!!
+			if r.SrcName() == "ConfigureWindow" &&
+				field.SrcName() == "ValueMask" {
+
+				continue
+			}
+			size = size.Add(field.Size())
+		default:
+			size = size.Add(field.Size())
+		}
 	}
 	return size
 }
diff --git a/nexgb/xgbgen/translation.go b/nexgb/xgbgen/translation.go
index 9c7603b..fe5a52b 100644
--- a/nexgb/xgbgen/translation.go
+++ b/nexgb/xgbgen/translation.go
@@ -138,7 +138,7 @@ func (x *XMLEvent) Translate() *Event {
 		Fields:     make([]Field, len(x.Fields)),
 	}
 	for i, field := range x.Fields {
-		ev.Fields[i] = field.Translate()
+		ev.Fields[i] = field.Translate(ev)
 	}
 	return ev
 }
@@ -158,7 +158,7 @@ func (x *XMLError) Translate() *Error {
 		Fields:  make([]Field, len(x.Fields)),
 	}
 	for i, field := range x.Fields {
-		err.Fields[i] = field.Translate()
+		err.Fields[i] = field.Translate(err)
 	}
 	return err
 }
@@ -177,7 +177,7 @@ func (x *XMLStruct) Translate() *Struct {
 		Fields:  make([]Field, len(x.Fields)),
 	}
 	for i, field := range x.Fields {
-		s.Fields[i] = field.Translate()
+		s.Fields[i] = field.Translate(s)
 	}
 	return s
 }
@@ -188,7 +188,7 @@ func (x *XMLUnion) Translate() *Union {
 		Fields:  make([]Field, len(x.Fields)),
 	}
 	for i, field := range x.Fields {
-		u.Fields[i] = field.Translate()
+		u.Fields[i] = field.Translate(u)
 	}
 	return u
 }
@@ -202,7 +202,7 @@ func (x *XMLRequest) Translate() *Request {
 		Reply:   x.Reply.Translate(),
 	}
 	for i, field := range x.Fields {
-		r.Fields[i] = field.Translate()
+		r.Fields[i] = field.Translate(r)
 	}
 
 	// Address bug (or legacy code) in QueryTextExtents.
@@ -230,7 +230,7 @@ func (x *XMLReply) Translate() *Reply {
 		Fields: make([]Field, len(x.Fields)),
 	}
 	for i, field := range x.Fields {
-		r.Fields[i] = field.Translate()
+		r.Fields[i] = field.Translate(r)
 	}
 	return r
 }
@@ -309,7 +309,7 @@ func (x *XMLExpression) Translate() Expression {
 	panic("unreachable")
 }
 
-func (x *XMLField) Translate() Field {
+func (x *XMLField) Translate(parent interface{}) Field {
 	switch x.XMLName.Local {
 	case "pad":
 		return &PadField{
@@ -339,6 +339,7 @@ func (x *XMLField) Translate() Field {
 		}
 	case "valueparam":
 		return &ValueField{
+			Parent: parent,
 			MaskType: newTranslation(x.ValueMaskType),
 			MaskName: x.ValueMaskName,
 			ListName: x.ValueListName,
@@ -365,7 +366,7 @@ func (x *XMLBitcase) Translate() *Bitcase {
 		Fields: make([]Field, len(x.Fields)),
 	}
 	for i, field := range x.Fields {
-		b.Fields[i] = field.Translate()
+		b.Fields[i] = field.Translate(b)
 	}
 	return b
 }
diff --git a/nexgb/xgbgen/type.go b/nexgb/xgbgen/type.go
index d8e76a2..3498463 100644
--- a/nexgb/xgbgen/type.go
+++ b/nexgb/xgbgen/type.go
@@ -334,6 +334,18 @@ func (s *Struct) Initialize(p *Protocol) {
 	}
 }
 
+// HasList returns whether there is a field in this struct that is a list.
+// When true, a more involved calculation is necessary to compute this struct's
+// size.
+func (s *Struct) HasList() bool {
+	for _, field := range s.Fields {
+		if _, ok := field.(*ListField); ok {
+			return true
+		}
+	}
+	return false
+}
+
 type Union struct {
 	srcName string
 	xmlName string
diff --git a/nexgb/xproto.go b/nexgb/xproto.go
new file mode 100644
index 0000000..3317b51
--- /dev/null
+++ b/nexgb/xproto.go
@@ -0,0 +1,11215 @@
+package xgb
+
+/*
+	This file was generated by xproto.xml on May 3 2012 12:48:47am EDT.
+	This file is automatically generated. Edit at your peril!
+*/
+
+// Skipping definition for base type 'Float'
+
+// Skipping definition for base type 'Id'
+
+// Skipping definition for base type 'Card8'
+
+// Skipping definition for base type 'Int16'
+
+// Skipping definition for base type 'Int32'
+
+// Skipping definition for base type 'Void'
+
+// Skipping definition for base type 'Byte'
+
+// Skipping definition for base type 'Int8'
+
+// Skipping definition for base type 'Card16'
+
+// Skipping definition for base type 'Char'
+
+// Skipping definition for base type 'Card32'
+
+// Skipping definition for base type 'Double'
+
+// Skipping definition for base type 'Bool'
+
+const (
+	VisualClassStaticGray  = 0
+	VisualClassGrayScale   = 1
+	VisualClassStaticColor = 2
+	VisualClassPseudoColor = 3
+	VisualClassTrueColor   = 4
+	VisualClassDirectColor = 5
+)
+
+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
+)
+
+const (
+	ImageOrderLSBFirst = 0
+	ImageOrderMSBFirst = 1
+)
+
+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 (
+	ButtonMask1   = 256
+	ButtonMask2   = 512
+	ButtonMask3   = 1024
+	ButtonMask4   = 2048
+	ButtonMask5   = 4096
+	ButtonMaskAny = 32768
+)
+
+const (
+	MotionNormal = 0
+	MotionHint   = 1
+)
+
+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 (
+	VisibilityUnobscured        = 0
+	VisibilityPartiallyObscured = 1
+	VisibilityFullyObscured     = 2
+)
+
+const (
+	PlaceOnTop    = 0
+	PlaceOnBottom = 1
+)
+
+const (
+	PropertyNewValue = 0
+	PropertyDelete   = 1
+)
+
+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 (
+	ColormapStateUninstalled = 0
+	ColormapStateInstalled   = 1
+)
+
+const (
+	ColormapNone = 0
+)
+
+const (
+	MappingModifier = 0
+	MappingKeyboard = 1
+	MappingPointer  = 2
+)
+
+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
+)
+
+const (
+	MapStateUnmapped   = 0
+	MapStateUnviewable = 1
+	MapStateViewable   = 2
+)
+
+const (
+	SetModeInsert = 0
+	SetModeDelete = 1
+)
+
+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
+)
+
+const (
+	CirculateRaiseLowest  = 0
+	CirculateLowerHighest = 1
+)
+
+const (
+	PropModeReplace = 0
+	PropModePrepend = 1
+	PropModeAppend  = 2
+)
+
+const (
+	GetPropertyTypeAny = 0
+)
+
+const (
+	SendEventDestPointerWindow = 0
+	SendEventDestItemFocus     = 1
+)
+
+const (
+	GrabModeSync  = 0
+	GrabModeAsync = 1
+)
+
+const (
+	GrabStatusSuccess        = 0
+	GrabStatusAlreadyGrabbed = 1
+	GrabStatusInvalidTime    = 2
+	GrabStatusNotViewable    = 3
+	GrabStatusFrozen         = 4
+)
+
+const (
+	CursorNone = 0
+)
+
+const (
+	ButtonIndexAny = 0
+	ButtonIndex1   = 1
+	ButtonIndex2   = 2
+	ButtonIndex3   = 3
+	ButtonIndex4   = 4
+	ButtonIndex5   = 5
+)
+
+const (
+	GrabAny = 0
+)
+
+const (
+	AllowAsyncPointer   = 0
+	AllowSyncPointer    = 1
+	AllowReplayPointer  = 2
+	AllowAsyncKeyboard  = 3
+	AllowSyncKeyboard   = 4
+	AllowReplayKeyboard = 5
+	AllowAsyncBoth      = 6
+	AllowSyncBoth       = 7
+)
+
+const (
+	InputFocusNone           = 0
+	InputFocusPointerRoot    = 1
+	InputFocusParent         = 2
+	InputFocusFollowKeyboard = 3
+)
+
+const (
+	FontDrawLeftToRight = 0
+	FontDrawRightToLeft = 1
+)
+
+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
+)
+
+const (
+	ClipOrderingUnsorted = 0
+	ClipOrderingYSorted  = 1
+	ClipOrderingYXSorted = 2
+	ClipOrderingYXBanded = 3
+)
+
+const (
+	CoordModeOrigin   = 0
+	CoordModePrevious = 1
+)
+
+const (
+	PolyShapeComplex   = 0
+	PolyShapeNonconvex = 1
+	PolyShapeConvex    = 2
+)
+
+const (
+	ImageFormatXYBitmap = 0
+	ImageFormatXYPixmap = 1
+	ImageFormatZPixmap  = 2
+)
+
+const (
+	ColormapAllocNone = 0
+	ColormapAllocAll  = 1
+)
+
+const (
+	ColorFlagRed   = 1
+	ColorFlagGreen = 2
+	ColorFlagBlue  = 4
+)
+
+const (
+	PixmapNone = 0
+)
+
+const (
+	FontNone = 0
+)
+
+const (
+	QueryShapeOfLargestCursor  = 0
+	QueryShapeOfFastestTile    = 1
+	QueryShapeOfFastestStipple = 2
+)
+
+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
+)
+
+const (
+	BlankingNotPreferred = 0
+	BlankingPreferred    = 1
+	BlankingDefault      = 2
+)
+
+const (
+	ExposuresNotAllowed = 0
+	ExposuresAllowed    = 1
+	ExposuresDefault    = 2
+)
+
+const (
+	HostModeInsert = 0
+	HostModeDelete = 1
+)
+
+const (
+	FamilyInternet          = 0
+	FamilyDECnet            = 1
+	FamilyChaos             = 2
+	FamilyServerInterpreted = 5
+	FamilyInternet6         = 6
+)
+
+const (
+	AccessControlDisable = 0
+	AccessControlEnable  = 1
+)
+
+const (
+	CloseDownDestroyAll      = 0
+	CloseDownRetainPermanent = 1
+	CloseDownRetainTemporary = 2
+)
+
+const (
+	KillAllTemporary = 0
+)
+
+const (
+	ScreenSaverReset  = 0
+	ScreenSaverActive = 1
+)
+
+const (
+	MappingStatusSuccess = 0
+	MappingStatusBusy    = 1
+	MappingStatusFailure = 2
+)
+
+const (
+	MapIndexShift   = 0
+	MapIndexLock    = 1
+	MapIndexControl = 2
+	MapIndex1       = 3
+	MapIndex2       = 4
+	MapIndex3       = 5
+	MapIndex4       = 6
+	MapIndex5       = 7
+)
+
+// Skipping resource definition of 'Window'
+
+// Skipping resource definition of 'Pixmap'
+
+// Skipping resource definition of 'Cursor'
+
+// Skipping resource definition of 'Font'
+
+// Skipping resource definition of 'Gcontext'
+
+// Skipping resource definition of 'Colormap'
+
+// Skipping resource definition of 'Atom'
+
+// Skipping resource definition of 'Drawable'
+
+// Skipping resource definition of 'Fontable'
+
+type Visualid uint32
+
+type Timestamp uint32
+
+type Keysym uint32
+
+type Keycode byte
+
+type Button byte
+
+// 'Char2b' struct definition
+// Size: 2
+type Char2b struct {
+	Byte1 byte
+	Byte2 byte
+}
+
+// Struct read Char2b
+func ReadChar2b(buf []byte, v *Char2b) int {
+	b := 0
+
+	v.Byte1 = buf[b]
+	b += 1
+
+	v.Byte2 = buf[b]
+	b += 1
+
+	return b
+}
+
+// Struct list read Char2b
+func ReadChar2bList(buf []byte, dest []Char2b) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = Char2b{}
+		b += ReadChar2b(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write Char2b
+func (v Char2b) Bytes() []byte {
+	buf := make([]byte, 2)
+	b := 0
+
+	buf[b] = v.Byte1
+	b += 1
+
+	buf[b] = v.Byte2
+	b += 1
+
+	return buf
+}
+
+// Write struct list Char2b
+func Char2bListBytes(buf []byte, list []Char2b) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// 'Point' struct definition
+// Size: 4
+type Point struct {
+	X int16
+	Y int16
+}
+
+// Struct read Point
+func ReadPoint(buf []byte, v *Point) int {
+	b := 0
+
+	v.X = int16(Get16(buf[b:]))
+	b += 2
+
+	v.Y = int16(Get16(buf[b:]))
+	b += 2
+
+	return b
+}
+
+// Struct list read Point
+func ReadPointList(buf []byte, dest []Point) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = Point{}
+		b += ReadPoint(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write Point
+func (v Point) Bytes() []byte {
+	buf := make([]byte, 4)
+	b := 0
+
+	Put16(buf[b:], uint16(v.X))
+	b += 2
+
+	Put16(buf[b:], uint16(v.Y))
+	b += 2
+
+	return buf
+}
+
+// Write struct list Point
+func PointListBytes(buf []byte, list []Point) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// 'Rectangle' struct definition
+// Size: 8
+type Rectangle struct {
+	X      int16
+	Y      int16
+	Width  uint16
+	Height uint16
+}
+
+// Struct read Rectangle
+func ReadRectangle(buf []byte, v *Rectangle) int {
+	b := 0
+
+	v.X = int16(Get16(buf[b:]))
+	b += 2
+
+	v.Y = int16(Get16(buf[b:]))
+	b += 2
+
+	v.Width = Get16(buf[b:])
+	b += 2
+
+	v.Height = Get16(buf[b:])
+	b += 2
+
+	return b
+}
+
+// Struct list read Rectangle
+func ReadRectangleList(buf []byte, dest []Rectangle) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = Rectangle{}
+		b += ReadRectangle(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write Rectangle
+func (v Rectangle) Bytes() []byte {
+	buf := make([]byte, 8)
+	b := 0
+
+	Put16(buf[b:], uint16(v.X))
+	b += 2
+
+	Put16(buf[b:], uint16(v.Y))
+	b += 2
+
+	Put16(buf[b:], v.Width)
+	b += 2
+
+	Put16(buf[b:], v.Height)
+	b += 2
+
+	return buf
+}
+
+// Write struct list Rectangle
+func RectangleListBytes(buf []byte, list []Rectangle) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// 'Arc' struct definition
+// Size: 12
+type Arc struct {
+	X      int16
+	Y      int16
+	Width  uint16
+	Height uint16
+	Angle1 int16
+	Angle2 int16
+}
+
+// Struct read Arc
+func ReadArc(buf []byte, v *Arc) int {
+	b := 0
+
+	v.X = int16(Get16(buf[b:]))
+	b += 2
+
+	v.Y = int16(Get16(buf[b:]))
+	b += 2
+
+	v.Width = Get16(buf[b:])
+	b += 2
+
+	v.Height = Get16(buf[b:])
+	b += 2
+
+	v.Angle1 = int16(Get16(buf[b:]))
+	b += 2
+
+	v.Angle2 = int16(Get16(buf[b:]))
+	b += 2
+
+	return b
+}
+
+// Struct list read Arc
+func ReadArcList(buf []byte, dest []Arc) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = Arc{}
+		b += ReadArc(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write Arc
+func (v Arc) Bytes() []byte {
+	buf := make([]byte, 12)
+	b := 0
+
+	Put16(buf[b:], uint16(v.X))
+	b += 2
+
+	Put16(buf[b:], uint16(v.Y))
+	b += 2
+
+	Put16(buf[b:], v.Width)
+	b += 2
+
+	Put16(buf[b:], v.Height)
+	b += 2
+
+	Put16(buf[b:], uint16(v.Angle1))
+	b += 2
+
+	Put16(buf[b:], uint16(v.Angle2))
+	b += 2
+
+	return buf
+}
+
+// Write struct list Arc
+func ArcListBytes(buf []byte, list []Arc) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// 'Format' struct definition
+// Size: 8
+type Format struct {
+	Depth        byte
+	BitsPerPixel byte
+	ScanlinePad  byte
+	// padding: 5 bytes
+}
+
+// Struct read Format
+func ReadFormat(buf []byte, v *Format) int {
+	b := 0
+
+	v.Depth = buf[b]
+	b += 1
+
+	v.BitsPerPixel = buf[b]
+	b += 1
+
+	v.ScanlinePad = buf[b]
+	b += 1
+
+	b += 5 // padding
+
+	return b
+}
+
+// Struct list read Format
+func ReadFormatList(buf []byte, dest []Format) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = Format{}
+		b += ReadFormat(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write Format
+func (v Format) Bytes() []byte {
+	buf := make([]byte, 8)
+	b := 0
+
+	buf[b] = v.Depth
+	b += 1
+
+	buf[b] = v.BitsPerPixel
+	b += 1
+
+	buf[b] = v.ScanlinePad
+	b += 1
+
+	b += 5 // padding
+
+	return buf
+}
+
+// Write struct list Format
+func FormatListBytes(buf []byte, list []Format) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// 'VisualInfo' struct definition
+// Size: 24
+type VisualInfo struct {
+	VisualId        Visualid
+	Class           byte
+	BitsPerRgbValue byte
+	ColormapEntries uint16
+	RedMask         uint32
+	GreenMask       uint32
+	BlueMask        uint32
+	// padding: 4 bytes
+}
+
+// Struct read VisualInfo
+func ReadVisualInfo(buf []byte, v *VisualInfo) int {
+	b := 0
+
+	v.VisualId = Visualid(Get32(buf[b:]))
+	b += 4
+
+	v.Class = buf[b]
+	b += 1
+
+	v.BitsPerRgbValue = buf[b]
+	b += 1
+
+	v.ColormapEntries = Get16(buf[b:])
+	b += 2
+
+	v.RedMask = Get32(buf[b:])
+	b += 4
+
+	v.GreenMask = Get32(buf[b:])
+	b += 4
+
+	v.BlueMask = Get32(buf[b:])
+	b += 4
+
+	b += 4 // padding
+
+	return b
+}
+
+// Struct list read VisualInfo
+func ReadVisualInfoList(buf []byte, dest []VisualInfo) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = VisualInfo{}
+		b += ReadVisualInfo(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write VisualInfo
+func (v VisualInfo) Bytes() []byte {
+	buf := make([]byte, 24)
+	b := 0
+
+	Put32(buf[b:], uint32(v.VisualId))
+	b += 4
+
+	buf[b] = v.Class
+	b += 1
+
+	buf[b] = v.BitsPerRgbValue
+	b += 1
+
+	Put16(buf[b:], v.ColormapEntries)
+	b += 2
+
+	Put32(buf[b:], v.RedMask)
+	b += 4
+
+	Put32(buf[b:], v.GreenMask)
+	b += 4
+
+	Put32(buf[b:], v.BlueMask)
+	b += 4
+
+	b += 4 // padding
+
+	return buf
+}
+
+// Write struct list VisualInfo
+func VisualInfoListBytes(buf []byte, list []VisualInfo) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// 'DepthInfo' struct definition
+// Size: (8 + pad((int(VisualsLen) * 24)))
+type DepthInfo struct {
+	Depth byte
+	// padding: 1 bytes
+	VisualsLen uint16
+	// padding: 4 bytes
+	Visuals []VisualInfo // size: pad((int(VisualsLen) * 24))
+}
+
+// Struct read DepthInfo
+func ReadDepthInfo(buf []byte, v *DepthInfo) int {
+	b := 0
+
+	v.Depth = buf[b]
+	b += 1
+
+	b += 1 // padding
+
+	v.VisualsLen = Get16(buf[b:])
+	b += 2
+
+	b += 4 // padding
+
+	v.Visuals = make([]VisualInfo, v.VisualsLen)
+	b += ReadVisualInfoList(buf[b:], v.Visuals)
+
+	return b
+}
+
+// Struct list read DepthInfo
+func ReadDepthInfoList(buf []byte, dest []DepthInfo) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = DepthInfo{}
+		b += ReadDepthInfo(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write DepthInfo
+func (v DepthInfo) Bytes() []byte {
+	buf := make([]byte, (8 + pad((int(v.VisualsLen) * 24))))
+	b := 0
+
+	buf[b] = v.Depth
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], v.VisualsLen)
+	b += 2
+
+	b += 4 // padding
+
+	b += VisualInfoListBytes(buf[b:], v.Visuals)
+
+	return buf
+}
+
+// Write struct list DepthInfo
+func DepthInfoListBytes(buf []byte, list []DepthInfo) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// Struct list size DepthInfo
+func DepthInfoListSize(list []DepthInfo) int {
+	size := 0
+	for _, item := range list {
+		size += (8 + pad((int(item.VisualsLen) * 24)))
+	}
+	return size
+}
+
+// 'ScreenInfo' struct definition
+// Size: (40 + DepthInfoListSize(AllowedDepths))
+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          Visualid
+	BackingStores       byte
+	SaveUnders          bool
+	RootDepth           byte
+	AllowedDepthsLen    byte
+	AllowedDepths       []DepthInfo // size: DepthInfoListSize(AllowedDepths)
+}
+
+// Struct read ScreenInfo
+func ReadScreenInfo(buf []byte, v *ScreenInfo) int {
+	b := 0
+
+	v.Root = Id(Get32(buf[b:]))
+	b += 4
+
+	v.DefaultColormap = Id(Get32(buf[b:]))
+	b += 4
+
+	v.WhitePixel = Get32(buf[b:])
+	b += 4
+
+	v.BlackPixel = Get32(buf[b:])
+	b += 4
+
+	v.CurrentInputMasks = Get32(buf[b:])
+	b += 4
+
+	v.WidthInPixels = Get16(buf[b:])
+	b += 2
+
+	v.HeightInPixels = Get16(buf[b:])
+	b += 2
+
+	v.WidthInMillimeters = Get16(buf[b:])
+	b += 2
+
+	v.HeightInMillimeters = Get16(buf[b:])
+	b += 2
+
+	v.MinInstalledMaps = Get16(buf[b:])
+	b += 2
+
+	v.MaxInstalledMaps = Get16(buf[b:])
+	b += 2
+
+	v.RootVisual = Visualid(Get32(buf[b:]))
+	b += 4
+
+	v.BackingStores = buf[b]
+	b += 1
+
+	if buf[b] == 1 {
+		v.SaveUnders = true
+	} else {
+		v.SaveUnders = false
+	}
+	b += 1
+
+	v.RootDepth = buf[b]
+	b += 1
+
+	v.AllowedDepthsLen = buf[b]
+	b += 1
+
+	v.AllowedDepths = make([]DepthInfo, v.AllowedDepthsLen)
+	b += ReadDepthInfoList(buf[b:], v.AllowedDepths)
+
+	return b
+}
+
+// Struct list read ScreenInfo
+func ReadScreenInfoList(buf []byte, dest []ScreenInfo) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = ScreenInfo{}
+		b += ReadScreenInfo(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write ScreenInfo
+func (v ScreenInfo) Bytes() []byte {
+	buf := make([]byte, (40 + DepthInfoListSize(v.AllowedDepths)))
+	b := 0
+
+	Put32(buf[b:], uint32(v.Root))
+	b += 4
+
+	Put32(buf[b:], uint32(v.DefaultColormap))
+	b += 4
+
+	Put32(buf[b:], v.WhitePixel)
+	b += 4
+
+	Put32(buf[b:], v.BlackPixel)
+	b += 4
+
+	Put32(buf[b:], v.CurrentInputMasks)
+	b += 4
+
+	Put16(buf[b:], v.WidthInPixels)
+	b += 2
+
+	Put16(buf[b:], v.HeightInPixels)
+	b += 2
+
+	Put16(buf[b:], v.WidthInMillimeters)
+	b += 2
+
+	Put16(buf[b:], v.HeightInMillimeters)
+	b += 2
+
+	Put16(buf[b:], v.MinInstalledMaps)
+	b += 2
+
+	Put16(buf[b:], v.MaxInstalledMaps)
+	b += 2
+
+	Put32(buf[b:], uint32(v.RootVisual))
+	b += 4
+
+	buf[b] = v.BackingStores
+	b += 1
+
+	if v.SaveUnders {
+		buf[b] = 1
+	} else {
+		buf[b] = 0
+	}
+	b += 1
+
+	buf[b] = v.RootDepth
+	b += 1
+
+	buf[b] = v.AllowedDepthsLen
+	b += 1
+
+	b += DepthInfoListBytes(buf[b:], v.AllowedDepths)
+
+	return buf
+}
+
+// Write struct list ScreenInfo
+func ScreenInfoListBytes(buf []byte, list []ScreenInfo) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// Struct list size ScreenInfo
+func ScreenInfoListSize(list []ScreenInfo) int {
+	size := 0
+	for _, item := range list {
+		size += (40 + DepthInfoListSize(item.AllowedDepths))
+	}
+	return size
+}
+
+// 'SetupRequest' struct definition
+// Size: ((12 + pad((int(AuthorizationProtocolNameLen) * 1))) + pad((int(AuthorizationProtocolDataLen) * 1)))
+type SetupRequest struct {
+	ByteOrder byte
+	// padding: 1 bytes
+	ProtocolMajorVersion         uint16
+	ProtocolMinorVersion         uint16
+	AuthorizationProtocolNameLen uint16
+	AuthorizationProtocolDataLen uint16
+	// padding: 2 bytes
+	AuthorizationProtocolName string // size: pad((int(AuthorizationProtocolNameLen) * 1))
+	AuthorizationProtocolData string // size: pad((int(AuthorizationProtocolDataLen) * 1))
+}
+
+// Struct read SetupRequest
+func ReadSetupRequest(buf []byte, v *SetupRequest) int {
+	b := 0
+
+	v.ByteOrder = buf[b]
+	b += 1
+
+	b += 1 // padding
+
+	v.ProtocolMajorVersion = Get16(buf[b:])
+	b += 2
+
+	v.ProtocolMinorVersion = Get16(buf[b:])
+	b += 2
+
+	v.AuthorizationProtocolNameLen = Get16(buf[b:])
+	b += 2
+
+	v.AuthorizationProtocolDataLen = Get16(buf[b:])
+	b += 2
+
+	b += 2 // padding
+
+	{
+		byteString := make([]byte, v.AuthorizationProtocolNameLen)
+		copy(byteString[:v.AuthorizationProtocolNameLen], buf[b:])
+		v.AuthorizationProtocolName = string(byteString)
+		b += pad(int(v.AuthorizationProtocolNameLen))
+	}
+
+	{
+		byteString := make([]byte, v.AuthorizationProtocolDataLen)
+		copy(byteString[:v.AuthorizationProtocolDataLen], buf[b:])
+		v.AuthorizationProtocolData = string(byteString)
+		b += pad(int(v.AuthorizationProtocolDataLen))
+	}
+
+	return b
+}
+
+// Struct list read SetupRequest
+func ReadSetupRequestList(buf []byte, dest []SetupRequest) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = SetupRequest{}
+		b += ReadSetupRequest(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write SetupRequest
+func (v SetupRequest) Bytes() []byte {
+	buf := make([]byte, ((12 + pad((int(v.AuthorizationProtocolNameLen) * 1))) + pad((int(v.AuthorizationProtocolDataLen) * 1))))
+	b := 0
+
+	buf[b] = v.ByteOrder
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], v.ProtocolMajorVersion)
+	b += 2
+
+	Put16(buf[b:], v.ProtocolMinorVersion)
+	b += 2
+
+	Put16(buf[b:], v.AuthorizationProtocolNameLen)
+	b += 2
+
+	Put16(buf[b:], v.AuthorizationProtocolDataLen)
+	b += 2
+
+	b += 2 // padding
+
+	copy(buf[b:], v.AuthorizationProtocolName[:v.AuthorizationProtocolNameLen])
+	b += pad(int(v.AuthorizationProtocolNameLen))
+
+	copy(buf[b:], v.AuthorizationProtocolData[:v.AuthorizationProtocolDataLen])
+	b += pad(int(v.AuthorizationProtocolDataLen))
+
+	return buf
+}
+
+// Write struct list SetupRequest
+func SetupRequestListBytes(buf []byte, list []SetupRequest) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// Struct list size SetupRequest
+func SetupRequestListSize(list []SetupRequest) int {
+	size := 0
+	for _, item := range list {
+		size += ((12 + pad((int(item.AuthorizationProtocolNameLen) * 1))) + pad((int(item.AuthorizationProtocolDataLen) * 1)))
+	}
+	return size
+}
+
+// 'SetupFailed' struct definition
+// Size: (8 + pad((int(ReasonLen) * 1)))
+type SetupFailed struct {
+	Status               byte
+	ReasonLen            byte
+	ProtocolMajorVersion uint16
+	ProtocolMinorVersion uint16
+	Length               uint16
+	Reason               string // size: pad((int(ReasonLen) * 1))
+}
+
+// Struct read SetupFailed
+func ReadSetupFailed(buf []byte, v *SetupFailed) int {
+	b := 0
+
+	v.Status = buf[b]
+	b += 1
+
+	v.ReasonLen = buf[b]
+	b += 1
+
+	v.ProtocolMajorVersion = Get16(buf[b:])
+	b += 2
+
+	v.ProtocolMinorVersion = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get16(buf[b:])
+	b += 2
+
+	{
+		byteString := make([]byte, v.ReasonLen)
+		copy(byteString[:v.ReasonLen], buf[b:])
+		v.Reason = string(byteString)
+		b += pad(int(v.ReasonLen))
+	}
+
+	return b
+}
+
+// Struct list read SetupFailed
+func ReadSetupFailedList(buf []byte, dest []SetupFailed) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = SetupFailed{}
+		b += ReadSetupFailed(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write SetupFailed
+func (v SetupFailed) Bytes() []byte {
+	buf := make([]byte, (8 + pad((int(v.ReasonLen) * 1))))
+	b := 0
+
+	buf[b] = v.Status
+	b += 1
+
+	buf[b] = v.ReasonLen
+	b += 1
+
+	Put16(buf[b:], v.ProtocolMajorVersion)
+	b += 2
+
+	Put16(buf[b:], v.ProtocolMinorVersion)
+	b += 2
+
+	Put16(buf[b:], v.Length)
+	b += 2
+
+	copy(buf[b:], v.Reason[:v.ReasonLen])
+	b += pad(int(v.ReasonLen))
+
+	return buf
+}
+
+// Write struct list SetupFailed
+func SetupFailedListBytes(buf []byte, list []SetupFailed) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// Struct list size SetupFailed
+func SetupFailedListSize(list []SetupFailed) int {
+	size := 0
+	for _, item := range list {
+		size += (8 + pad((int(item.ReasonLen) * 1)))
+	}
+	return size
+}
+
+// 'SetupAuthenticate' struct definition
+// Size: (8 + pad(((int(Length) * 4) * 1)))
+type SetupAuthenticate struct {
+	Status byte
+	// padding: 5 bytes
+	Length uint16
+	Reason string // size: pad(((int(Length) * 4) * 1))
+}
+
+// Struct read SetupAuthenticate
+func ReadSetupAuthenticate(buf []byte, v *SetupAuthenticate) int {
+	b := 0
+
+	v.Status = buf[b]
+	b += 1
+
+	b += 5 // padding
+
+	v.Length = Get16(buf[b:])
+	b += 2
+
+	{
+		byteString := make([]byte, (int(v.Length) * 4))
+		copy(byteString[:(int(v.Length)*4)], buf[b:])
+		v.Reason = string(byteString)
+		b += pad(int((int(v.Length) * 4)))
+	}
+
+	return b
+}
+
+// Struct list read SetupAuthenticate
+func ReadSetupAuthenticateList(buf []byte, dest []SetupAuthenticate) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = SetupAuthenticate{}
+		b += ReadSetupAuthenticate(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write SetupAuthenticate
+func (v SetupAuthenticate) Bytes() []byte {
+	buf := make([]byte, (8 + pad(((int(v.Length) * 4) * 1))))
+	b := 0
+
+	buf[b] = v.Status
+	b += 1
+
+	b += 5 // padding
+
+	Put16(buf[b:], v.Length)
+	b += 2
+
+	copy(buf[b:], v.Reason[:(int(v.Length)*4)])
+	b += pad(int((int(v.Length) * 4)))
+
+	return buf
+}
+
+// Write struct list SetupAuthenticate
+func SetupAuthenticateListBytes(buf []byte, list []SetupAuthenticate) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// Struct list size SetupAuthenticate
+func SetupAuthenticateListSize(list []SetupAuthenticate) int {
+	size := 0
+	for _, item := range list {
+		size += (8 + pad(((int(item.Length) * 4) * 1)))
+	}
+	return size
+}
+
+// 'SetupInfo' struct definition
+// Size: (((40 + pad((int(VendorLen) * 1))) + pad((int(PixmapFormatsLen) * 8))) + ScreenInfoListSize(Roots))
+type SetupInfo struct {
+	Status byte
+	// padding: 1 bytes
+	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               Keycode
+	MaxKeycode               Keycode
+	// padding: 4 bytes
+	Vendor        string       // size: pad((int(VendorLen) * 1))
+	PixmapFormats []Format     // size: pad((int(PixmapFormatsLen) * 8))
+	Roots         []ScreenInfo // size: ScreenInfoListSize(Roots)
+}
+
+// Struct read SetupInfo
+func ReadSetupInfo(buf []byte, v *SetupInfo) int {
+	b := 0
+
+	v.Status = buf[b]
+	b += 1
+
+	b += 1 // padding
+
+	v.ProtocolMajorVersion = Get16(buf[b:])
+	b += 2
+
+	v.ProtocolMinorVersion = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get16(buf[b:])
+	b += 2
+
+	v.ReleaseNumber = Get32(buf[b:])
+	b += 4
+
+	v.ResourceIdBase = Get32(buf[b:])
+	b += 4
+
+	v.ResourceIdMask = Get32(buf[b:])
+	b += 4
+
+	v.MotionBufferSize = Get32(buf[b:])
+	b += 4
+
+	v.VendorLen = Get16(buf[b:])
+	b += 2
+
+	v.MaximumRequestLength = Get16(buf[b:])
+	b += 2
+
+	v.RootsLen = buf[b]
+	b += 1
+
+	v.PixmapFormatsLen = buf[b]
+	b += 1
+
+	v.ImageByteOrder = buf[b]
+	b += 1
+
+	v.BitmapFormatBitOrder = buf[b]
+	b += 1
+
+	v.BitmapFormatScanlineUnit = buf[b]
+	b += 1
+
+	v.BitmapFormatScanlinePad = buf[b]
+	b += 1
+
+	v.MinKeycode = Keycode(buf[b])
+	b += 1
+
+	v.MaxKeycode = Keycode(buf[b])
+	b += 1
+
+	b += 4 // padding
+
+	{
+		byteString := make([]byte, v.VendorLen)
+		copy(byteString[:v.VendorLen], buf[b:])
+		v.Vendor = string(byteString)
+		b += pad(int(v.VendorLen))
+	}
+
+	v.PixmapFormats = make([]Format, v.PixmapFormatsLen)
+	b += ReadFormatList(buf[b:], v.PixmapFormats)
+
+	v.Roots = make([]ScreenInfo, v.RootsLen)
+	b += ReadScreenInfoList(buf[b:], v.Roots)
+
+	return b
+}
+
+// Struct list read SetupInfo
+func ReadSetupInfoList(buf []byte, dest []SetupInfo) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = SetupInfo{}
+		b += ReadSetupInfo(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write SetupInfo
+func (v SetupInfo) Bytes() []byte {
+	buf := make([]byte, (((40 + pad((int(v.VendorLen) * 1))) + pad((int(v.PixmapFormatsLen) * 8))) + ScreenInfoListSize(v.Roots)))
+	b := 0
+
+	buf[b] = v.Status
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], v.ProtocolMajorVersion)
+	b += 2
+
+	Put16(buf[b:], v.ProtocolMinorVersion)
+	b += 2
+
+	Put16(buf[b:], v.Length)
+	b += 2
+
+	Put32(buf[b:], v.ReleaseNumber)
+	b += 4
+
+	Put32(buf[b:], v.ResourceIdBase)
+	b += 4
+
+	Put32(buf[b:], v.ResourceIdMask)
+	b += 4
+
+	Put32(buf[b:], v.MotionBufferSize)
+	b += 4
+
+	Put16(buf[b:], v.VendorLen)
+	b += 2
+
+	Put16(buf[b:], v.MaximumRequestLength)
+	b += 2
+
+	buf[b] = v.RootsLen
+	b += 1
+
+	buf[b] = v.PixmapFormatsLen
+	b += 1
+
+	buf[b] = v.ImageByteOrder
+	b += 1
+
+	buf[b] = v.BitmapFormatBitOrder
+	b += 1
+
+	buf[b] = v.BitmapFormatScanlineUnit
+	b += 1
+
+	buf[b] = v.BitmapFormatScanlinePad
+	b += 1
+
+	buf[b] = byte(v.MinKeycode)
+	b += 1
+
+	buf[b] = byte(v.MaxKeycode)
+	b += 1
+
+	b += 4 // padding
+
+	copy(buf[b:], v.Vendor[:v.VendorLen])
+	b += pad(int(v.VendorLen))
+
+	b += FormatListBytes(buf[b:], v.PixmapFormats)
+
+	b += ScreenInfoListBytes(buf[b:], v.Roots)
+
+	return buf
+}
+
+// Write struct list SetupInfo
+func SetupInfoListBytes(buf []byte, list []SetupInfo) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// Struct list size SetupInfo
+func SetupInfoListSize(list []SetupInfo) int {
+	size := 0
+	for _, item := range list {
+		size += (((40 + pad((int(item.VendorLen) * 1))) + pad((int(item.PixmapFormatsLen) * 8))) + ScreenInfoListSize(item.Roots))
+	}
+	return size
+}
+
+// 'Timecoord' struct definition
+// Size: 8
+type Timecoord struct {
+	Time Timestamp
+	X    int16
+	Y    int16
+}
+
+// Struct read Timecoord
+func ReadTimecoord(buf []byte, v *Timecoord) int {
+	b := 0
+
+	v.Time = Timestamp(Get32(buf[b:]))
+	b += 4
+
+	v.X = int16(Get16(buf[b:]))
+	b += 2
+
+	v.Y = int16(Get16(buf[b:]))
+	b += 2
+
+	return b
+}
+
+// Struct list read Timecoord
+func ReadTimecoordList(buf []byte, dest []Timecoord) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = Timecoord{}
+		b += ReadTimecoord(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write Timecoord
+func (v Timecoord) Bytes() []byte {
+	buf := make([]byte, 8)
+	b := 0
+
+	Put32(buf[b:], uint32(v.Time))
+	b += 4
+
+	Put16(buf[b:], uint16(v.X))
+	b += 2
+
+	Put16(buf[b:], uint16(v.Y))
+	b += 2
+
+	return buf
+}
+
+// Write struct list Timecoord
+func TimecoordListBytes(buf []byte, list []Timecoord) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// 'Fontprop' struct definition
+// Size: 8
+type Fontprop struct {
+	Name  Id
+	Value uint32
+}
+
+// Struct read Fontprop
+func ReadFontprop(buf []byte, v *Fontprop) int {
+	b := 0
+
+	v.Name = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Value = Get32(buf[b:])
+	b += 4
+
+	return b
+}
+
+// Struct list read Fontprop
+func ReadFontpropList(buf []byte, dest []Fontprop) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = Fontprop{}
+		b += ReadFontprop(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write Fontprop
+func (v Fontprop) Bytes() []byte {
+	buf := make([]byte, 8)
+	b := 0
+
+	Put32(buf[b:], uint32(v.Name))
+	b += 4
+
+	Put32(buf[b:], v.Value)
+	b += 4
+
+	return buf
+}
+
+// Write struct list Fontprop
+func FontpropListBytes(buf []byte, list []Fontprop) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// 'Charinfo' struct definition
+// Size: 12
+type Charinfo struct {
+	LeftSideBearing  int16
+	RightSideBearing int16
+	CharacterWidth   int16
+	Ascent           int16
+	Descent          int16
+	Attributes       uint16
+}
+
+// Struct read Charinfo
+func ReadCharinfo(buf []byte, v *Charinfo) int {
+	b := 0
+
+	v.LeftSideBearing = int16(Get16(buf[b:]))
+	b += 2
+
+	v.RightSideBearing = int16(Get16(buf[b:]))
+	b += 2
+
+	v.CharacterWidth = int16(Get16(buf[b:]))
+	b += 2
+
+	v.Ascent = int16(Get16(buf[b:]))
+	b += 2
+
+	v.Descent = int16(Get16(buf[b:]))
+	b += 2
+
+	v.Attributes = Get16(buf[b:])
+	b += 2
+
+	return b
+}
+
+// Struct list read Charinfo
+func ReadCharinfoList(buf []byte, dest []Charinfo) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = Charinfo{}
+		b += ReadCharinfo(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write Charinfo
+func (v Charinfo) Bytes() []byte {
+	buf := make([]byte, 12)
+	b := 0
+
+	Put16(buf[b:], uint16(v.LeftSideBearing))
+	b += 2
+
+	Put16(buf[b:], uint16(v.RightSideBearing))
+	b += 2
+
+	Put16(buf[b:], uint16(v.CharacterWidth))
+	b += 2
+
+	Put16(buf[b:], uint16(v.Ascent))
+	b += 2
+
+	Put16(buf[b:], uint16(v.Descent))
+	b += 2
+
+	Put16(buf[b:], v.Attributes)
+	b += 2
+
+	return buf
+}
+
+// Write struct list Charinfo
+func CharinfoListBytes(buf []byte, list []Charinfo) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// 'Str' struct definition
+// Size: (1 + pad((int(NameLen) * 1)))
+type Str struct {
+	NameLen byte
+	Name    string // size: pad((int(NameLen) * 1))
+}
+
+// Struct read Str
+func ReadStr(buf []byte, v *Str) int {
+	b := 0
+
+	v.NameLen = buf[b]
+	b += 1
+
+	{
+		byteString := make([]byte, v.NameLen)
+		copy(byteString[:v.NameLen], buf[b:])
+		v.Name = string(byteString)
+		b += pad(int(v.NameLen))
+	}
+
+	return b
+}
+
+// Struct list read Str
+func ReadStrList(buf []byte, dest []Str) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = Str{}
+		b += ReadStr(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write Str
+func (v Str) Bytes() []byte {
+	buf := make([]byte, (1 + pad((int(v.NameLen) * 1))))
+	b := 0
+
+	buf[b] = v.NameLen
+	b += 1
+
+	copy(buf[b:], v.Name[:v.NameLen])
+	b += pad(int(v.NameLen))
+
+	return buf
+}
+
+// Write struct list Str
+func StrListBytes(buf []byte, list []Str) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// Struct list size Str
+func StrListSize(list []Str) int {
+	size := 0
+	for _, item := range list {
+		size += (1 + pad((int(item.NameLen) * 1)))
+	}
+	return size
+}
+
+// 'Segment' struct definition
+// Size: 8
+type Segment struct {
+	X1 int16
+	Y1 int16
+	X2 int16
+	Y2 int16
+}
+
+// Struct read Segment
+func ReadSegment(buf []byte, v *Segment) int {
+	b := 0
+
+	v.X1 = int16(Get16(buf[b:]))
+	b += 2
+
+	v.Y1 = int16(Get16(buf[b:]))
+	b += 2
+
+	v.X2 = int16(Get16(buf[b:]))
+	b += 2
+
+	v.Y2 = int16(Get16(buf[b:]))
+	b += 2
+
+	return b
+}
+
+// Struct list read Segment
+func ReadSegmentList(buf []byte, dest []Segment) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = Segment{}
+		b += ReadSegment(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write Segment
+func (v Segment) Bytes() []byte {
+	buf := make([]byte, 8)
+	b := 0
+
+	Put16(buf[b:], uint16(v.X1))
+	b += 2
+
+	Put16(buf[b:], uint16(v.Y1))
+	b += 2
+
+	Put16(buf[b:], uint16(v.X2))
+	b += 2
+
+	Put16(buf[b:], uint16(v.Y2))
+	b += 2
+
+	return buf
+}
+
+// Write struct list Segment
+func SegmentListBytes(buf []byte, list []Segment) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// 'Coloritem' struct definition
+// Size: 12
+type Coloritem struct {
+	Pixel uint32
+	Red   uint16
+	Green uint16
+	Blue  uint16
+	Flags byte
+	// padding: 1 bytes
+}
+
+// Struct read Coloritem
+func ReadColoritem(buf []byte, v *Coloritem) int {
+	b := 0
+
+	v.Pixel = Get32(buf[b:])
+	b += 4
+
+	v.Red = Get16(buf[b:])
+	b += 2
+
+	v.Green = Get16(buf[b:])
+	b += 2
+
+	v.Blue = Get16(buf[b:])
+	b += 2
+
+	v.Flags = buf[b]
+	b += 1
+
+	b += 1 // padding
+
+	return b
+}
+
+// Struct list read Coloritem
+func ReadColoritemList(buf []byte, dest []Coloritem) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = Coloritem{}
+		b += ReadColoritem(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write Coloritem
+func (v Coloritem) Bytes() []byte {
+	buf := make([]byte, 12)
+	b := 0
+
+	Put32(buf[b:], v.Pixel)
+	b += 4
+
+	Put16(buf[b:], v.Red)
+	b += 2
+
+	Put16(buf[b:], v.Green)
+	b += 2
+
+	Put16(buf[b:], v.Blue)
+	b += 2
+
+	buf[b] = v.Flags
+	b += 1
+
+	b += 1 // padding
+
+	return buf
+}
+
+// Write struct list Coloritem
+func ColoritemListBytes(buf []byte, list []Coloritem) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// 'Rgb' struct definition
+// Size: 8
+type Rgb struct {
+	Red   uint16
+	Green uint16
+	Blue  uint16
+	// padding: 2 bytes
+}
+
+// Struct read Rgb
+func ReadRgb(buf []byte, v *Rgb) int {
+	b := 0
+
+	v.Red = Get16(buf[b:])
+	b += 2
+
+	v.Green = Get16(buf[b:])
+	b += 2
+
+	v.Blue = Get16(buf[b:])
+	b += 2
+
+	b += 2 // padding
+
+	return b
+}
+
+// Struct list read Rgb
+func ReadRgbList(buf []byte, dest []Rgb) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = Rgb{}
+		b += ReadRgb(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write Rgb
+func (v Rgb) Bytes() []byte {
+	buf := make([]byte, 8)
+	b := 0
+
+	Put16(buf[b:], v.Red)
+	b += 2
+
+	Put16(buf[b:], v.Green)
+	b += 2
+
+	Put16(buf[b:], v.Blue)
+	b += 2
+
+	b += 2 // padding
+
+	return buf
+}
+
+// Write struct list Rgb
+func RgbListBytes(buf []byte, list []Rgb) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// 'Host' struct definition
+// Size: (4 + pad((int(AddressLen) * 1)))
+type Host struct {
+	Family byte
+	// padding: 1 bytes
+	AddressLen uint16
+	Address    []byte // size: pad((int(AddressLen) * 1))
+}
+
+// Struct read Host
+func ReadHost(buf []byte, v *Host) int {
+	b := 0
+
+	v.Family = buf[b]
+	b += 1
+
+	b += 1 // padding
+
+	v.AddressLen = Get16(buf[b:])
+	b += 2
+
+	v.Address = make([]byte, v.AddressLen)
+	copy(v.Address[:v.AddressLen], buf[b:])
+	b += pad(int(v.AddressLen))
+
+	return b
+}
+
+// Struct list read Host
+func ReadHostList(buf []byte, dest []Host) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = Host{}
+		b += ReadHost(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write Host
+func (v Host) Bytes() []byte {
+	buf := make([]byte, (4 + pad((int(v.AddressLen) * 1))))
+	b := 0
+
+	buf[b] = v.Family
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], v.AddressLen)
+	b += 2
+
+	copy(buf[b:], v.Address[:v.AddressLen])
+	b += pad(int(v.AddressLen))
+
+	return buf
+}
+
+// Write struct list Host
+func HostListBytes(buf []byte, list []Host) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// Struct list size Host
+func HostListSize(list []Host) int {
+	size := 0
+	for _, item := range list {
+		size += (4 + pad((int(item.AddressLen) * 1)))
+	}
+	return size
+}
+
+// Union definition ClientMessageDataUnion
+// Note that to *create* a Union, you should *never* create
+// this struct directly (unless you know what you're doing).
+// Instead use one of the following constructors for 'ClientMessageDataUnion':
+//     NewClientMessageDataUnionData8(Data8 []byte) ClientMessageDataUnion
+//     NewClientMessageDataUnionData16(Data16 []uint16) ClientMessageDataUnion
+//     NewClientMessageDataUnionData32(Data32 []uint32) ClientMessageDataUnion
+type ClientMessageDataUnion struct {
+	Data8  []byte   // size: pad(20)
+	Data16 []uint16 // size: pad(20)
+	Data32 []uint32 // size: pad(20)
+}
+
+// Union constructor for ClientMessageDataUnion for field Data8.
+func NewClientMessageDataUnionData8(Data8 []byte) ClientMessageDataUnion {
+	var b int
+	buf := make([]byte, pad(20))
+
+	copy(buf[b:], Data8[:20])
+	b += pad(int(20))
+
+	// Create the Union type
+	v := ClientMessageDataUnion{}
+
+	// Now copy buf into all fields
+
+	b = 0 // always read the same bytes
+	v.Data8 = make([]byte, 20)
+	copy(v.Data8[:20], buf[b:])
+	b += pad(int(20))
+
+	b = 0 // always read the same bytes
+	v.Data16 = make([]uint16, 10)
+	for i := 0; i < int(10); i++ {
+		v.Data16[i] = Get16(buf[b:])
+		b += 2
+	}
+	b = pad(b)
+
+	b = 0 // always read the same bytes
+	v.Data32 = make([]uint32, 5)
+	for i := 0; i < int(5); i++ {
+		v.Data32[i] = Get32(buf[b:])
+		b += 4
+	}
+	b = pad(b)
+
+	return v
+}
+
+// Union constructor for ClientMessageDataUnion for field Data16.
+func NewClientMessageDataUnionData16(Data16 []uint16) ClientMessageDataUnion {
+	var b int
+	buf := make([]byte, pad(20))
+
+	for i := 0; i < int(10); i++ {
+		Put16(buf[b:], Data16[i])
+		b += 2
+	}
+	b = pad(b)
+
+	// Create the Union type
+	v := ClientMessageDataUnion{}
+
+	// Now copy buf into all fields
+
+	b = 0 // always read the same bytes
+	v.Data8 = make([]byte, 20)
+	copy(v.Data8[:20], buf[b:])
+	b += pad(int(20))
+
+	b = 0 // always read the same bytes
+	v.Data16 = make([]uint16, 10)
+	for i := 0; i < int(10); i++ {
+		v.Data16[i] = Get16(buf[b:])
+		b += 2
+	}
+	b = pad(b)
+
+	b = 0 // always read the same bytes
+	v.Data32 = make([]uint32, 5)
+	for i := 0; i < int(5); i++ {
+		v.Data32[i] = Get32(buf[b:])
+		b += 4
+	}
+	b = pad(b)
+
+	return v
+}
+
+// Union constructor for ClientMessageDataUnion for field Data32.
+func NewClientMessageDataUnionData32(Data32 []uint32) ClientMessageDataUnion {
+	var b int
+	buf := make([]byte, pad(20))
+
+	for i := 0; i < int(5); i++ {
+		Put32(buf[b:], Data32[i])
+		b += 4
+	}
+	b = pad(b)
+
+	// Create the Union type
+	v := ClientMessageDataUnion{}
+
+	// Now copy buf into all fields
+
+	b = 0 // always read the same bytes
+	v.Data8 = make([]byte, 20)
+	copy(v.Data8[:20], buf[b:])
+	b += pad(int(20))
+
+	b = 0 // always read the same bytes
+	v.Data16 = make([]uint16, 10)
+	for i := 0; i < int(10); i++ {
+		v.Data16[i] = Get16(buf[b:])
+		b += 2
+	}
+	b = pad(b)
+
+	b = 0 // always read the same bytes
+	v.Data32 = make([]uint32, 5)
+	for i := 0; i < int(5); i++ {
+		v.Data32[i] = Get32(buf[b:])
+		b += 4
+	}
+	b = pad(b)
+
+	return v
+}
+
+// Union read ClientMessageDataUnion
+func ReadClientMessageDataUnion(buf []byte, v *ClientMessageDataUnion) int {
+	var b int
+
+	b = 0 // re-read the same bytes
+	v.Data8 = make([]byte, 20)
+	copy(v.Data8[:20], buf[b:])
+	b += pad(int(20))
+
+	b = 0 // re-read the same bytes
+	v.Data16 = make([]uint16, 10)
+	for i := 0; i < int(10); i++ {
+		v.Data16[i] = Get16(buf[b:])
+		b += 2
+	}
+	b = pad(b)
+
+	b = 0 // re-read the same bytes
+	v.Data32 = make([]uint32, 5)
+	for i := 0; i < int(5); i++ {
+		v.Data32[i] = Get32(buf[b:])
+		b += 4
+	}
+	b = pad(b)
+
+	return pad(20)
+}
+
+// Union list read ClientMessageDataUnion
+func ReadClientMessageDataUnionList(buf []byte, dest []ClientMessageDataUnion) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = ClientMessageDataUnion{}
+		b += ReadClientMessageDataUnion(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Union write ClientMessageDataUnion
+// Each field in a union must contain the same data.
+// So simply pick the first field and write that to the wire.
+func (v ClientMessageDataUnion) Bytes() []byte {
+	buf := make([]byte, pad(20))
+	b := 0
+
+	copy(buf[b:], v.Data8[:20])
+	b += pad(int(20))
+	return buf
+}
+
+// Union list write ClientMessageDataUnion
+func ClientMessageDataUnionListBytes(buf []byte, list []ClientMessageDataUnion) int {
+	b := 0
+	var unionBytes []byte
+	for _, item := range list {
+		unionBytes = item.Bytes()
+		copy(buf[b:], unionBytes)
+		b += pad(len(unionBytes))
+	}
+	return b
+}
+
+// Event definition KeyPress (2)
+// Size: 32
+
+const KeyPress = 2
+
+type KeyPressEvent struct {
+	Sequence   uint16
+	Detail     Keycode
+	Time       Timestamp
+	Root       Id
+	Event      Id
+	Child      Id
+	RootX      int16
+	RootY      int16
+	EventX     int16
+	EventY     int16
+	State      uint16
+	SameScreen bool
+	// padding: 1 bytes
+}
+
+// Event read KeyPress
+func NewKeyPressEvent(buf []byte) Event {
+	v := KeyPressEvent{}
+	b := 1 // don't read event number
+
+	v.Detail = Keycode(buf[b])
+	b += 1
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Time = Timestamp(Get32(buf[b:]))
+	b += 4
+
+	v.Root = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Event = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Child = Id(Get32(buf[b:]))
+	b += 4
+
+	v.RootX = int16(Get16(buf[b:]))
+	b += 2
+
+	v.RootY = int16(Get16(buf[b:]))
+	b += 2
+
+	v.EventX = int16(Get16(buf[b:]))
+	b += 2
+
+	v.EventY = int16(Get16(buf[b:]))
+	b += 2
+
+	v.State = Get16(buf[b:])
+	b += 2
+
+	if buf[b] == 1 {
+		v.SameScreen = true
+	} else {
+		v.SameScreen = false
+	}
+	b += 1
+
+	b += 1 // padding
+
+	return v
+}
+
+// Event write KeyPress
+func (v KeyPressEvent) Bytes() []byte {
+	buf := make([]byte, 32)
+	b := 0
+
+	// write event number
+	buf[b] = 2
+	b += 1
+
+	buf[b] = byte(v.Detail)
+	b += 1
+
+	b += 2 // skip sequence number
+
+	Put32(buf[b:], uint32(v.Time))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Root))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Event))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Child))
+	b += 4
+
+	Put16(buf[b:], uint16(v.RootX))
+	b += 2
+
+	Put16(buf[b:], uint16(v.RootY))
+	b += 2
+
+	Put16(buf[b:], uint16(v.EventX))
+	b += 2
+
+	Put16(buf[b:], uint16(v.EventY))
+	b += 2
+
+	Put16(buf[b:], v.State)
+	b += 2
+
+	if v.SameScreen {
+		buf[b] = 1
+	} else {
+		buf[b] = 0
+	}
+	b += 1
+
+	b += 1 // padding
+
+	return buf
+}
+
+func (v KeyPressEvent) ImplementsEvent() {}
+
+func init() {
+	newEventFuncs[2] = NewKeyPressEvent
+}
+
+// Event definition ButtonPress (4)
+// Size: 32
+
+const ButtonPress = 4
+
+type ButtonPressEvent struct {
+	Sequence   uint16
+	Detail     Button
+	Time       Timestamp
+	Root       Id
+	Event      Id
+	Child      Id
+	RootX      int16
+	RootY      int16
+	EventX     int16
+	EventY     int16
+	State      uint16
+	SameScreen bool
+	// padding: 1 bytes
+}
+
+// Event read ButtonPress
+func NewButtonPressEvent(buf []byte) Event {
+	v := ButtonPressEvent{}
+	b := 1 // don't read event number
+
+	v.Detail = Button(buf[b])
+	b += 1
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Time = Timestamp(Get32(buf[b:]))
+	b += 4
+
+	v.Root = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Event = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Child = Id(Get32(buf[b:]))
+	b += 4
+
+	v.RootX = int16(Get16(buf[b:]))
+	b += 2
+
+	v.RootY = int16(Get16(buf[b:]))
+	b += 2
+
+	v.EventX = int16(Get16(buf[b:]))
+	b += 2
+
+	v.EventY = int16(Get16(buf[b:]))
+	b += 2
+
+	v.State = Get16(buf[b:])
+	b += 2
+
+	if buf[b] == 1 {
+		v.SameScreen = true
+	} else {
+		v.SameScreen = false
+	}
+	b += 1
+
+	b += 1 // padding
+
+	return v
+}
+
+// Event write ButtonPress
+func (v ButtonPressEvent) Bytes() []byte {
+	buf := make([]byte, 32)
+	b := 0
+
+	// write event number
+	buf[b] = 4
+	b += 1
+
+	buf[b] = byte(v.Detail)
+	b += 1
+
+	b += 2 // skip sequence number
+
+	Put32(buf[b:], uint32(v.Time))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Root))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Event))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Child))
+	b += 4
+
+	Put16(buf[b:], uint16(v.RootX))
+	b += 2
+
+	Put16(buf[b:], uint16(v.RootY))
+	b += 2
+
+	Put16(buf[b:], uint16(v.EventX))
+	b += 2
+
+	Put16(buf[b:], uint16(v.EventY))
+	b += 2
+
+	Put16(buf[b:], v.State)
+	b += 2
+
+	if v.SameScreen {
+		buf[b] = 1
+	} else {
+		buf[b] = 0
+	}
+	b += 1
+
+	b += 1 // padding
+
+	return buf
+}
+
+func (v ButtonPressEvent) ImplementsEvent() {}
+
+func init() {
+	newEventFuncs[4] = NewButtonPressEvent
+}
+
+// Event definition MotionNotify (6)
+// Size: 32
+
+const MotionNotify = 6
+
+type MotionNotifyEvent struct {
+	Sequence   uint16
+	Detail     byte
+	Time       Timestamp
+	Root       Id
+	Event      Id
+	Child      Id
+	RootX      int16
+	RootY      int16
+	EventX     int16
+	EventY     int16
+	State      uint16
+	SameScreen bool
+	// padding: 1 bytes
+}
+
+// Event read MotionNotify
+func NewMotionNotifyEvent(buf []byte) Event {
+	v := MotionNotifyEvent{}
+	b := 1 // don't read event number
+
+	v.Detail = buf[b]
+	b += 1
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Time = Timestamp(Get32(buf[b:]))
+	b += 4
+
+	v.Root = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Event = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Child = Id(Get32(buf[b:]))
+	b += 4
+
+	v.RootX = int16(Get16(buf[b:]))
+	b += 2
+
+	v.RootY = int16(Get16(buf[b:]))
+	b += 2
+
+	v.EventX = int16(Get16(buf[b:]))
+	b += 2
+
+	v.EventY = int16(Get16(buf[b:]))
+	b += 2
+
+	v.State = Get16(buf[b:])
+	b += 2
+
+	if buf[b] == 1 {
+		v.SameScreen = true
+	} else {
+		v.SameScreen = false
+	}
+	b += 1
+
+	b += 1 // padding
+
+	return v
+}
+
+// Event write MotionNotify
+func (v MotionNotifyEvent) Bytes() []byte {
+	buf := make([]byte, 32)
+	b := 0
+
+	// write event number
+	buf[b] = 6
+	b += 1
+
+	buf[b] = v.Detail
+	b += 1
+
+	b += 2 // skip sequence number
+
+	Put32(buf[b:], uint32(v.Time))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Root))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Event))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Child))
+	b += 4
+
+	Put16(buf[b:], uint16(v.RootX))
+	b += 2
+
+	Put16(buf[b:], uint16(v.RootY))
+	b += 2
+
+	Put16(buf[b:], uint16(v.EventX))
+	b += 2
+
+	Put16(buf[b:], uint16(v.EventY))
+	b += 2
+
+	Put16(buf[b:], v.State)
+	b += 2
+
+	if v.SameScreen {
+		buf[b] = 1
+	} else {
+		buf[b] = 0
+	}
+	b += 1
+
+	b += 1 // padding
+
+	return buf
+}
+
+func (v MotionNotifyEvent) ImplementsEvent() {}
+
+func init() {
+	newEventFuncs[6] = NewMotionNotifyEvent
+}
+
+// Event definition EnterNotify (7)
+// Size: 32
+
+const EnterNotify = 7
+
+type EnterNotifyEvent struct {
+	Sequence        uint16
+	Detail          byte
+	Time            Timestamp
+	Root            Id
+	Event           Id
+	Child           Id
+	RootX           int16
+	RootY           int16
+	EventX          int16
+	EventY          int16
+	State           uint16
+	Mode            byte
+	SameScreenFocus byte
+}
+
+// Event read EnterNotify
+func NewEnterNotifyEvent(buf []byte) Event {
+	v := EnterNotifyEvent{}
+	b := 1 // don't read event number
+
+	v.Detail = buf[b]
+	b += 1
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Time = Timestamp(Get32(buf[b:]))
+	b += 4
+
+	v.Root = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Event = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Child = Id(Get32(buf[b:]))
+	b += 4
+
+	v.RootX = int16(Get16(buf[b:]))
+	b += 2
+
+	v.RootY = int16(Get16(buf[b:]))
+	b += 2
+
+	v.EventX = int16(Get16(buf[b:]))
+	b += 2
+
+	v.EventY = int16(Get16(buf[b:]))
+	b += 2
+
+	v.State = Get16(buf[b:])
+	b += 2
+
+	v.Mode = buf[b]
+	b += 1
+
+	v.SameScreenFocus = buf[b]
+	b += 1
+
+	return v
+}
+
+// Event write EnterNotify
+func (v EnterNotifyEvent) Bytes() []byte {
+	buf := make([]byte, 32)
+	b := 0
+
+	// write event number
+	buf[b] = 7
+	b += 1
+
+	buf[b] = v.Detail
+	b += 1
+
+	b += 2 // skip sequence number
+
+	Put32(buf[b:], uint32(v.Time))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Root))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Event))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Child))
+	b += 4
+
+	Put16(buf[b:], uint16(v.RootX))
+	b += 2
+
+	Put16(buf[b:], uint16(v.RootY))
+	b += 2
+
+	Put16(buf[b:], uint16(v.EventX))
+	b += 2
+
+	Put16(buf[b:], uint16(v.EventY))
+	b += 2
+
+	Put16(buf[b:], v.State)
+	b += 2
+
+	buf[b] = v.Mode
+	b += 1
+
+	buf[b] = v.SameScreenFocus
+	b += 1
+
+	return buf
+}
+
+func (v EnterNotifyEvent) ImplementsEvent() {}
+
+func init() {
+	newEventFuncs[7] = NewEnterNotifyEvent
+}
+
+// Event definition FocusIn (9)
+// Size: 32
+
+const FocusIn = 9
+
+type FocusInEvent struct {
+	Sequence uint16
+	Detail   byte
+	Event    Id
+	Mode     byte
+	// padding: 3 bytes
+}
+
+// Event read FocusIn
+func NewFocusInEvent(buf []byte) Event {
+	v := FocusInEvent{}
+	b := 1 // don't read event number
+
+	v.Detail = buf[b]
+	b += 1
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Event = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Mode = buf[b]
+	b += 1
+
+	b += 3 // padding
+
+	return v
+}
+
+// Event write FocusIn
+func (v FocusInEvent) Bytes() []byte {
+	buf := make([]byte, 32)
+	b := 0
+
+	// write event number
+	buf[b] = 9
+	b += 1
+
+	buf[b] = v.Detail
+	b += 1
+
+	b += 2 // skip sequence number
+
+	Put32(buf[b:], uint32(v.Event))
+	b += 4
+
+	buf[b] = v.Mode
+	b += 1
+
+	b += 3 // padding
+
+	return buf
+}
+
+func (v FocusInEvent) ImplementsEvent() {}
+
+func init() {
+	newEventFuncs[9] = NewFocusInEvent
+}
+
+// Event definition KeymapNotify (11)
+// Size: 32
+
+const KeymapNotify = 11
+
+type KeymapNotifyEvent struct {
+	Keys []byte // size: pad(31)
+}
+
+// Event read KeymapNotify
+func NewKeymapNotifyEvent(buf []byte) Event {
+	v := KeymapNotifyEvent{}
+	b := 1 // don't read event number
+
+	v.Keys = make([]byte, 31)
+	copy(v.Keys[:31], buf[b:])
+	b += pad(int(31))
+
+	return v
+}
+
+// Event write KeymapNotify
+func (v KeymapNotifyEvent) Bytes() []byte {
+	buf := make([]byte, 32)
+	b := 0
+
+	// write event number
+	buf[b] = 11
+	b += 1
+
+	copy(buf[b:], v.Keys[:31])
+	b += pad(int(31))
+
+	return buf
+}
+
+func (v KeymapNotifyEvent) ImplementsEvent() {}
+
+func init() {
+	newEventFuncs[11] = NewKeymapNotifyEvent
+}
+
+// Event definition Expose (12)
+// Size: 32
+
+const Expose = 12
+
+type ExposeEvent struct {
+	Sequence uint16
+	// padding: 1 bytes
+	Window Id
+	X      uint16
+	Y      uint16
+	Width  uint16
+	Height uint16
+	Count  uint16
+	// padding: 2 bytes
+}
+
+// Event read Expose
+func NewExposeEvent(buf []byte) Event {
+	v := ExposeEvent{}
+	b := 1 // don't read event number
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Window = Id(Get32(buf[b:]))
+	b += 4
+
+	v.X = Get16(buf[b:])
+	b += 2
+
+	v.Y = Get16(buf[b:])
+	b += 2
+
+	v.Width = Get16(buf[b:])
+	b += 2
+
+	v.Height = Get16(buf[b:])
+	b += 2
+
+	v.Count = Get16(buf[b:])
+	b += 2
+
+	b += 2 // padding
+
+	return v
+}
+
+// Event write Expose
+func (v ExposeEvent) Bytes() []byte {
+	buf := make([]byte, 32)
+	b := 0
+
+	// write event number
+	buf[b] = 12
+	b += 1
+
+	b += 1 // padding
+
+	b += 2 // skip sequence number
+
+	Put32(buf[b:], uint32(v.Window))
+	b += 4
+
+	Put16(buf[b:], v.X)
+	b += 2
+
+	Put16(buf[b:], v.Y)
+	b += 2
+
+	Put16(buf[b:], v.Width)
+	b += 2
+
+	Put16(buf[b:], v.Height)
+	b += 2
+
+	Put16(buf[b:], v.Count)
+	b += 2
+
+	b += 2 // padding
+
+	return buf
+}
+
+func (v ExposeEvent) ImplementsEvent() {}
+
+func init() {
+	newEventFuncs[12] = NewExposeEvent
+}
+
+// Event definition GraphicsExposure (13)
+// Size: 32
+
+const GraphicsExposure = 13
+
+type GraphicsExposureEvent struct {
+	Sequence uint16
+	// padding: 1 bytes
+	Drawable    Id
+	X           uint16
+	Y           uint16
+	Width       uint16
+	Height      uint16
+	MinorOpcode uint16
+	Count       uint16
+	MajorOpcode byte
+	// padding: 3 bytes
+}
+
+// Event read GraphicsExposure
+func NewGraphicsExposureEvent(buf []byte) Event {
+	v := GraphicsExposureEvent{}
+	b := 1 // don't read event number
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Drawable = Id(Get32(buf[b:]))
+	b += 4
+
+	v.X = Get16(buf[b:])
+	b += 2
+
+	v.Y = Get16(buf[b:])
+	b += 2
+
+	v.Width = Get16(buf[b:])
+	b += 2
+
+	v.Height = Get16(buf[b:])
+	b += 2
+
+	v.MinorOpcode = Get16(buf[b:])
+	b += 2
+
+	v.Count = Get16(buf[b:])
+	b += 2
+
+	v.MajorOpcode = buf[b]
+	b += 1
+
+	b += 3 // padding
+
+	return v
+}
+
+// Event write GraphicsExposure
+func (v GraphicsExposureEvent) Bytes() []byte {
+	buf := make([]byte, 32)
+	b := 0
+
+	// write event number
+	buf[b] = 13
+	b += 1
+
+	b += 1 // padding
+
+	b += 2 // skip sequence number
+
+	Put32(buf[b:], uint32(v.Drawable))
+	b += 4
+
+	Put16(buf[b:], v.X)
+	b += 2
+
+	Put16(buf[b:], v.Y)
+	b += 2
+
+	Put16(buf[b:], v.Width)
+	b += 2
+
+	Put16(buf[b:], v.Height)
+	b += 2
+
+	Put16(buf[b:], v.MinorOpcode)
+	b += 2
+
+	Put16(buf[b:], v.Count)
+	b += 2
+
+	buf[b] = v.MajorOpcode
+	b += 1
+
+	b += 3 // padding
+
+	return buf
+}
+
+func (v GraphicsExposureEvent) ImplementsEvent() {}
+
+func init() {
+	newEventFuncs[13] = NewGraphicsExposureEvent
+}
+
+// Event definition NoExposure (14)
+// Size: 32
+
+const NoExposure = 14
+
+type NoExposureEvent struct {
+	Sequence uint16
+	// padding: 1 bytes
+	Drawable    Id
+	MinorOpcode uint16
+	MajorOpcode byte
+	// padding: 1 bytes
+}
+
+// Event read NoExposure
+func NewNoExposureEvent(buf []byte) Event {
+	v := NoExposureEvent{}
+	b := 1 // don't read event number
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Drawable = Id(Get32(buf[b:]))
+	b += 4
+
+	v.MinorOpcode = Get16(buf[b:])
+	b += 2
+
+	v.MajorOpcode = buf[b]
+	b += 1
+
+	b += 1 // padding
+
+	return v
+}
+
+// Event write NoExposure
+func (v NoExposureEvent) Bytes() []byte {
+	buf := make([]byte, 32)
+	b := 0
+
+	// write event number
+	buf[b] = 14
+	b += 1
+
+	b += 1 // padding
+
+	b += 2 // skip sequence number
+
+	Put32(buf[b:], uint32(v.Drawable))
+	b += 4
+
+	Put16(buf[b:], v.MinorOpcode)
+	b += 2
+
+	buf[b] = v.MajorOpcode
+	b += 1
+
+	b += 1 // padding
+
+	return buf
+}
+
+func (v NoExposureEvent) ImplementsEvent() {}
+
+func init() {
+	newEventFuncs[14] = NewNoExposureEvent
+}
+
+// Event definition VisibilityNotify (15)
+// Size: 32
+
+const VisibilityNotify = 15
+
+type VisibilityNotifyEvent struct {
+	Sequence uint16
+	// padding: 1 bytes
+	Window Id
+	State  byte
+	// padding: 3 bytes
+}
+
+// Event read VisibilityNotify
+func NewVisibilityNotifyEvent(buf []byte) Event {
+	v := VisibilityNotifyEvent{}
+	b := 1 // don't read event number
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Window = Id(Get32(buf[b:]))
+	b += 4
+
+	v.State = buf[b]
+	b += 1
+
+	b += 3 // padding
+
+	return v
+}
+
+// Event write VisibilityNotify
+func (v VisibilityNotifyEvent) Bytes() []byte {
+	buf := make([]byte, 32)
+	b := 0
+
+	// write event number
+	buf[b] = 15
+	b += 1
+
+	b += 1 // padding
+
+	b += 2 // skip sequence number
+
+	Put32(buf[b:], uint32(v.Window))
+	b += 4
+
+	buf[b] = v.State
+	b += 1
+
+	b += 3 // padding
+
+	return buf
+}
+
+func (v VisibilityNotifyEvent) ImplementsEvent() {}
+
+func init() {
+	newEventFuncs[15] = NewVisibilityNotifyEvent
+}
+
+// Event definition CreateNotify (16)
+// Size: 32
+
+const CreateNotify = 16
+
+type CreateNotifyEvent struct {
+	Sequence uint16
+	// padding: 1 bytes
+	Parent           Id
+	Window           Id
+	X                int16
+	Y                int16
+	Width            uint16
+	Height           uint16
+	BorderWidth      uint16
+	OverrideRedirect bool
+	// padding: 1 bytes
+}
+
+// Event read CreateNotify
+func NewCreateNotifyEvent(buf []byte) Event {
+	v := CreateNotifyEvent{}
+	b := 1 // don't read event number
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Parent = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Window = Id(Get32(buf[b:]))
+	b += 4
+
+	v.X = int16(Get16(buf[b:]))
+	b += 2
+
+	v.Y = int16(Get16(buf[b:]))
+	b += 2
+
+	v.Width = Get16(buf[b:])
+	b += 2
+
+	v.Height = Get16(buf[b:])
+	b += 2
+
+	v.BorderWidth = Get16(buf[b:])
+	b += 2
+
+	if buf[b] == 1 {
+		v.OverrideRedirect = true
+	} else {
+		v.OverrideRedirect = false
+	}
+	b += 1
+
+	b += 1 // padding
+
+	return v
+}
+
+// Event write CreateNotify
+func (v CreateNotifyEvent) Bytes() []byte {
+	buf := make([]byte, 32)
+	b := 0
+
+	// write event number
+	buf[b] = 16
+	b += 1
+
+	b += 1 // padding
+
+	b += 2 // skip sequence number
+
+	Put32(buf[b:], uint32(v.Parent))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Window))
+	b += 4
+
+	Put16(buf[b:], uint16(v.X))
+	b += 2
+
+	Put16(buf[b:], uint16(v.Y))
+	b += 2
+
+	Put16(buf[b:], v.Width)
+	b += 2
+
+	Put16(buf[b:], v.Height)
+	b += 2
+
+	Put16(buf[b:], v.BorderWidth)
+	b += 2
+
+	if v.OverrideRedirect {
+		buf[b] = 1
+	} else {
+		buf[b] = 0
+	}
+	b += 1
+
+	b += 1 // padding
+
+	return buf
+}
+
+func (v CreateNotifyEvent) ImplementsEvent() {}
+
+func init() {
+	newEventFuncs[16] = NewCreateNotifyEvent
+}
+
+// Event definition DestroyNotify (17)
+// Size: 32
+
+const DestroyNotify = 17
+
+type DestroyNotifyEvent struct {
+	Sequence uint16
+	// padding: 1 bytes
+	Event  Id
+	Window Id
+}
+
+// Event read DestroyNotify
+func NewDestroyNotifyEvent(buf []byte) Event {
+	v := DestroyNotifyEvent{}
+	b := 1 // don't read event number
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Event = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Window = Id(Get32(buf[b:]))
+	b += 4
+
+	return v
+}
+
+// Event write DestroyNotify
+func (v DestroyNotifyEvent) Bytes() []byte {
+	buf := make([]byte, 32)
+	b := 0
+
+	// write event number
+	buf[b] = 17
+	b += 1
+
+	b += 1 // padding
+
+	b += 2 // skip sequence number
+
+	Put32(buf[b:], uint32(v.Event))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Window))
+	b += 4
+
+	return buf
+}
+
+func (v DestroyNotifyEvent) ImplementsEvent() {}
+
+func init() {
+	newEventFuncs[17] = NewDestroyNotifyEvent
+}
+
+// Event definition UnmapNotify (18)
+// Size: 32
+
+const UnmapNotify = 18
+
+type UnmapNotifyEvent struct {
+	Sequence uint16
+	// padding: 1 bytes
+	Event         Id
+	Window        Id
+	FromConfigure bool
+	// padding: 3 bytes
+}
+
+// Event read UnmapNotify
+func NewUnmapNotifyEvent(buf []byte) Event {
+	v := UnmapNotifyEvent{}
+	b := 1 // don't read event number
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Event = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Window = Id(Get32(buf[b:]))
+	b += 4
+
+	if buf[b] == 1 {
+		v.FromConfigure = true
+	} else {
+		v.FromConfigure = false
+	}
+	b += 1
+
+	b += 3 // padding
+
+	return v
+}
+
+// Event write UnmapNotify
+func (v UnmapNotifyEvent) Bytes() []byte {
+	buf := make([]byte, 32)
+	b := 0
+
+	// write event number
+	buf[b] = 18
+	b += 1
+
+	b += 1 // padding
+
+	b += 2 // skip sequence number
+
+	Put32(buf[b:], uint32(v.Event))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Window))
+	b += 4
+
+	if v.FromConfigure {
+		buf[b] = 1
+	} else {
+		buf[b] = 0
+	}
+	b += 1
+
+	b += 3 // padding
+
+	return buf
+}
+
+func (v UnmapNotifyEvent) ImplementsEvent() {}
+
+func init() {
+	newEventFuncs[18] = NewUnmapNotifyEvent
+}
+
+// Event definition MapNotify (19)
+// Size: 32
+
+const MapNotify = 19
+
+type MapNotifyEvent struct {
+	Sequence uint16
+	// padding: 1 bytes
+	Event            Id
+	Window           Id
+	OverrideRedirect bool
+	// padding: 3 bytes
+}
+
+// Event read MapNotify
+func NewMapNotifyEvent(buf []byte) Event {
+	v := MapNotifyEvent{}
+	b := 1 // don't read event number
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Event = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Window = Id(Get32(buf[b:]))
+	b += 4
+
+	if buf[b] == 1 {
+		v.OverrideRedirect = true
+	} else {
+		v.OverrideRedirect = false
+	}
+	b += 1
+
+	b += 3 // padding
+
+	return v
+}
+
+// Event write MapNotify
+func (v MapNotifyEvent) Bytes() []byte {
+	buf := make([]byte, 32)
+	b := 0
+
+	// write event number
+	buf[b] = 19
+	b += 1
+
+	b += 1 // padding
+
+	b += 2 // skip sequence number
+
+	Put32(buf[b:], uint32(v.Event))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Window))
+	b += 4
+
+	if v.OverrideRedirect {
+		buf[b] = 1
+	} else {
+		buf[b] = 0
+	}
+	b += 1
+
+	b += 3 // padding
+
+	return buf
+}
+
+func (v MapNotifyEvent) ImplementsEvent() {}
+
+func init() {
+	newEventFuncs[19] = NewMapNotifyEvent
+}
+
+// Event definition MapRequest (20)
+// Size: 32
+
+const MapRequest = 20
+
+type MapRequestEvent struct {
+	Sequence uint16
+	// padding: 1 bytes
+	Parent Id
+	Window Id
+}
+
+// Event read MapRequest
+func NewMapRequestEvent(buf []byte) Event {
+	v := MapRequestEvent{}
+	b := 1 // don't read event number
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Parent = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Window = Id(Get32(buf[b:]))
+	b += 4
+
+	return v
+}
+
+// Event write MapRequest
+func (v MapRequestEvent) Bytes() []byte {
+	buf := make([]byte, 32)
+	b := 0
+
+	// write event number
+	buf[b] = 20
+	b += 1
+
+	b += 1 // padding
+
+	b += 2 // skip sequence number
+
+	Put32(buf[b:], uint32(v.Parent))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Window))
+	b += 4
+
+	return buf
+}
+
+func (v MapRequestEvent) ImplementsEvent() {}
+
+func init() {
+	newEventFuncs[20] = NewMapRequestEvent
+}
+
+// Event definition ReparentNotify (21)
+// Size: 32
+
+const ReparentNotify = 21
+
+type ReparentNotifyEvent struct {
+	Sequence uint16
+	// padding: 1 bytes
+	Event            Id
+	Window           Id
+	Parent           Id
+	X                int16
+	Y                int16
+	OverrideRedirect bool
+	// padding: 3 bytes
+}
+
+// Event read ReparentNotify
+func NewReparentNotifyEvent(buf []byte) Event {
+	v := ReparentNotifyEvent{}
+	b := 1 // don't read event number
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Event = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Window = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Parent = Id(Get32(buf[b:]))
+	b += 4
+
+	v.X = int16(Get16(buf[b:]))
+	b += 2
+
+	v.Y = int16(Get16(buf[b:]))
+	b += 2
+
+	if buf[b] == 1 {
+		v.OverrideRedirect = true
+	} else {
+		v.OverrideRedirect = false
+	}
+	b += 1
+
+	b += 3 // padding
+
+	return v
+}
+
+// Event write ReparentNotify
+func (v ReparentNotifyEvent) Bytes() []byte {
+	buf := make([]byte, 32)
+	b := 0
+
+	// write event number
+	buf[b] = 21
+	b += 1
+
+	b += 1 // padding
+
+	b += 2 // skip sequence number
+
+	Put32(buf[b:], uint32(v.Event))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Window))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Parent))
+	b += 4
+
+	Put16(buf[b:], uint16(v.X))
+	b += 2
+
+	Put16(buf[b:], uint16(v.Y))
+	b += 2
+
+	if v.OverrideRedirect {
+		buf[b] = 1
+	} else {
+		buf[b] = 0
+	}
+	b += 1
+
+	b += 3 // padding
+
+	return buf
+}
+
+func (v ReparentNotifyEvent) ImplementsEvent() {}
+
+func init() {
+	newEventFuncs[21] = NewReparentNotifyEvent
+}
+
+// Event definition ConfigureNotify (22)
+// Size: 32
+
+const ConfigureNotify = 22
+
+type ConfigureNotifyEvent struct {
+	Sequence uint16
+	// padding: 1 bytes
+	Event            Id
+	Window           Id
+	AboveSibling     Id
+	X                int16
+	Y                int16
+	Width            uint16
+	Height           uint16
+	BorderWidth      uint16
+	OverrideRedirect bool
+	// padding: 1 bytes
+}
+
+// Event read ConfigureNotify
+func NewConfigureNotifyEvent(buf []byte) Event {
+	v := ConfigureNotifyEvent{}
+	b := 1 // don't read event number
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Event = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Window = Id(Get32(buf[b:]))
+	b += 4
+
+	v.AboveSibling = Id(Get32(buf[b:]))
+	b += 4
+
+	v.X = int16(Get16(buf[b:]))
+	b += 2
+
+	v.Y = int16(Get16(buf[b:]))
+	b += 2
+
+	v.Width = Get16(buf[b:])
+	b += 2
+
+	v.Height = Get16(buf[b:])
+	b += 2
+
+	v.BorderWidth = Get16(buf[b:])
+	b += 2
+
+	if buf[b] == 1 {
+		v.OverrideRedirect = true
+	} else {
+		v.OverrideRedirect = false
+	}
+	b += 1
+
+	b += 1 // padding
+
+	return v
+}
+
+// Event write ConfigureNotify
+func (v ConfigureNotifyEvent) Bytes() []byte {
+	buf := make([]byte, 32)
+	b := 0
+
+	// write event number
+	buf[b] = 22
+	b += 1
+
+	b += 1 // padding
+
+	b += 2 // skip sequence number
+
+	Put32(buf[b:], uint32(v.Event))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Window))
+	b += 4
+
+	Put32(buf[b:], uint32(v.AboveSibling))
+	b += 4
+
+	Put16(buf[b:], uint16(v.X))
+	b += 2
+
+	Put16(buf[b:], uint16(v.Y))
+	b += 2
+
+	Put16(buf[b:], v.Width)
+	b += 2
+
+	Put16(buf[b:], v.Height)
+	b += 2
+
+	Put16(buf[b:], v.BorderWidth)
+	b += 2
+
+	if v.OverrideRedirect {
+		buf[b] = 1
+	} else {
+		buf[b] = 0
+	}
+	b += 1
+
+	b += 1 // padding
+
+	return buf
+}
+
+func (v ConfigureNotifyEvent) ImplementsEvent() {}
+
+func init() {
+	newEventFuncs[22] = NewConfigureNotifyEvent
+}
+
+// Event definition ConfigureRequest (23)
+// Size: 32
+
+const ConfigureRequest = 23
+
+type ConfigureRequestEvent struct {
+	Sequence    uint16
+	StackMode   byte
+	Parent      Id
+	Window      Id
+	Sibling     Id
+	X           int16
+	Y           int16
+	Width       uint16
+	Height      uint16
+	BorderWidth uint16
+	ValueMask   uint16
+}
+
+// Event read ConfigureRequest
+func NewConfigureRequestEvent(buf []byte) Event {
+	v := ConfigureRequestEvent{}
+	b := 1 // don't read event number
+
+	v.StackMode = buf[b]
+	b += 1
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Parent = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Window = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Sibling = Id(Get32(buf[b:]))
+	b += 4
+
+	v.X = int16(Get16(buf[b:]))
+	b += 2
+
+	v.Y = int16(Get16(buf[b:]))
+	b += 2
+
+	v.Width = Get16(buf[b:])
+	b += 2
+
+	v.Height = Get16(buf[b:])
+	b += 2
+
+	v.BorderWidth = Get16(buf[b:])
+	b += 2
+
+	v.ValueMask = Get16(buf[b:])
+	b += 2
+
+	return v
+}
+
+// Event write ConfigureRequest
+func (v ConfigureRequestEvent) Bytes() []byte {
+	buf := make([]byte, 32)
+	b := 0
+
+	// write event number
+	buf[b] = 23
+	b += 1
+
+	buf[b] = v.StackMode
+	b += 1
+
+	b += 2 // skip sequence number
+
+	Put32(buf[b:], uint32(v.Parent))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Window))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Sibling))
+	b += 4
+
+	Put16(buf[b:], uint16(v.X))
+	b += 2
+
+	Put16(buf[b:], uint16(v.Y))
+	b += 2
+
+	Put16(buf[b:], v.Width)
+	b += 2
+
+	Put16(buf[b:], v.Height)
+	b += 2
+
+	Put16(buf[b:], v.BorderWidth)
+	b += 2
+
+	Put16(buf[b:], v.ValueMask)
+	b += 2
+
+	return buf
+}
+
+func (v ConfigureRequestEvent) ImplementsEvent() {}
+
+func init() {
+	newEventFuncs[23] = NewConfigureRequestEvent
+}
+
+// Event definition GravityNotify (24)
+// Size: 32
+
+const GravityNotify = 24
+
+type GravityNotifyEvent struct {
+	Sequence uint16
+	// padding: 1 bytes
+	Event  Id
+	Window Id
+	X      int16
+	Y      int16
+}
+
+// Event read GravityNotify
+func NewGravityNotifyEvent(buf []byte) Event {
+	v := GravityNotifyEvent{}
+	b := 1 // don't read event number
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Event = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Window = Id(Get32(buf[b:]))
+	b += 4
+
+	v.X = int16(Get16(buf[b:]))
+	b += 2
+
+	v.Y = int16(Get16(buf[b:]))
+	b += 2
+
+	return v
+}
+
+// Event write GravityNotify
+func (v GravityNotifyEvent) Bytes() []byte {
+	buf := make([]byte, 32)
+	b := 0
+
+	// write event number
+	buf[b] = 24
+	b += 1
+
+	b += 1 // padding
+
+	b += 2 // skip sequence number
+
+	Put32(buf[b:], uint32(v.Event))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Window))
+	b += 4
+
+	Put16(buf[b:], uint16(v.X))
+	b += 2
+
+	Put16(buf[b:], uint16(v.Y))
+	b += 2
+
+	return buf
+}
+
+func (v GravityNotifyEvent) ImplementsEvent() {}
+
+func init() {
+	newEventFuncs[24] = NewGravityNotifyEvent
+}
+
+// Event definition ResizeRequest (25)
+// Size: 32
+
+const ResizeRequest = 25
+
+type ResizeRequestEvent struct {
+	Sequence uint16
+	// padding: 1 bytes
+	Window Id
+	Width  uint16
+	Height uint16
+}
+
+// Event read ResizeRequest
+func NewResizeRequestEvent(buf []byte) Event {
+	v := ResizeRequestEvent{}
+	b := 1 // don't read event number
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Window = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Width = Get16(buf[b:])
+	b += 2
+
+	v.Height = Get16(buf[b:])
+	b += 2
+
+	return v
+}
+
+// Event write ResizeRequest
+func (v ResizeRequestEvent) Bytes() []byte {
+	buf := make([]byte, 32)
+	b := 0
+
+	// write event number
+	buf[b] = 25
+	b += 1
+
+	b += 1 // padding
+
+	b += 2 // skip sequence number
+
+	Put32(buf[b:], uint32(v.Window))
+	b += 4
+
+	Put16(buf[b:], v.Width)
+	b += 2
+
+	Put16(buf[b:], v.Height)
+	b += 2
+
+	return buf
+}
+
+func (v ResizeRequestEvent) ImplementsEvent() {}
+
+func init() {
+	newEventFuncs[25] = NewResizeRequestEvent
+}
+
+// Event definition CirculateNotify (26)
+// Size: 32
+
+const CirculateNotify = 26
+
+type CirculateNotifyEvent struct {
+	Sequence uint16
+	// padding: 1 bytes
+	Event  Id
+	Window Id
+	// padding: 4 bytes
+	Place byte
+	// padding: 3 bytes
+}
+
+// Event read CirculateNotify
+func NewCirculateNotifyEvent(buf []byte) Event {
+	v := CirculateNotifyEvent{}
+	b := 1 // don't read event number
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Event = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Window = Id(Get32(buf[b:]))
+	b += 4
+
+	b += 4 // padding
+
+	v.Place = buf[b]
+	b += 1
+
+	b += 3 // padding
+
+	return v
+}
+
+// Event write CirculateNotify
+func (v CirculateNotifyEvent) Bytes() []byte {
+	buf := make([]byte, 32)
+	b := 0
+
+	// write event number
+	buf[b] = 26
+	b += 1
+
+	b += 1 // padding
+
+	b += 2 // skip sequence number
+
+	Put32(buf[b:], uint32(v.Event))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Window))
+	b += 4
+
+	b += 4 // padding
+
+	buf[b] = v.Place
+	b += 1
+
+	b += 3 // padding
+
+	return buf
+}
+
+func (v CirculateNotifyEvent) ImplementsEvent() {}
+
+func init() {
+	newEventFuncs[26] = NewCirculateNotifyEvent
+}
+
+// Event definition PropertyNotify (28)
+// Size: 32
+
+const PropertyNotify = 28
+
+type PropertyNotifyEvent struct {
+	Sequence uint16
+	// padding: 1 bytes
+	Window Id
+	Atom   Id
+	Time   Timestamp
+	State  byte
+	// padding: 3 bytes
+}
+
+// Event read PropertyNotify
+func NewPropertyNotifyEvent(buf []byte) Event {
+	v := PropertyNotifyEvent{}
+	b := 1 // don't read event number
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Window = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Atom = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Time = Timestamp(Get32(buf[b:]))
+	b += 4
+
+	v.State = buf[b]
+	b += 1
+
+	b += 3 // padding
+
+	return v
+}
+
+// Event write PropertyNotify
+func (v PropertyNotifyEvent) Bytes() []byte {
+	buf := make([]byte, 32)
+	b := 0
+
+	// write event number
+	buf[b] = 28
+	b += 1
+
+	b += 1 // padding
+
+	b += 2 // skip sequence number
+
+	Put32(buf[b:], uint32(v.Window))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Atom))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Time))
+	b += 4
+
+	buf[b] = v.State
+	b += 1
+
+	b += 3 // padding
+
+	return buf
+}
+
+func (v PropertyNotifyEvent) ImplementsEvent() {}
+
+func init() {
+	newEventFuncs[28] = NewPropertyNotifyEvent
+}
+
+// Event definition SelectionClear (29)
+// Size: 32
+
+const SelectionClear = 29
+
+type SelectionClearEvent struct {
+	Sequence uint16
+	// padding: 1 bytes
+	Time      Timestamp
+	Owner     Id
+	Selection Id
+}
+
+// Event read SelectionClear
+func NewSelectionClearEvent(buf []byte) Event {
+	v := SelectionClearEvent{}
+	b := 1 // don't read event number
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Time = Timestamp(Get32(buf[b:]))
+	b += 4
+
+	v.Owner = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Selection = Id(Get32(buf[b:]))
+	b += 4
+
+	return v
+}
+
+// Event write SelectionClear
+func (v SelectionClearEvent) Bytes() []byte {
+	buf := make([]byte, 32)
+	b := 0
+
+	// write event number
+	buf[b] = 29
+	b += 1
+
+	b += 1 // padding
+
+	b += 2 // skip sequence number
+
+	Put32(buf[b:], uint32(v.Time))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Owner))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Selection))
+	b += 4
+
+	return buf
+}
+
+func (v SelectionClearEvent) ImplementsEvent() {}
+
+func init() {
+	newEventFuncs[29] = NewSelectionClearEvent
+}
+
+// Event definition SelectionRequest (30)
+// Size: 32
+
+const SelectionRequest = 30
+
+type SelectionRequestEvent struct {
+	Sequence uint16
+	// padding: 1 bytes
+	Time      Timestamp
+	Owner     Id
+	Requestor Id
+	Selection Id
+	Target    Id
+	Property  Id
+}
+
+// Event read SelectionRequest
+func NewSelectionRequestEvent(buf []byte) Event {
+	v := SelectionRequestEvent{}
+	b := 1 // don't read event number
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Time = Timestamp(Get32(buf[b:]))
+	b += 4
+
+	v.Owner = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Requestor = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Selection = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Target = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Property = Id(Get32(buf[b:]))
+	b += 4
+
+	return v
+}
+
+// Event write SelectionRequest
+func (v SelectionRequestEvent) Bytes() []byte {
+	buf := make([]byte, 32)
+	b := 0
+
+	// write event number
+	buf[b] = 30
+	b += 1
+
+	b += 1 // padding
+
+	b += 2 // skip sequence number
+
+	Put32(buf[b:], uint32(v.Time))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Owner))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Requestor))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Selection))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Target))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Property))
+	b += 4
+
+	return buf
+}
+
+func (v SelectionRequestEvent) ImplementsEvent() {}
+
+func init() {
+	newEventFuncs[30] = NewSelectionRequestEvent
+}
+
+// Event definition SelectionNotify (31)
+// Size: 32
+
+const SelectionNotify = 31
+
+type SelectionNotifyEvent struct {
+	Sequence uint16
+	// padding: 1 bytes
+	Time      Timestamp
+	Requestor Id
+	Selection Id
+	Target    Id
+	Property  Id
+}
+
+// Event read SelectionNotify
+func NewSelectionNotifyEvent(buf []byte) Event {
+	v := SelectionNotifyEvent{}
+	b := 1 // don't read event number
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Time = Timestamp(Get32(buf[b:]))
+	b += 4
+
+	v.Requestor = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Selection = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Target = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Property = Id(Get32(buf[b:]))
+	b += 4
+
+	return v
+}
+
+// Event write SelectionNotify
+func (v SelectionNotifyEvent) Bytes() []byte {
+	buf := make([]byte, 32)
+	b := 0
+
+	// write event number
+	buf[b] = 31
+	b += 1
+
+	b += 1 // padding
+
+	b += 2 // skip sequence number
+
+	Put32(buf[b:], uint32(v.Time))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Requestor))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Selection))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Target))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Property))
+	b += 4
+
+	return buf
+}
+
+func (v SelectionNotifyEvent) ImplementsEvent() {}
+
+func init() {
+	newEventFuncs[31] = NewSelectionNotifyEvent
+}
+
+// Event definition ColormapNotify (32)
+// Size: 32
+
+const ColormapNotify = 32
+
+type ColormapNotifyEvent struct {
+	Sequence uint16
+	// padding: 1 bytes
+	Window   Id
+	Colormap Id
+	New      bool
+	State    byte
+	// padding: 2 bytes
+}
+
+// Event read ColormapNotify
+func NewColormapNotifyEvent(buf []byte) Event {
+	v := ColormapNotifyEvent{}
+	b := 1 // don't read event number
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Window = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Colormap = Id(Get32(buf[b:]))
+	b += 4
+
+	if buf[b] == 1 {
+		v.New = true
+	} else {
+		v.New = false
+	}
+	b += 1
+
+	v.State = buf[b]
+	b += 1
+
+	b += 2 // padding
+
+	return v
+}
+
+// Event write ColormapNotify
+func (v ColormapNotifyEvent) Bytes() []byte {
+	buf := make([]byte, 32)
+	b := 0
+
+	// write event number
+	buf[b] = 32
+	b += 1
+
+	b += 1 // padding
+
+	b += 2 // skip sequence number
+
+	Put32(buf[b:], uint32(v.Window))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Colormap))
+	b += 4
+
+	if v.New {
+		buf[b] = 1
+	} else {
+		buf[b] = 0
+	}
+	b += 1
+
+	buf[b] = v.State
+	b += 1
+
+	b += 2 // padding
+
+	return buf
+}
+
+func (v ColormapNotifyEvent) ImplementsEvent() {}
+
+func init() {
+	newEventFuncs[32] = NewColormapNotifyEvent
+}
+
+// Event definition ClientMessage (33)
+// Size: 32
+
+const ClientMessage = 33
+
+type ClientMessageEvent struct {
+	Sequence uint16
+	Format   byte
+	Window   Id
+	Type     Id
+	Data     ClientMessageDataUnion
+}
+
+// Event read ClientMessage
+func NewClientMessageEvent(buf []byte) Event {
+	v := ClientMessageEvent{}
+	b := 1 // don't read event number
+
+	v.Format = buf[b]
+	b += 1
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Window = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Type = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Data = ClientMessageDataUnion{}
+	b += ReadClientMessageDataUnion(buf[b:], &v.Data)
+
+	return v
+}
+
+// Event write ClientMessage
+func (v ClientMessageEvent) Bytes() []byte {
+	buf := make([]byte, 32)
+	b := 0
+
+	// write event number
+	buf[b] = 33
+	b += 1
+
+	buf[b] = v.Format
+	b += 1
+
+	b += 2 // skip sequence number
+
+	Put32(buf[b:], uint32(v.Window))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Type))
+	b += 4
+
+	{
+		unionBytes := v.Data.Bytes()
+		copy(buf[b:], unionBytes)
+		b += pad(len(unionBytes))
+	}
+
+	return buf
+}
+
+func (v ClientMessageEvent) ImplementsEvent() {}
+
+func init() {
+	newEventFuncs[33] = NewClientMessageEvent
+}
+
+// Event definition MappingNotify (34)
+// Size: 32
+
+const MappingNotify = 34
+
+type MappingNotifyEvent struct {
+	Sequence uint16
+	// padding: 1 bytes
+	Request      byte
+	FirstKeycode Keycode
+	Count        byte
+	// padding: 1 bytes
+}
+
+// Event read MappingNotify
+func NewMappingNotifyEvent(buf []byte) Event {
+	v := MappingNotifyEvent{}
+	b := 1 // don't read event number
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Request = buf[b]
+	b += 1
+
+	v.FirstKeycode = Keycode(buf[b])
+	b += 1
+
+	v.Count = buf[b]
+	b += 1
+
+	b += 1 // padding
+
+	return v
+}
+
+// Event write MappingNotify
+func (v MappingNotifyEvent) Bytes() []byte {
+	buf := make([]byte, 32)
+	b := 0
+
+	// write event number
+	buf[b] = 34
+	b += 1
+
+	b += 1 // padding
+
+	b += 2 // skip sequence number
+
+	buf[b] = v.Request
+	b += 1
+
+	buf[b] = byte(v.FirstKeycode)
+	b += 1
+
+	buf[b] = v.Count
+	b += 1
+
+	b += 1 // padding
+
+	return buf
+}
+
+func (v MappingNotifyEvent) ImplementsEvent() {}
+
+func init() {
+	newEventFuncs[34] = NewMappingNotifyEvent
+}
+
+// EventCopy definition KeyRelease (3)
+
+const KeyRelease = 3
+
+type KeyReleaseEvent KeyPressEvent
+
+func NewKeyReleaseEvent(buf []byte) Event {
+	return KeyReleaseEvent(NewKeyPressEvent(buf).(KeyPressEvent))
+}
+
+func (v KeyReleaseEvent) Bytes() []byte {
+	return KeyPressEvent(v).Bytes()
+}
+
+func (v KeyReleaseEvent) ImplementsEvent() {}
+
+func init() {
+	newEventFuncs[3] = NewKeyReleaseEvent
+}
+
+// EventCopy definition ButtonRelease (5)
+
+const ButtonRelease = 5
+
+type ButtonReleaseEvent ButtonPressEvent
+
+func NewButtonReleaseEvent(buf []byte) Event {
+	return ButtonReleaseEvent(NewButtonPressEvent(buf).(ButtonPressEvent))
+}
+
+func (v ButtonReleaseEvent) Bytes() []byte {
+	return ButtonPressEvent(v).Bytes()
+}
+
+func (v ButtonReleaseEvent) ImplementsEvent() {}
+
+func init() {
+	newEventFuncs[5] = NewButtonReleaseEvent
+}
+
+// EventCopy definition LeaveNotify (8)
+
+const LeaveNotify = 8
+
+type LeaveNotifyEvent EnterNotifyEvent
+
+func NewLeaveNotifyEvent(buf []byte) Event {
+	return LeaveNotifyEvent(NewEnterNotifyEvent(buf).(EnterNotifyEvent))
+}
+
+func (v LeaveNotifyEvent) Bytes() []byte {
+	return EnterNotifyEvent(v).Bytes()
+}
+
+func (v LeaveNotifyEvent) ImplementsEvent() {}
+
+func init() {
+	newEventFuncs[8] = NewLeaveNotifyEvent
+}
+
+// EventCopy definition FocusOut (10)
+
+const FocusOut = 10
+
+type FocusOutEvent FocusInEvent
+
+func NewFocusOutEvent(buf []byte) Event {
+	return FocusOutEvent(NewFocusInEvent(buf).(FocusInEvent))
+}
+
+func (v FocusOutEvent) Bytes() []byte {
+	return FocusInEvent(v).Bytes()
+}
+
+func (v FocusOutEvent) ImplementsEvent() {}
+
+func init() {
+	newEventFuncs[10] = NewFocusOutEvent
+}
+
+// EventCopy definition CirculateRequest (27)
+
+const CirculateRequest = 27
+
+type CirculateRequestEvent CirculateNotifyEvent
+
+func NewCirculateRequestEvent(buf []byte) Event {
+	return CirculateRequestEvent(NewCirculateNotifyEvent(buf).(CirculateNotifyEvent))
+}
+
+func (v CirculateRequestEvent) Bytes() []byte {
+	return CirculateNotifyEvent(v).Bytes()
+}
+
+func (v CirculateRequestEvent) ImplementsEvent() {}
+
+func init() {
+	newEventFuncs[27] = NewCirculateRequestEvent
+}
+
+// Error definition Request (1)
+// Size: 32
+
+const BadRequest = 1
+
+type RequestError struct {
+	Sequence    uint16
+	NiceName    string
+	BadValue    uint32
+	MinorOpcode uint16
+	MajorOpcode byte
+	// padding: 1 bytes
+}
+
+// Error read Request
+func NewRequestError(buf []byte) Error {
+	v := RequestError{}
+	v.NiceName = "Request"
+
+	b := 1 // skip error determinant
+	b += 1 // don't read error number
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.BadValue = Get32(buf[b:])
+	b += 4
+
+	v.MinorOpcode = Get16(buf[b:])
+	b += 2
+
+	v.MajorOpcode = buf[b]
+	b += 1
+
+	b += 1 // padding
+
+	return v
+}
+
+func (err RequestError) ImplementsError() {}
+
+func (err RequestError) SequenceId() uint16 {
+	return err.Sequence
+}
+
+func (err RequestError) BadId() Id {
+	return Id(err.BadValue)
+}
+
+func (err RequestError) Error() string {
+	fieldVals := make([]string, 0, 4)
+	fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+	fieldVals = append(fieldVals, sprintf("BadValue: %d", err.BadValue))
+	fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", err.MinorOpcode))
+	fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", err.MajorOpcode))
+	return "BadRequest {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+	newErrorFuncs[1] = NewRequestError
+}
+
+// Error definition Value (2)
+// Size: 32
+
+const BadValue = 2
+
+type ValueError struct {
+	Sequence    uint16
+	NiceName    string
+	BadValue    uint32
+	MinorOpcode uint16
+	MajorOpcode byte
+	// padding: 1 bytes
+}
+
+// Error read Value
+func NewValueError(buf []byte) Error {
+	v := ValueError{}
+	v.NiceName = "Value"
+
+	b := 1 // skip error determinant
+	b += 1 // don't read error number
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.BadValue = Get32(buf[b:])
+	b += 4
+
+	v.MinorOpcode = Get16(buf[b:])
+	b += 2
+
+	v.MajorOpcode = buf[b]
+	b += 1
+
+	b += 1 // padding
+
+	return v
+}
+
+func (err ValueError) ImplementsError() {}
+
+func (err ValueError) SequenceId() uint16 {
+	return err.Sequence
+}
+
+func (err ValueError) BadId() Id {
+	return Id(err.BadValue)
+}
+
+func (err ValueError) Error() string {
+	fieldVals := make([]string, 0, 4)
+	fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+	fieldVals = append(fieldVals, sprintf("BadValue: %d", err.BadValue))
+	fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", err.MinorOpcode))
+	fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", err.MajorOpcode))
+	return "BadValue {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+	newErrorFuncs[2] = NewValueError
+}
+
+// ErrorCopy definition Window (3)
+
+const BadWindow = 3
+
+type WindowError ValueError
+
+func NewWindowError(buf []byte) Error {
+	v := WindowError(NewValueError(buf).(ValueError))
+	v.NiceName = "Window"
+	return v
+}
+
+func (err WindowError) ImplementsError() {}
+
+func (err WindowError) SequenceId() uint16 {
+	return err.Sequence
+}
+
+func (err WindowError) BadId() Id {
+	return Id(err.BadValue)
+}
+
+func (err WindowError) Error() string {
+	fieldVals := make([]string, 0, 4)
+	fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+	fieldVals = append(fieldVals, sprintf("BadValue: %d", err.BadValue))
+	fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", err.MinorOpcode))
+	fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", err.MajorOpcode))
+	return "BadWindow {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+	newErrorFuncs[3] = NewWindowError
+}
+
+// ErrorCopy definition Pixmap (4)
+
+const BadPixmap = 4
+
+type PixmapError ValueError
+
+func NewPixmapError(buf []byte) Error {
+	v := PixmapError(NewValueError(buf).(ValueError))
+	v.NiceName = "Pixmap"
+	return v
+}
+
+func (err PixmapError) ImplementsError() {}
+
+func (err PixmapError) SequenceId() uint16 {
+	return err.Sequence
+}
+
+func (err PixmapError) BadId() Id {
+	return Id(err.BadValue)
+}
+
+func (err PixmapError) Error() string {
+	fieldVals := make([]string, 0, 4)
+	fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+	fieldVals = append(fieldVals, sprintf("BadValue: %d", err.BadValue))
+	fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", err.MinorOpcode))
+	fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", err.MajorOpcode))
+	return "BadPixmap {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+	newErrorFuncs[4] = NewPixmapError
+}
+
+// ErrorCopy definition Atom (5)
+
+const BadAtom = 5
+
+type AtomError ValueError
+
+func NewAtomError(buf []byte) Error {
+	v := AtomError(NewValueError(buf).(ValueError))
+	v.NiceName = "Atom"
+	return v
+}
+
+func (err AtomError) ImplementsError() {}
+
+func (err AtomError) SequenceId() uint16 {
+	return err.Sequence
+}
+
+func (err AtomError) BadId() Id {
+	return Id(err.BadValue)
+}
+
+func (err AtomError) Error() string {
+	fieldVals := make([]string, 0, 4)
+	fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+	fieldVals = append(fieldVals, sprintf("BadValue: %d", err.BadValue))
+	fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", err.MinorOpcode))
+	fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", err.MajorOpcode))
+	return "BadAtom {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+	newErrorFuncs[5] = NewAtomError
+}
+
+// ErrorCopy definition Cursor (6)
+
+const BadCursor = 6
+
+type CursorError ValueError
+
+func NewCursorError(buf []byte) Error {
+	v := CursorError(NewValueError(buf).(ValueError))
+	v.NiceName = "Cursor"
+	return v
+}
+
+func (err CursorError) ImplementsError() {}
+
+func (err CursorError) SequenceId() uint16 {
+	return err.Sequence
+}
+
+func (err CursorError) BadId() Id {
+	return Id(err.BadValue)
+}
+
+func (err CursorError) Error() string {
+	fieldVals := make([]string, 0, 4)
+	fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+	fieldVals = append(fieldVals, sprintf("BadValue: %d", err.BadValue))
+	fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", err.MinorOpcode))
+	fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", err.MajorOpcode))
+	return "BadCursor {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+	newErrorFuncs[6] = NewCursorError
+}
+
+// ErrorCopy definition Font (7)
+
+const BadFont = 7
+
+type FontError ValueError
+
+func NewFontError(buf []byte) Error {
+	v := FontError(NewValueError(buf).(ValueError))
+	v.NiceName = "Font"
+	return v
+}
+
+func (err FontError) ImplementsError() {}
+
+func (err FontError) SequenceId() uint16 {
+	return err.Sequence
+}
+
+func (err FontError) BadId() Id {
+	return Id(err.BadValue)
+}
+
+func (err FontError) Error() string {
+	fieldVals := make([]string, 0, 4)
+	fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+	fieldVals = append(fieldVals, sprintf("BadValue: %d", err.BadValue))
+	fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", err.MinorOpcode))
+	fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", err.MajorOpcode))
+	return "BadFont {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+	newErrorFuncs[7] = NewFontError
+}
+
+// ErrorCopy definition Match (8)
+
+const BadMatch = 8
+
+type MatchError RequestError
+
+func NewMatchError(buf []byte) Error {
+	v := MatchError(NewRequestError(buf).(RequestError))
+	v.NiceName = "Match"
+	return v
+}
+
+func (err MatchError) ImplementsError() {}
+
+func (err MatchError) SequenceId() uint16 {
+	return err.Sequence
+}
+
+func (err MatchError) BadId() Id {
+	return Id(err.BadValue)
+}
+
+func (err MatchError) Error() string {
+	fieldVals := make([]string, 0, 4)
+	fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+	fieldVals = append(fieldVals, sprintf("BadValue: %d", err.BadValue))
+	fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", err.MinorOpcode))
+	fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", err.MajorOpcode))
+	return "BadMatch {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+	newErrorFuncs[8] = NewMatchError
+}
+
+// ErrorCopy definition Drawable (9)
+
+const BadDrawable = 9
+
+type DrawableError ValueError
+
+func NewDrawableError(buf []byte) Error {
+	v := DrawableError(NewValueError(buf).(ValueError))
+	v.NiceName = "Drawable"
+	return v
+}
+
+func (err DrawableError) ImplementsError() {}
+
+func (err DrawableError) SequenceId() uint16 {
+	return err.Sequence
+}
+
+func (err DrawableError) BadId() Id {
+	return Id(err.BadValue)
+}
+
+func (err DrawableError) Error() string {
+	fieldVals := make([]string, 0, 4)
+	fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+	fieldVals = append(fieldVals, sprintf("BadValue: %d", err.BadValue))
+	fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", err.MinorOpcode))
+	fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", err.MajorOpcode))
+	return "BadDrawable {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+	newErrorFuncs[9] = NewDrawableError
+}
+
+// ErrorCopy definition Access (10)
+
+const BadAccess = 10
+
+type AccessError RequestError
+
+func NewAccessError(buf []byte) Error {
+	v := AccessError(NewRequestError(buf).(RequestError))
+	v.NiceName = "Access"
+	return v
+}
+
+func (err AccessError) ImplementsError() {}
+
+func (err AccessError) SequenceId() uint16 {
+	return err.Sequence
+}
+
+func (err AccessError) BadId() Id {
+	return Id(err.BadValue)
+}
+
+func (err AccessError) Error() string {
+	fieldVals := make([]string, 0, 4)
+	fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+	fieldVals = append(fieldVals, sprintf("BadValue: %d", err.BadValue))
+	fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", err.MinorOpcode))
+	fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", err.MajorOpcode))
+	return "BadAccess {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+	newErrorFuncs[10] = NewAccessError
+}
+
+// ErrorCopy definition Alloc (11)
+
+const BadAlloc = 11
+
+type AllocError RequestError
+
+func NewAllocError(buf []byte) Error {
+	v := AllocError(NewRequestError(buf).(RequestError))
+	v.NiceName = "Alloc"
+	return v
+}
+
+func (err AllocError) ImplementsError() {}
+
+func (err AllocError) SequenceId() uint16 {
+	return err.Sequence
+}
+
+func (err AllocError) BadId() Id {
+	return Id(err.BadValue)
+}
+
+func (err AllocError) Error() string {
+	fieldVals := make([]string, 0, 4)
+	fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+	fieldVals = append(fieldVals, sprintf("BadValue: %d", err.BadValue))
+	fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", err.MinorOpcode))
+	fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", err.MajorOpcode))
+	return "BadAlloc {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+	newErrorFuncs[11] = NewAllocError
+}
+
+// ErrorCopy definition Colormap (12)
+
+const BadColormap = 12
+
+type ColormapError ValueError
+
+func NewColormapError(buf []byte) Error {
+	v := ColormapError(NewValueError(buf).(ValueError))
+	v.NiceName = "Colormap"
+	return v
+}
+
+func (err ColormapError) ImplementsError() {}
+
+func (err ColormapError) SequenceId() uint16 {
+	return err.Sequence
+}
+
+func (err ColormapError) BadId() Id {
+	return Id(err.BadValue)
+}
+
+func (err ColormapError) Error() string {
+	fieldVals := make([]string, 0, 4)
+	fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+	fieldVals = append(fieldVals, sprintf("BadValue: %d", err.BadValue))
+	fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", err.MinorOpcode))
+	fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", err.MajorOpcode))
+	return "BadColormap {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+	newErrorFuncs[12] = NewColormapError
+}
+
+// ErrorCopy definition GContext (13)
+
+const BadGContext = 13
+
+type GContextError ValueError
+
+func NewGContextError(buf []byte) Error {
+	v := GContextError(NewValueError(buf).(ValueError))
+	v.NiceName = "GContext"
+	return v
+}
+
+func (err GContextError) ImplementsError() {}
+
+func (err GContextError) SequenceId() uint16 {
+	return err.Sequence
+}
+
+func (err GContextError) BadId() Id {
+	return Id(err.BadValue)
+}
+
+func (err GContextError) Error() string {
+	fieldVals := make([]string, 0, 4)
+	fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+	fieldVals = append(fieldVals, sprintf("BadValue: %d", err.BadValue))
+	fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", err.MinorOpcode))
+	fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", err.MajorOpcode))
+	return "BadGContext {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+	newErrorFuncs[13] = NewGContextError
+}
+
+// ErrorCopy definition IDChoice (14)
+
+const BadIDChoice = 14
+
+type IDChoiceError ValueError
+
+func NewIDChoiceError(buf []byte) Error {
+	v := IDChoiceError(NewValueError(buf).(ValueError))
+	v.NiceName = "IDChoice"
+	return v
+}
+
+func (err IDChoiceError) ImplementsError() {}
+
+func (err IDChoiceError) SequenceId() uint16 {
+	return err.Sequence
+}
+
+func (err IDChoiceError) BadId() Id {
+	return Id(err.BadValue)
+}
+
+func (err IDChoiceError) Error() string {
+	fieldVals := make([]string, 0, 4)
+	fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+	fieldVals = append(fieldVals, sprintf("BadValue: %d", err.BadValue))
+	fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", err.MinorOpcode))
+	fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", err.MajorOpcode))
+	return "BadIDChoice {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+	newErrorFuncs[14] = NewIDChoiceError
+}
+
+// ErrorCopy definition Name (15)
+
+const BadName = 15
+
+type NameError RequestError
+
+func NewNameError(buf []byte) Error {
+	v := NameError(NewRequestError(buf).(RequestError))
+	v.NiceName = "Name"
+	return v
+}
+
+func (err NameError) ImplementsError() {}
+
+func (err NameError) SequenceId() uint16 {
+	return err.Sequence
+}
+
+func (err NameError) BadId() Id {
+	return Id(err.BadValue)
+}
+
+func (err NameError) Error() string {
+	fieldVals := make([]string, 0, 4)
+	fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+	fieldVals = append(fieldVals, sprintf("BadValue: %d", err.BadValue))
+	fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", err.MinorOpcode))
+	fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", err.MajorOpcode))
+	return "BadName {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+	newErrorFuncs[15] = NewNameError
+}
+
+// ErrorCopy definition Length (16)
+
+const BadLength = 16
+
+type LengthError RequestError
+
+func NewLengthError(buf []byte) Error {
+	v := LengthError(NewRequestError(buf).(RequestError))
+	v.NiceName = "Length"
+	return v
+}
+
+func (err LengthError) ImplementsError() {}
+
+func (err LengthError) SequenceId() uint16 {
+	return err.Sequence
+}
+
+func (err LengthError) BadId() Id {
+	return Id(err.BadValue)
+}
+
+func (err LengthError) Error() string {
+	fieldVals := make([]string, 0, 4)
+	fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+	fieldVals = append(fieldVals, sprintf("BadValue: %d", err.BadValue))
+	fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", err.MinorOpcode))
+	fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", err.MajorOpcode))
+	return "BadLength {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+	newErrorFuncs[16] = NewLengthError
+}
+
+// ErrorCopy definition Implementation (17)
+
+const BadImplementation = 17
+
+type ImplementationError RequestError
+
+func NewImplementationError(buf []byte) Error {
+	v := ImplementationError(NewRequestError(buf).(RequestError))
+	v.NiceName = "Implementation"
+	return v
+}
+
+func (err ImplementationError) ImplementsError() {}
+
+func (err ImplementationError) SequenceId() uint16 {
+	return err.Sequence
+}
+
+func (err ImplementationError) BadId() Id {
+	return Id(err.BadValue)
+}
+
+func (err ImplementationError) Error() string {
+	fieldVals := make([]string, 0, 4)
+	fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+	fieldVals = append(fieldVals, sprintf("BadValue: %d", err.BadValue))
+	fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", err.MinorOpcode))
+	fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", err.MajorOpcode))
+	return "BadImplementation {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+	newErrorFuncs[17] = NewImplementationError
+}
+
+// Request CreateWindow
+// size: (28 + (4 + pad((4 * popCount(int(ValueMask))))))
+// Write request to wire for CreateWindow
+func (c *Conn) CreateWindow(Depth byte, Wid Id, Parent Id, X int16, Y int16, Width uint16, Height uint16, BorderWidth uint16, Class uint16, Visual Visualid, ValueMask uint32, ValueList []uint32) {
+	size := (28 + (4 + pad((4 * popCount(int(ValueMask))))))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 1 // request opcode
+	b += 1
+
+	buf[b] = Depth
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Wid))
+	b += 4
+
+	Put32(buf[b:], uint32(Parent))
+	b += 4
+
+	Put16(buf[b:], uint16(X))
+	b += 2
+
+	Put16(buf[b:], uint16(Y))
+	b += 2
+
+	Put16(buf[b:], Width)
+	b += 2
+
+	Put16(buf[b:], Height)
+	b += 2
+
+	Put16(buf[b:], BorderWidth)
+	b += 2
+
+	Put16(buf[b:], Class)
+	b += 2
+
+	Put32(buf[b:], uint32(Visual))
+	b += 4
+
+	Put32(buf[b:], ValueMask)
+	b += 4
+	for i := 0; i < popCount(int(ValueMask)); i++ {
+		Put32(buf[b:], ValueList[i])
+		b += 4
+	}
+	b = pad(b)
+
+	c.sendRequest(false, buf)
+}
+
+// Request ChangeWindowAttributes
+// size: (8 + (4 + pad((4 * popCount(int(ValueMask))))))
+// Write request to wire for ChangeWindowAttributes
+func (c *Conn) ChangeWindowAttributes(Window Id, ValueMask uint32, ValueList []uint32) {
+	size := (8 + (4 + pad((4 * popCount(int(ValueMask))))))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 2 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Window))
+	b += 4
+
+	Put32(buf[b:], ValueMask)
+	b += 4
+	for i := 0; i < popCount(int(ValueMask)); i++ {
+		Put32(buf[b:], ValueList[i])
+		b += 4
+	}
+	b = pad(b)
+
+	c.sendRequest(false, buf)
+}
+
+// Request GetWindowAttributes
+// size: 8
+func (c *Conn) GetWindowAttributes(Window Id) (*GetWindowAttributesReply, error) {
+	return c.GetWindowAttributesReply(c.GetWindowAttributesRequest(Window))
+}
+
+// Write request to wire for GetWindowAttributes
+func (c *Conn) GetWindowAttributesRequest(Window Id) *Cookie {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 3 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Window))
+	b += 4
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for GetWindowAttributes
+// size: 44
+type GetWindowAttributesReply struct {
+	Sequence           uint16
+	Length             uint32
+	BackingStore       byte
+	Visual             Visualid
+	Class              uint16
+	BitGravity         byte
+	WinGravity         byte
+	BackingPlanes      uint32
+	BackingPixel       uint32
+	SaveUnder          bool
+	MapIsInstalled     bool
+	MapState           byte
+	OverrideRedirect   bool
+	Colormap           Id
+	AllEventMasks      uint32
+	YourEventMask      uint32
+	DoNotPropagateMask uint16
+	// padding: 2 bytes
+}
+
+// Read reply GetWindowAttributes
+func (c *Conn) GetWindowAttributesReply(cook *Cookie) (*GetWindowAttributesReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(GetWindowAttributesReply)
+	b := 1 // skip reply determinant
+
+	v.BackingStore = buf[b]
+	b += 1
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.Visual = Visualid(Get32(buf[b:]))
+	b += 4
+
+	v.Class = Get16(buf[b:])
+	b += 2
+
+	v.BitGravity = buf[b]
+	b += 1
+
+	v.WinGravity = buf[b]
+	b += 1
+
+	v.BackingPlanes = Get32(buf[b:])
+	b += 4
+
+	v.BackingPixel = Get32(buf[b:])
+	b += 4
+
+	if buf[b] == 1 {
+		v.SaveUnder = true
+	} else {
+		v.SaveUnder = false
+	}
+	b += 1
+
+	if buf[b] == 1 {
+		v.MapIsInstalled = true
+	} else {
+		v.MapIsInstalled = false
+	}
+	b += 1
+
+	v.MapState = buf[b]
+	b += 1
+
+	if buf[b] == 1 {
+		v.OverrideRedirect = true
+	} else {
+		v.OverrideRedirect = false
+	}
+	b += 1
+
+	v.Colormap = Id(Get32(buf[b:]))
+	b += 4
+
+	v.AllEventMasks = Get32(buf[b:])
+	b += 4
+
+	v.YourEventMask = Get32(buf[b:])
+	b += 4
+
+	v.DoNotPropagateMask = Get16(buf[b:])
+	b += 2
+
+	b += 2 // padding
+
+	return v, nil
+}
+
+// Request DestroyWindow
+// size: 8
+// Write request to wire for DestroyWindow
+func (c *Conn) DestroyWindow(Window Id) {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 4 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Window))
+	b += 4
+
+	c.sendRequest(false, buf)
+}
+
+// Request DestroySubwindows
+// size: 8
+// Write request to wire for DestroySubwindows
+func (c *Conn) DestroySubwindows(Window Id) {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 5 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Window))
+	b += 4
+
+	c.sendRequest(false, buf)
+}
+
+// Request ChangeSaveSet
+// size: 8
+// Write request to wire for ChangeSaveSet
+func (c *Conn) ChangeSaveSet(Mode byte, Window Id) {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 6 // request opcode
+	b += 1
+
+	buf[b] = Mode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Window))
+	b += 4
+
+	c.sendRequest(false, buf)
+}
+
+// Request ReparentWindow
+// size: 16
+// Write request to wire for ReparentWindow
+func (c *Conn) ReparentWindow(Window Id, Parent Id, X int16, Y int16) {
+	size := 16
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 7 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Window))
+	b += 4
+
+	Put32(buf[b:], uint32(Parent))
+	b += 4
+
+	Put16(buf[b:], uint16(X))
+	b += 2
+
+	Put16(buf[b:], uint16(Y))
+	b += 2
+
+	c.sendRequest(false, buf)
+}
+
+// Request MapWindow
+// size: 8
+// Write request to wire for MapWindow
+func (c *Conn) MapWindow(Window Id) {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 8 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Window))
+	b += 4
+
+	c.sendRequest(false, buf)
+}
+
+// Request MapSubwindows
+// size: 8
+// Write request to wire for MapSubwindows
+func (c *Conn) MapSubwindows(Window Id) {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 9 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Window))
+	b += 4
+
+	c.sendRequest(false, buf)
+}
+
+// Request UnmapWindow
+// size: 8
+// Write request to wire for UnmapWindow
+func (c *Conn) UnmapWindow(Window Id) {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 10 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Window))
+	b += 4
+
+	c.sendRequest(false, buf)
+}
+
+// Request UnmapSubwindows
+// size: 8
+// Write request to wire for UnmapSubwindows
+func (c *Conn) UnmapSubwindows(Window Id) {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 11 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Window))
+	b += 4
+
+	c.sendRequest(false, buf)
+}
+
+// Request ConfigureWindow
+// size: (10 + (2 + pad((4 * popCount(int(ValueMask))))))
+// Write request to wire for ConfigureWindow
+func (c *Conn) ConfigureWindow(Window Id, ValueMask uint16, ValueList []uint32) {
+	size := (10 + (2 + pad((4 * popCount(int(ValueMask))))))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 12 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Window))
+	b += 4
+
+	Put16(buf[b:], ValueMask)
+	b += 2
+
+	b += 2 // padding
+
+	for i := 0; i < popCount(int(ValueMask)); i++ {
+		Put32(buf[b:], ValueList[i])
+		b += 4
+	}
+	b = pad(b)
+
+	c.sendRequest(false, buf)
+}
+
+// Request CirculateWindow
+// size: 8
+// Write request to wire for CirculateWindow
+func (c *Conn) CirculateWindow(Direction byte, Window Id) {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 13 // request opcode
+	b += 1
+
+	buf[b] = Direction
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Window))
+	b += 4
+
+	c.sendRequest(false, buf)
+}
+
+// Request GetGeometry
+// size: 8
+func (c *Conn) GetGeometry(Drawable Id) (*GetGeometryReply, error) {
+	return c.GetGeometryReply(c.GetGeometryRequest(Drawable))
+}
+
+// Write request to wire for GetGeometry
+func (c *Conn) GetGeometryRequest(Drawable Id) *Cookie {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 14 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Drawable))
+	b += 4
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for GetGeometry
+// size: 24
+type GetGeometryReply struct {
+	Sequence    uint16
+	Length      uint32
+	Depth       byte
+	Root        Id
+	X           int16
+	Y           int16
+	Width       uint16
+	Height      uint16
+	BorderWidth uint16
+	// padding: 2 bytes
+}
+
+// Read reply GetGeometry
+func (c *Conn) GetGeometryReply(cook *Cookie) (*GetGeometryReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(GetGeometryReply)
+	b := 1 // skip reply determinant
+
+	v.Depth = buf[b]
+	b += 1
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.Root = Id(Get32(buf[b:]))
+	b += 4
+
+	v.X = int16(Get16(buf[b:]))
+	b += 2
+
+	v.Y = int16(Get16(buf[b:]))
+	b += 2
+
+	v.Width = Get16(buf[b:])
+	b += 2
+
+	v.Height = Get16(buf[b:])
+	b += 2
+
+	v.BorderWidth = Get16(buf[b:])
+	b += 2
+
+	b += 2 // padding
+
+	return v, nil
+}
+
+// Request QueryTree
+// size: 8
+func (c *Conn) QueryTree(Window Id) (*QueryTreeReply, error) {
+	return c.QueryTreeReply(c.QueryTreeRequest(Window))
+}
+
+// Write request to wire for QueryTree
+func (c *Conn) QueryTreeRequest(Window Id) *Cookie {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 15 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Window))
+	b += 4
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for QueryTree
+// size: (32 + pad((int(ChildrenLen) * 4)))
+type QueryTreeReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	Root        Id
+	Parent      Id
+	ChildrenLen uint16
+	// padding: 14 bytes
+	Children []Id // size: pad((int(ChildrenLen) * 4))
+}
+
+// Read reply QueryTree
+func (c *Conn) QueryTreeReply(cook *Cookie) (*QueryTreeReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(QueryTreeReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.Root = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Parent = Id(Get32(buf[b:]))
+	b += 4
+
+	v.ChildrenLen = Get16(buf[b:])
+	b += 2
+
+	b += 14 // padding
+
+	v.Children = make([]Id, v.ChildrenLen)
+	for i := 0; i < int(v.ChildrenLen); i++ {
+		v.Children[i] = Id(Get32(buf[b:]))
+		b += 4
+	}
+	b = pad(b)
+
+	return v, nil
+}
+
+// Request InternAtom
+// size: (8 + pad((int(NameLen) * 1)))
+func (c *Conn) InternAtom(OnlyIfExists bool, NameLen uint16, Name string) (*InternAtomReply, error) {
+	return c.InternAtomReply(c.InternAtomRequest(OnlyIfExists, NameLen, Name))
+}
+
+// Write request to wire for InternAtom
+func (c *Conn) InternAtomRequest(OnlyIfExists bool, NameLen uint16, Name string) *Cookie {
+	size := (8 + pad((int(NameLen) * 1)))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 16 // request opcode
+	b += 1
+
+	if OnlyIfExists {
+		buf[b] = 1
+	} else {
+		buf[b] = 0
+	}
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put16(buf[b:], NameLen)
+	b += 2
+
+	b += 2 // padding
+
+	copy(buf[b:], Name[:NameLen])
+	b += pad(int(NameLen))
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for InternAtom
+// size: 12
+type InternAtomReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	Atom Id
+}
+
+// Read reply InternAtom
+func (c *Conn) InternAtomReply(cook *Cookie) (*InternAtomReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(InternAtomReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.Atom = Id(Get32(buf[b:]))
+	b += 4
+
+	return v, nil
+}
+
+// Request GetAtomName
+// size: 8
+func (c *Conn) GetAtomName(Atom Id) (*GetAtomNameReply, error) {
+	return c.GetAtomNameReply(c.GetAtomNameRequest(Atom))
+}
+
+// Write request to wire for GetAtomName
+func (c *Conn) GetAtomNameRequest(Atom Id) *Cookie {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 17 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Atom))
+	b += 4
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for GetAtomName
+// size: (32 + pad((int(NameLen) * 1)))
+type GetAtomNameReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	NameLen uint16
+	// padding: 22 bytes
+	Name string // size: pad((int(NameLen) * 1))
+}
+
+// Read reply GetAtomName
+func (c *Conn) GetAtomNameReply(cook *Cookie) (*GetAtomNameReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(GetAtomNameReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.NameLen = Get16(buf[b:])
+	b += 2
+
+	b += 22 // padding
+
+	{
+		byteString := make([]byte, v.NameLen)
+		copy(byteString[:v.NameLen], buf[b:])
+		v.Name = string(byteString)
+		b += pad(int(v.NameLen))
+	}
+
+	return v, nil
+}
+
+// Request ChangeProperty
+// size: (24 + pad((((int(DataLen) * int(Format)) / 8) * 1)))
+// Write request to wire for ChangeProperty
+func (c *Conn) ChangeProperty(Mode byte, Window Id, Property Id, Type Id, Format byte, DataLen uint32, Data []byte) {
+	size := (24 + pad((((int(DataLen) * int(Format)) / 8) * 1)))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 18 // request opcode
+	b += 1
+
+	buf[b] = Mode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Window))
+	b += 4
+
+	Put32(buf[b:], uint32(Property))
+	b += 4
+
+	Put32(buf[b:], uint32(Type))
+	b += 4
+
+	buf[b] = Format
+	b += 1
+
+	b += 3 // padding
+
+	Put32(buf[b:], DataLen)
+	b += 4
+
+	copy(buf[b:], Data[:((int(DataLen)*int(Format))/8)])
+	b += pad(int(((int(DataLen) * int(Format)) / 8)))
+
+	c.sendRequest(false, buf)
+}
+
+// Request DeleteProperty
+// size: 12
+// Write request to wire for DeleteProperty
+func (c *Conn) DeleteProperty(Window Id, Property Id) {
+	size := 12
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 19 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Window))
+	b += 4
+
+	Put32(buf[b:], uint32(Property))
+	b += 4
+
+	c.sendRequest(false, buf)
+}
+
+// Request GetProperty
+// size: 24
+func (c *Conn) GetProperty(Delete bool, Window Id, Property Id, Type Id, LongOffset uint32, LongLength uint32) (*GetPropertyReply, error) {
+	return c.GetPropertyReply(c.GetPropertyRequest(Delete, Window, Property, Type, LongOffset, LongLength))
+}
+
+// Write request to wire for GetProperty
+func (c *Conn) GetPropertyRequest(Delete bool, Window Id, Property Id, Type Id, LongOffset uint32, LongLength uint32) *Cookie {
+	size := 24
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 20 // request opcode
+	b += 1
+
+	if Delete {
+		buf[b] = 1
+	} else {
+		buf[b] = 0
+	}
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Window))
+	b += 4
+
+	Put32(buf[b:], uint32(Property))
+	b += 4
+
+	Put32(buf[b:], uint32(Type))
+	b += 4
+
+	Put32(buf[b:], LongOffset)
+	b += 4
+
+	Put32(buf[b:], LongLength)
+	b += 4
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for GetProperty
+// size: (32 + pad(((int(ValueLen) * (int(Format) / 8)) * 1)))
+type GetPropertyReply struct {
+	Sequence   uint16
+	Length     uint32
+	Format     byte
+	Type       Id
+	BytesAfter uint32
+	ValueLen   uint32
+	// padding: 12 bytes
+	Value []byte // size: pad(((int(ValueLen) * (int(Format) / 8)) * 1))
+}
+
+// Read reply GetProperty
+func (c *Conn) GetPropertyReply(cook *Cookie) (*GetPropertyReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(GetPropertyReply)
+	b := 1 // skip reply determinant
+
+	v.Format = buf[b]
+	b += 1
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.Type = Id(Get32(buf[b:]))
+	b += 4
+
+	v.BytesAfter = Get32(buf[b:])
+	b += 4
+
+	v.ValueLen = Get32(buf[b:])
+	b += 4
+
+	b += 12 // padding
+
+	v.Value = make([]byte, (int(v.ValueLen) * (int(v.Format) / 8)))
+	copy(v.Value[:(int(v.ValueLen)*(int(v.Format)/8))], buf[b:])
+	b += pad(int((int(v.ValueLen) * (int(v.Format) / 8))))
+
+	return v, nil
+}
+
+// Request ListProperties
+// size: 8
+func (c *Conn) ListProperties(Window Id) (*ListPropertiesReply, error) {
+	return c.ListPropertiesReply(c.ListPropertiesRequest(Window))
+}
+
+// Write request to wire for ListProperties
+func (c *Conn) ListPropertiesRequest(Window Id) *Cookie {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 21 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Window))
+	b += 4
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for ListProperties
+// size: (32 + pad((int(AtomsLen) * 4)))
+type ListPropertiesReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	AtomsLen uint16
+	// padding: 22 bytes
+	Atoms []Id // size: pad((int(AtomsLen) * 4))
+}
+
+// Read reply ListProperties
+func (c *Conn) ListPropertiesReply(cook *Cookie) (*ListPropertiesReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(ListPropertiesReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.AtomsLen = Get16(buf[b:])
+	b += 2
+
+	b += 22 // padding
+
+	v.Atoms = make([]Id, v.AtomsLen)
+	for i := 0; i < int(v.AtomsLen); i++ {
+		v.Atoms[i] = Id(Get32(buf[b:]))
+		b += 4
+	}
+	b = pad(b)
+
+	return v, nil
+}
+
+// Request SetSelectionOwner
+// size: 16
+// Write request to wire for SetSelectionOwner
+func (c *Conn) SetSelectionOwner(Owner Id, Selection Id, Time Timestamp) {
+	size := 16
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 22 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Owner))
+	b += 4
+
+	Put32(buf[b:], uint32(Selection))
+	b += 4
+
+	Put32(buf[b:], uint32(Time))
+	b += 4
+
+	c.sendRequest(false, buf)
+}
+
+// Request GetSelectionOwner
+// size: 8
+func (c *Conn) GetSelectionOwner(Selection Id) (*GetSelectionOwnerReply, error) {
+	return c.GetSelectionOwnerReply(c.GetSelectionOwnerRequest(Selection))
+}
+
+// Write request to wire for GetSelectionOwner
+func (c *Conn) GetSelectionOwnerRequest(Selection Id) *Cookie {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 23 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Selection))
+	b += 4
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for GetSelectionOwner
+// size: 12
+type GetSelectionOwnerReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	Owner Id
+}
+
+// Read reply GetSelectionOwner
+func (c *Conn) GetSelectionOwnerReply(cook *Cookie) (*GetSelectionOwnerReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(GetSelectionOwnerReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.Owner = Id(Get32(buf[b:]))
+	b += 4
+
+	return v, nil
+}
+
+// Request ConvertSelection
+// size: 24
+// Write request to wire for ConvertSelection
+func (c *Conn) ConvertSelection(Requestor Id, Selection Id, Target Id, Property Id, Time Timestamp) {
+	size := 24
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 24 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Requestor))
+	b += 4
+
+	Put32(buf[b:], uint32(Selection))
+	b += 4
+
+	Put32(buf[b:], uint32(Target))
+	b += 4
+
+	Put32(buf[b:], uint32(Property))
+	b += 4
+
+	Put32(buf[b:], uint32(Time))
+	b += 4
+
+	c.sendRequest(false, buf)
+}
+
+// Request SendEvent
+// size: (12 + pad(32))
+// Write request to wire for SendEvent
+func (c *Conn) SendEvent(Propagate bool, Destination Id, EventMask uint32, Event string) {
+	size := (12 + pad(32))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 25 // request opcode
+	b += 1
+
+	if Propagate {
+		buf[b] = 1
+	} else {
+		buf[b] = 0
+	}
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Destination))
+	b += 4
+
+	Put32(buf[b:], EventMask)
+	b += 4
+
+	copy(buf[b:], Event[:32])
+	b += pad(int(32))
+
+	c.sendRequest(false, buf)
+}
+
+// Request GrabPointer
+// size: 24
+func (c *Conn) GrabPointer(OwnerEvents bool, GrabWindow Id, EventMask uint16, PointerMode byte, KeyboardMode byte, ConfineTo Id, Cursor Id, Time Timestamp) (*GrabPointerReply, error) {
+	return c.GrabPointerReply(c.GrabPointerRequest(OwnerEvents, GrabWindow, EventMask, PointerMode, KeyboardMode, ConfineTo, Cursor, Time))
+}
+
+// Write request to wire for GrabPointer
+func (c *Conn) GrabPointerRequest(OwnerEvents bool, GrabWindow Id, EventMask uint16, PointerMode byte, KeyboardMode byte, ConfineTo Id, Cursor Id, Time Timestamp) *Cookie {
+	size := 24
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 26 // request opcode
+	b += 1
+
+	if OwnerEvents {
+		buf[b] = 1
+	} else {
+		buf[b] = 0
+	}
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(GrabWindow))
+	b += 4
+
+	Put16(buf[b:], EventMask)
+	b += 2
+
+	buf[b] = PointerMode
+	b += 1
+
+	buf[b] = KeyboardMode
+	b += 1
+
+	Put32(buf[b:], uint32(ConfineTo))
+	b += 4
+
+	Put32(buf[b:], uint32(Cursor))
+	b += 4
+
+	Put32(buf[b:], uint32(Time))
+	b += 4
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for GrabPointer
+// size: 8
+type GrabPointerReply struct {
+	Sequence uint16
+	Length   uint32
+	Status   byte
+}
+
+// Read reply GrabPointer
+func (c *Conn) GrabPointerReply(cook *Cookie) (*GrabPointerReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(GrabPointerReply)
+	b := 1 // skip reply determinant
+
+	v.Status = buf[b]
+	b += 1
+
+	return v, nil
+}
+
+// Request UngrabPointer
+// size: 8
+// Write request to wire for UngrabPointer
+func (c *Conn) UngrabPointer(Time Timestamp) {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 27 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Time))
+	b += 4
+
+	c.sendRequest(false, buf)
+}
+
+// Request GrabButton
+// size: 24
+// Write request to wire for GrabButton
+func (c *Conn) GrabButton(OwnerEvents bool, GrabWindow Id, EventMask uint16, PointerMode byte, KeyboardMode byte, ConfineTo Id, Cursor Id, Button byte, Modifiers uint16) {
+	size := 24
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 28 // request opcode
+	b += 1
+
+	if OwnerEvents {
+		buf[b] = 1
+	} else {
+		buf[b] = 0
+	}
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(GrabWindow))
+	b += 4
+
+	Put16(buf[b:], EventMask)
+	b += 2
+
+	buf[b] = PointerMode
+	b += 1
+
+	buf[b] = KeyboardMode
+	b += 1
+
+	Put32(buf[b:], uint32(ConfineTo))
+	b += 4
+
+	Put32(buf[b:], uint32(Cursor))
+	b += 4
+
+	buf[b] = Button
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], Modifiers)
+	b += 2
+
+	c.sendRequest(false, buf)
+}
+
+// Request UngrabButton
+// size: 12
+// Write request to wire for UngrabButton
+func (c *Conn) UngrabButton(Button byte, GrabWindow Id, Modifiers uint16) {
+	size := 12
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 29 // request opcode
+	b += 1
+
+	buf[b] = Button
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(GrabWindow))
+	b += 4
+
+	Put16(buf[b:], Modifiers)
+	b += 2
+
+	b += 2 // padding
+
+	c.sendRequest(false, buf)
+}
+
+// Request ChangeActivePointerGrab
+// size: 16
+// Write request to wire for ChangeActivePointerGrab
+func (c *Conn) ChangeActivePointerGrab(Cursor Id, Time Timestamp, EventMask uint16) {
+	size := 16
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 30 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Cursor))
+	b += 4
+
+	Put32(buf[b:], uint32(Time))
+	b += 4
+
+	Put16(buf[b:], EventMask)
+	b += 2
+
+	b += 2 // padding
+
+	c.sendRequest(false, buf)
+}
+
+// Request GrabKeyboard
+// size: 16
+func (c *Conn) GrabKeyboard(OwnerEvents bool, GrabWindow Id, Time Timestamp, PointerMode byte, KeyboardMode byte) (*GrabKeyboardReply, error) {
+	return c.GrabKeyboardReply(c.GrabKeyboardRequest(OwnerEvents, GrabWindow, Time, PointerMode, KeyboardMode))
+}
+
+// Write request to wire for GrabKeyboard
+func (c *Conn) GrabKeyboardRequest(OwnerEvents bool, GrabWindow Id, Time Timestamp, PointerMode byte, KeyboardMode byte) *Cookie {
+	size := 16
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 31 // request opcode
+	b += 1
+
+	if OwnerEvents {
+		buf[b] = 1
+	} else {
+		buf[b] = 0
+	}
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(GrabWindow))
+	b += 4
+
+	Put32(buf[b:], uint32(Time))
+	b += 4
+
+	buf[b] = PointerMode
+	b += 1
+
+	buf[b] = KeyboardMode
+	b += 1
+
+	b += 2 // padding
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for GrabKeyboard
+// size: 8
+type GrabKeyboardReply struct {
+	Sequence uint16
+	Length   uint32
+	Status   byte
+}
+
+// Read reply GrabKeyboard
+func (c *Conn) GrabKeyboardReply(cook *Cookie) (*GrabKeyboardReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(GrabKeyboardReply)
+	b := 1 // skip reply determinant
+
+	v.Status = buf[b]
+	b += 1
+
+	return v, nil
+}
+
+// Request UngrabKeyboard
+// size: 8
+// Write request to wire for UngrabKeyboard
+func (c *Conn) UngrabKeyboard(Time Timestamp) {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 32 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Time))
+	b += 4
+
+	c.sendRequest(false, buf)
+}
+
+// Request GrabKey
+// size: 16
+// Write request to wire for GrabKey
+func (c *Conn) GrabKey(OwnerEvents bool, GrabWindow Id, Modifiers uint16, Key Keycode, PointerMode byte, KeyboardMode byte) {
+	size := 16
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 33 // request opcode
+	b += 1
+
+	if OwnerEvents {
+		buf[b] = 1
+	} else {
+		buf[b] = 0
+	}
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(GrabWindow))
+	b += 4
+
+	Put16(buf[b:], Modifiers)
+	b += 2
+
+	buf[b] = byte(Key)
+	b += 1
+
+	buf[b] = PointerMode
+	b += 1
+
+	buf[b] = KeyboardMode
+	b += 1
+
+	b += 3 // padding
+
+	c.sendRequest(false, buf)
+}
+
+// Request UngrabKey
+// size: 12
+// Write request to wire for UngrabKey
+func (c *Conn) UngrabKey(Key Keycode, GrabWindow Id, Modifiers uint16) {
+	size := 12
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 34 // request opcode
+	b += 1
+
+	buf[b] = byte(Key)
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(GrabWindow))
+	b += 4
+
+	Put16(buf[b:], Modifiers)
+	b += 2
+
+	b += 2 // padding
+
+	c.sendRequest(false, buf)
+}
+
+// Request AllowEvents
+// size: 8
+// Write request to wire for AllowEvents
+func (c *Conn) AllowEvents(Mode byte, Time Timestamp) {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 35 // request opcode
+	b += 1
+
+	buf[b] = Mode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Time))
+	b += 4
+
+	c.sendRequest(false, buf)
+}
+
+// Request GrabServer
+// size: 3
+// Write request to wire for GrabServer
+func (c *Conn) GrabServer() {
+	size := 3
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 36 // request opcode
+	b += 1
+
+	c.sendRequest(false, buf)
+}
+
+// Request UngrabServer
+// size: 3
+// Write request to wire for UngrabServer
+func (c *Conn) UngrabServer() {
+	size := 3
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 37 // request opcode
+	b += 1
+
+	c.sendRequest(false, buf)
+}
+
+// Request QueryPointer
+// size: 8
+func (c *Conn) QueryPointer(Window Id) (*QueryPointerReply, error) {
+	return c.QueryPointerReply(c.QueryPointerRequest(Window))
+}
+
+// Write request to wire for QueryPointer
+func (c *Conn) QueryPointerRequest(Window Id) *Cookie {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 38 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Window))
+	b += 4
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for QueryPointer
+// size: 28
+type QueryPointerReply struct {
+	Sequence   uint16
+	Length     uint32
+	SameScreen bool
+	Root       Id
+	Child      Id
+	RootX      int16
+	RootY      int16
+	WinX       int16
+	WinY       int16
+	Mask       uint16
+	// padding: 2 bytes
+}
+
+// Read reply QueryPointer
+func (c *Conn) QueryPointerReply(cook *Cookie) (*QueryPointerReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(QueryPointerReply)
+	b := 1 // skip reply determinant
+
+	if buf[b] == 1 {
+		v.SameScreen = true
+	} else {
+		v.SameScreen = false
+	}
+	b += 1
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.Root = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Child = Id(Get32(buf[b:]))
+	b += 4
+
+	v.RootX = int16(Get16(buf[b:]))
+	b += 2
+
+	v.RootY = int16(Get16(buf[b:]))
+	b += 2
+
+	v.WinX = int16(Get16(buf[b:]))
+	b += 2
+
+	v.WinY = int16(Get16(buf[b:]))
+	b += 2
+
+	v.Mask = Get16(buf[b:])
+	b += 2
+
+	b += 2 // padding
+
+	return v, nil
+}
+
+// Request GetMotionEvents
+// size: 16
+func (c *Conn) GetMotionEvents(Window Id, Start Timestamp, Stop Timestamp) (*GetMotionEventsReply, error) {
+	return c.GetMotionEventsReply(c.GetMotionEventsRequest(Window, Start, Stop))
+}
+
+// Write request to wire for GetMotionEvents
+func (c *Conn) GetMotionEventsRequest(Window Id, Start Timestamp, Stop Timestamp) *Cookie {
+	size := 16
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 39 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Window))
+	b += 4
+
+	Put32(buf[b:], uint32(Start))
+	b += 4
+
+	Put32(buf[b:], uint32(Stop))
+	b += 4
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for GetMotionEvents
+// size: (32 + pad((int(EventsLen) * 8)))
+type GetMotionEventsReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	EventsLen uint32
+	// padding: 20 bytes
+	Events []Timecoord // size: pad((int(EventsLen) * 8))
+}
+
+// Read reply GetMotionEvents
+func (c *Conn) GetMotionEventsReply(cook *Cookie) (*GetMotionEventsReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(GetMotionEventsReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.EventsLen = Get32(buf[b:])
+	b += 4
+
+	b += 20 // padding
+
+	v.Events = make([]Timecoord, v.EventsLen)
+	b += ReadTimecoordList(buf[b:], v.Events)
+
+	return v, nil
+}
+
+// Request TranslateCoordinates
+// size: 16
+func (c *Conn) TranslateCoordinates(SrcWindow Id, DstWindow Id, SrcX int16, SrcY int16) (*TranslateCoordinatesReply, error) {
+	return c.TranslateCoordinatesReply(c.TranslateCoordinatesRequest(SrcWindow, DstWindow, SrcX, SrcY))
+}
+
+// Write request to wire for TranslateCoordinates
+func (c *Conn) TranslateCoordinatesRequest(SrcWindow Id, DstWindow Id, SrcX int16, SrcY int16) *Cookie {
+	size := 16
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 40 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(SrcWindow))
+	b += 4
+
+	Put32(buf[b:], uint32(DstWindow))
+	b += 4
+
+	Put16(buf[b:], uint16(SrcX))
+	b += 2
+
+	Put16(buf[b:], uint16(SrcY))
+	b += 2
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for TranslateCoordinates
+// size: 16
+type TranslateCoordinatesReply struct {
+	Sequence   uint16
+	Length     uint32
+	SameScreen bool
+	Child      Id
+	DstX       int16
+	DstY       int16
+}
+
+// Read reply TranslateCoordinates
+func (c *Conn) TranslateCoordinatesReply(cook *Cookie) (*TranslateCoordinatesReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(TranslateCoordinatesReply)
+	b := 1 // skip reply determinant
+
+	if buf[b] == 1 {
+		v.SameScreen = true
+	} else {
+		v.SameScreen = false
+	}
+	b += 1
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.Child = Id(Get32(buf[b:]))
+	b += 4
+
+	v.DstX = int16(Get16(buf[b:]))
+	b += 2
+
+	v.DstY = int16(Get16(buf[b:]))
+	b += 2
+
+	return v, nil
+}
+
+// Request WarpPointer
+// size: 24
+// Write request to wire for WarpPointer
+func (c *Conn) WarpPointer(SrcWindow Id, DstWindow Id, SrcX int16, SrcY int16, SrcWidth uint16, SrcHeight uint16, DstX int16, DstY int16) {
+	size := 24
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 41 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(SrcWindow))
+	b += 4
+
+	Put32(buf[b:], uint32(DstWindow))
+	b += 4
+
+	Put16(buf[b:], uint16(SrcX))
+	b += 2
+
+	Put16(buf[b:], uint16(SrcY))
+	b += 2
+
+	Put16(buf[b:], SrcWidth)
+	b += 2
+
+	Put16(buf[b:], SrcHeight)
+	b += 2
+
+	Put16(buf[b:], uint16(DstX))
+	b += 2
+
+	Put16(buf[b:], uint16(DstY))
+	b += 2
+
+	c.sendRequest(false, buf)
+}
+
+// Request SetInputFocus
+// size: 12
+// Write request to wire for SetInputFocus
+func (c *Conn) SetInputFocus(RevertTo byte, Focus Id, Time Timestamp) {
+	size := 12
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 42 // request opcode
+	b += 1
+
+	buf[b] = RevertTo
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Focus))
+	b += 4
+
+	Put32(buf[b:], uint32(Time))
+	b += 4
+
+	c.sendRequest(false, buf)
+}
+
+// Request GetInputFocus
+// size: 3
+func (c *Conn) GetInputFocus() (*GetInputFocusReply, error) {
+	return c.GetInputFocusReply(c.GetInputFocusRequest())
+}
+
+// Write request to wire for GetInputFocus
+func (c *Conn) GetInputFocusRequest() *Cookie {
+	size := 3
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 43 // request opcode
+	b += 1
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for GetInputFocus
+// size: 12
+type GetInputFocusReply struct {
+	Sequence uint16
+	Length   uint32
+	RevertTo byte
+	Focus    Id
+}
+
+// Read reply GetInputFocus
+func (c *Conn) GetInputFocusReply(cook *Cookie) (*GetInputFocusReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(GetInputFocusReply)
+	b := 1 // skip reply determinant
+
+	v.RevertTo = buf[b]
+	b += 1
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.Focus = Id(Get32(buf[b:]))
+	b += 4
+
+	return v, nil
+}
+
+// Request QueryKeymap
+// size: 3
+func (c *Conn) QueryKeymap() (*QueryKeymapReply, error) {
+	return c.QueryKeymapReply(c.QueryKeymapRequest())
+}
+
+// Write request to wire for QueryKeymap
+func (c *Conn) QueryKeymapRequest() *Cookie {
+	size := 3
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 44 // request opcode
+	b += 1
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for QueryKeymap
+// size: (8 + pad(32))
+type QueryKeymapReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	Keys []byte // size: pad(32)
+}
+
+// Read reply QueryKeymap
+func (c *Conn) QueryKeymapReply(cook *Cookie) (*QueryKeymapReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(QueryKeymapReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.Keys = make([]byte, 32)
+	copy(v.Keys[:32], buf[b:])
+	b += pad(int(32))
+
+	return v, nil
+}
+
+// Request OpenFont
+// size: (12 + pad((int(NameLen) * 1)))
+// Write request to wire for OpenFont
+func (c *Conn) OpenFont(Fid Id, NameLen uint16, Name string) {
+	size := (12 + pad((int(NameLen) * 1)))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 45 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Fid))
+	b += 4
+
+	Put16(buf[b:], NameLen)
+	b += 2
+
+	b += 2 // padding
+
+	copy(buf[b:], Name[:NameLen])
+	b += pad(int(NameLen))
+
+	c.sendRequest(false, buf)
+}
+
+// Request CloseFont
+// size: 8
+// Write request to wire for CloseFont
+func (c *Conn) CloseFont(Font Id) {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 46 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Font))
+	b += 4
+
+	c.sendRequest(false, buf)
+}
+
+// Request QueryFont
+// size: 8
+func (c *Conn) QueryFont(Font Id) (*QueryFontReply, error) {
+	return c.QueryFontReply(c.QueryFontRequest(Font))
+}
+
+// Write request to wire for QueryFont
+func (c *Conn) QueryFontRequest(Font Id) *Cookie {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 47 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Font))
+	b += 4
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for QueryFont
+// size: ((60 + pad((int(PropertiesLen) * 8))) + pad((int(CharInfosLen) * 12)))
+type QueryFontReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	MinBounds Charinfo
+	// padding: 4 bytes
+	MaxBounds Charinfo
+	// padding: 4 bytes
+	MinCharOrByte2 uint16
+	MaxCharOrByte2 uint16
+	DefaultChar    uint16
+	PropertiesLen  uint16
+	DrawDirection  byte
+	MinByte1       byte
+	MaxByte1       byte
+	AllCharsExist  bool
+	FontAscent     int16
+	FontDescent    int16
+	CharInfosLen   uint32
+	Properties     []Fontprop // size: pad((int(PropertiesLen) * 8))
+	CharInfos      []Charinfo // size: pad((int(CharInfosLen) * 12))
+}
+
+// Read reply QueryFont
+func (c *Conn) QueryFontReply(cook *Cookie) (*QueryFontReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(QueryFontReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.MinBounds = Charinfo{}
+	b += ReadCharinfo(buf[b:], &v.MinBounds)
+
+	b += 4 // padding
+
+	v.MaxBounds = Charinfo{}
+	b += ReadCharinfo(buf[b:], &v.MaxBounds)
+
+	b += 4 // padding
+
+	v.MinCharOrByte2 = Get16(buf[b:])
+	b += 2
+
+	v.MaxCharOrByte2 = Get16(buf[b:])
+	b += 2
+
+	v.DefaultChar = Get16(buf[b:])
+	b += 2
+
+	v.PropertiesLen = Get16(buf[b:])
+	b += 2
+
+	v.DrawDirection = buf[b]
+	b += 1
+
+	v.MinByte1 = buf[b]
+	b += 1
+
+	v.MaxByte1 = buf[b]
+	b += 1
+
+	if buf[b] == 1 {
+		v.AllCharsExist = true
+	} else {
+		v.AllCharsExist = false
+	}
+	b += 1
+
+	v.FontAscent = int16(Get16(buf[b:]))
+	b += 2
+
+	v.FontDescent = int16(Get16(buf[b:]))
+	b += 2
+
+	v.CharInfosLen = Get32(buf[b:])
+	b += 4
+
+	v.Properties = make([]Fontprop, v.PropertiesLen)
+	b += ReadFontpropList(buf[b:], v.Properties)
+
+	v.CharInfos = make([]Charinfo, v.CharInfosLen)
+	b += ReadCharinfoList(buf[b:], v.CharInfos)
+
+	return v, nil
+}
+
+// Request QueryTextExtents
+// size: (8 + pad((len(String) * 2)))
+func (c *Conn) QueryTextExtents(Font Id, String []Char2b, StringLen uint16) (*QueryTextExtentsReply, error) {
+	return c.QueryTextExtentsReply(c.QueryTextExtentsRequest(Font, String, StringLen))
+}
+
+// Write request to wire for QueryTextExtents
+func (c *Conn) QueryTextExtentsRequest(Font Id, String []Char2b, StringLen uint16) *Cookie {
+	size := (8 + pad((len(String) * 2)))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 48 // request opcode
+	b += 1
+
+	buf[b] = byte((int(StringLen) & 1))
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Font))
+	b += 4
+
+	b += Char2bListBytes(buf[b:], String)
+
+	// skip writing local field: StringLen (2) :: uint16
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for QueryTextExtents
+// size: 28
+type QueryTextExtentsReply struct {
+	Sequence       uint16
+	Length         uint32
+	DrawDirection  byte
+	FontAscent     int16
+	FontDescent    int16
+	OverallAscent  int16
+	OverallDescent int16
+	OverallWidth   int32
+	OverallLeft    int32
+	OverallRight   int32
+}
+
+// Read reply QueryTextExtents
+func (c *Conn) QueryTextExtentsReply(cook *Cookie) (*QueryTextExtentsReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(QueryTextExtentsReply)
+	b := 1 // skip reply determinant
+
+	v.DrawDirection = buf[b]
+	b += 1
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.FontAscent = int16(Get16(buf[b:]))
+	b += 2
+
+	v.FontDescent = int16(Get16(buf[b:]))
+	b += 2
+
+	v.OverallAscent = int16(Get16(buf[b:]))
+	b += 2
+
+	v.OverallDescent = int16(Get16(buf[b:]))
+	b += 2
+
+	v.OverallWidth = int32(Get32(buf[b:]))
+	b += 4
+
+	v.OverallLeft = int32(Get32(buf[b:]))
+	b += 4
+
+	v.OverallRight = int32(Get32(buf[b:]))
+	b += 4
+
+	return v, nil
+}
+
+// Request ListFonts
+// size: (8 + pad((int(PatternLen) * 1)))
+func (c *Conn) ListFonts(MaxNames uint16, PatternLen uint16, Pattern string) (*ListFontsReply, error) {
+	return c.ListFontsReply(c.ListFontsRequest(MaxNames, PatternLen, Pattern))
+}
+
+// Write request to wire for ListFonts
+func (c *Conn) ListFontsRequest(MaxNames uint16, PatternLen uint16, Pattern string) *Cookie {
+	size := (8 + pad((int(PatternLen) * 1)))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 49 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put16(buf[b:], MaxNames)
+	b += 2
+
+	Put16(buf[b:], PatternLen)
+	b += 2
+
+	copy(buf[b:], Pattern[:PatternLen])
+	b += pad(int(PatternLen))
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for ListFonts
+// size: (32 + StrListSize(Names))
+type ListFontsReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	NamesLen uint16
+	// padding: 22 bytes
+	Names []Str // size: StrListSize(Names)
+}
+
+// Read reply ListFonts
+func (c *Conn) ListFontsReply(cook *Cookie) (*ListFontsReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(ListFontsReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.NamesLen = Get16(buf[b:])
+	b += 2
+
+	b += 22 // padding
+
+	v.Names = make([]Str, v.NamesLen)
+	b += ReadStrList(buf[b:], v.Names)
+
+	return v, nil
+}
+
+// Request ListFontsWithInfo
+// size: (8 + pad((int(PatternLen) * 1)))
+func (c *Conn) ListFontsWithInfo(MaxNames uint16, PatternLen uint16, Pattern string) (*ListFontsWithInfoReply, error) {
+	return c.ListFontsWithInfoReply(c.ListFontsWithInfoRequest(MaxNames, PatternLen, Pattern))
+}
+
+// Write request to wire for ListFontsWithInfo
+func (c *Conn) ListFontsWithInfoRequest(MaxNames uint16, PatternLen uint16, Pattern string) *Cookie {
+	size := (8 + pad((int(PatternLen) * 1)))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 50 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put16(buf[b:], MaxNames)
+	b += 2
+
+	Put16(buf[b:], PatternLen)
+	b += 2
+
+	copy(buf[b:], Pattern[:PatternLen])
+	b += pad(int(PatternLen))
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for ListFontsWithInfo
+// size: ((60 + pad((int(PropertiesLen) * 8))) + pad((int(NameLen) * 1)))
+type ListFontsWithInfoReply struct {
+	Sequence  uint16
+	Length    uint32
+	NameLen   byte
+	MinBounds Charinfo
+	// padding: 4 bytes
+	MaxBounds Charinfo
+	// padding: 4 bytes
+	MinCharOrByte2 uint16
+	MaxCharOrByte2 uint16
+	DefaultChar    uint16
+	PropertiesLen  uint16
+	DrawDirection  byte
+	MinByte1       byte
+	MaxByte1       byte
+	AllCharsExist  bool
+	FontAscent     int16
+	FontDescent    int16
+	RepliesHint    uint32
+	Properties     []Fontprop // size: pad((int(PropertiesLen) * 8))
+	Name           string     // size: pad((int(NameLen) * 1))
+}
+
+// Read reply ListFontsWithInfo
+func (c *Conn) ListFontsWithInfoReply(cook *Cookie) (*ListFontsWithInfoReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(ListFontsWithInfoReply)
+	b := 1 // skip reply determinant
+
+	v.NameLen = buf[b]
+	b += 1
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.MinBounds = Charinfo{}
+	b += ReadCharinfo(buf[b:], &v.MinBounds)
+
+	b += 4 // padding
+
+	v.MaxBounds = Charinfo{}
+	b += ReadCharinfo(buf[b:], &v.MaxBounds)
+
+	b += 4 // padding
+
+	v.MinCharOrByte2 = Get16(buf[b:])
+	b += 2
+
+	v.MaxCharOrByte2 = Get16(buf[b:])
+	b += 2
+
+	v.DefaultChar = Get16(buf[b:])
+	b += 2
+
+	v.PropertiesLen = Get16(buf[b:])
+	b += 2
+
+	v.DrawDirection = buf[b]
+	b += 1
+
+	v.MinByte1 = buf[b]
+	b += 1
+
+	v.MaxByte1 = buf[b]
+	b += 1
+
+	if buf[b] == 1 {
+		v.AllCharsExist = true
+	} else {
+		v.AllCharsExist = false
+	}
+	b += 1
+
+	v.FontAscent = int16(Get16(buf[b:]))
+	b += 2
+
+	v.FontDescent = int16(Get16(buf[b:]))
+	b += 2
+
+	v.RepliesHint = Get32(buf[b:])
+	b += 4
+
+	v.Properties = make([]Fontprop, v.PropertiesLen)
+	b += ReadFontpropList(buf[b:], v.Properties)
+
+	{
+		byteString := make([]byte, v.NameLen)
+		copy(byteString[:v.NameLen], buf[b:])
+		v.Name = string(byteString)
+		b += pad(int(v.NameLen))
+	}
+
+	return v, nil
+}
+
+// Request SetFontPath
+// size: (8 + StrListSize(Font))
+// Write request to wire for SetFontPath
+func (c *Conn) SetFontPath(FontQty uint16, Font []Str) {
+	size := (8 + StrListSize(Font))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 51 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put16(buf[b:], FontQty)
+	b += 2
+
+	b += 2 // padding
+
+	b += StrListBytes(buf[b:], Font)
+
+	c.sendRequest(false, buf)
+}
+
+// Request GetFontPath
+// size: 3
+func (c *Conn) GetFontPath() (*GetFontPathReply, error) {
+	return c.GetFontPathReply(c.GetFontPathRequest())
+}
+
+// Write request to wire for GetFontPath
+func (c *Conn) GetFontPathRequest() *Cookie {
+	size := 3
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 52 // request opcode
+	b += 1
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for GetFontPath
+// size: (32 + StrListSize(Path))
+type GetFontPathReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	PathLen uint16
+	// padding: 22 bytes
+	Path []Str // size: StrListSize(Path)
+}
+
+// Read reply GetFontPath
+func (c *Conn) GetFontPathReply(cook *Cookie) (*GetFontPathReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(GetFontPathReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.PathLen = Get16(buf[b:])
+	b += 2
+
+	b += 22 // padding
+
+	v.Path = make([]Str, v.PathLen)
+	b += ReadStrList(buf[b:], v.Path)
+
+	return v, nil
+}
+
+// Request CreatePixmap
+// size: 16
+// Write request to wire for CreatePixmap
+func (c *Conn) CreatePixmap(Depth byte, Pid Id, Drawable Id, Width uint16, Height uint16) {
+	size := 16
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 53 // request opcode
+	b += 1
+
+	buf[b] = Depth
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Pid))
+	b += 4
+
+	Put32(buf[b:], uint32(Drawable))
+	b += 4
+
+	Put16(buf[b:], Width)
+	b += 2
+
+	Put16(buf[b:], Height)
+	b += 2
+
+	c.sendRequest(false, buf)
+}
+
+// Request FreePixmap
+// size: 8
+// Write request to wire for FreePixmap
+func (c *Conn) FreePixmap(Pixmap Id) {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 54 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Pixmap))
+	b += 4
+
+	c.sendRequest(false, buf)
+}
+
+// Request CreateGC
+// size: (12 + (4 + pad((4 * popCount(int(ValueMask))))))
+// Write request to wire for CreateGC
+func (c *Conn) CreateGC(Cid Id, Drawable Id, ValueMask uint32, ValueList []uint32) {
+	size := (12 + (4 + pad((4 * popCount(int(ValueMask))))))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 55 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Cid))
+	b += 4
+
+	Put32(buf[b:], uint32(Drawable))
+	b += 4
+
+	Put32(buf[b:], ValueMask)
+	b += 4
+	for i := 0; i < popCount(int(ValueMask)); i++ {
+		Put32(buf[b:], ValueList[i])
+		b += 4
+	}
+	b = pad(b)
+
+	c.sendRequest(false, buf)
+}
+
+// Request ChangeGC
+// size: (8 + (4 + pad((4 * popCount(int(ValueMask))))))
+// Write request to wire for ChangeGC
+func (c *Conn) ChangeGC(Gc Id, ValueMask uint32, ValueList []uint32) {
+	size := (8 + (4 + pad((4 * popCount(int(ValueMask))))))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 56 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Gc))
+	b += 4
+
+	Put32(buf[b:], ValueMask)
+	b += 4
+	for i := 0; i < popCount(int(ValueMask)); i++ {
+		Put32(buf[b:], ValueList[i])
+		b += 4
+	}
+	b = pad(b)
+
+	c.sendRequest(false, buf)
+}
+
+// Request CopyGC
+// size: 16
+// Write request to wire for CopyGC
+func (c *Conn) CopyGC(SrcGc Id, DstGc Id, ValueMask uint32) {
+	size := 16
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 57 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(SrcGc))
+	b += 4
+
+	Put32(buf[b:], uint32(DstGc))
+	b += 4
+
+	Put32(buf[b:], ValueMask)
+	b += 4
+
+	c.sendRequest(false, buf)
+}
+
+// Request SetDashes
+// size: (12 + pad((int(DashesLen) * 1)))
+// Write request to wire for SetDashes
+func (c *Conn) SetDashes(Gc Id, DashOffset uint16, DashesLen uint16, Dashes []byte) {
+	size := (12 + pad((int(DashesLen) * 1)))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 58 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Gc))
+	b += 4
+
+	Put16(buf[b:], DashOffset)
+	b += 2
+
+	Put16(buf[b:], DashesLen)
+	b += 2
+
+	copy(buf[b:], Dashes[:DashesLen])
+	b += pad(int(DashesLen))
+
+	c.sendRequest(false, buf)
+}
+
+// Request SetClipRectangles
+// size: (12 + pad((len(Rectangles) * 8)))
+// Write request to wire for SetClipRectangles
+func (c *Conn) SetClipRectangles(Ordering byte, Gc Id, ClipXOrigin int16, ClipYOrigin int16, Rectangles []Rectangle) {
+	size := (12 + pad((len(Rectangles) * 8)))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 59 // request opcode
+	b += 1
+
+	buf[b] = Ordering
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Gc))
+	b += 4
+
+	Put16(buf[b:], uint16(ClipXOrigin))
+	b += 2
+
+	Put16(buf[b:], uint16(ClipYOrigin))
+	b += 2
+
+	b += RectangleListBytes(buf[b:], Rectangles)
+
+	c.sendRequest(false, buf)
+}
+
+// Request FreeGC
+// size: 8
+// Write request to wire for FreeGC
+func (c *Conn) FreeGC(Gc Id) {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 60 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Gc))
+	b += 4
+
+	c.sendRequest(false, buf)
+}
+
+// Request ClearArea
+// size: 16
+// Write request to wire for ClearArea
+func (c *Conn) ClearArea(Exposures bool, Window Id, X int16, Y int16, Width uint16, Height uint16) {
+	size := 16
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 61 // request opcode
+	b += 1
+
+	if Exposures {
+		buf[b] = 1
+	} else {
+		buf[b] = 0
+	}
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Window))
+	b += 4
+
+	Put16(buf[b:], uint16(X))
+	b += 2
+
+	Put16(buf[b:], uint16(Y))
+	b += 2
+
+	Put16(buf[b:], Width)
+	b += 2
+
+	Put16(buf[b:], Height)
+	b += 2
+
+	c.sendRequest(false, buf)
+}
+
+// Request CopyArea
+// size: 28
+// Write request to wire for CopyArea
+func (c *Conn) CopyArea(SrcDrawable Id, DstDrawable Id, Gc Id, SrcX int16, SrcY int16, DstX int16, DstY int16, Width uint16, Height uint16) {
+	size := 28
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 62 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(SrcDrawable))
+	b += 4
+
+	Put32(buf[b:], uint32(DstDrawable))
+	b += 4
+
+	Put32(buf[b:], uint32(Gc))
+	b += 4
+
+	Put16(buf[b:], uint16(SrcX))
+	b += 2
+
+	Put16(buf[b:], uint16(SrcY))
+	b += 2
+
+	Put16(buf[b:], uint16(DstX))
+	b += 2
+
+	Put16(buf[b:], uint16(DstY))
+	b += 2
+
+	Put16(buf[b:], Width)
+	b += 2
+
+	Put16(buf[b:], Height)
+	b += 2
+
+	c.sendRequest(false, buf)
+}
+
+// Request CopyPlane
+// size: 32
+// Write request to wire for CopyPlane
+func (c *Conn) CopyPlane(SrcDrawable Id, DstDrawable Id, Gc Id, SrcX int16, SrcY int16, DstX int16, DstY int16, Width uint16, Height uint16, BitPlane uint32) {
+	size := 32
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 63 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(SrcDrawable))
+	b += 4
+
+	Put32(buf[b:], uint32(DstDrawable))
+	b += 4
+
+	Put32(buf[b:], uint32(Gc))
+	b += 4
+
+	Put16(buf[b:], uint16(SrcX))
+	b += 2
+
+	Put16(buf[b:], uint16(SrcY))
+	b += 2
+
+	Put16(buf[b:], uint16(DstX))
+	b += 2
+
+	Put16(buf[b:], uint16(DstY))
+	b += 2
+
+	Put16(buf[b:], Width)
+	b += 2
+
+	Put16(buf[b:], Height)
+	b += 2
+
+	Put32(buf[b:], BitPlane)
+	b += 4
+
+	c.sendRequest(false, buf)
+}
+
+// Request PolyPoint
+// size: (12 + pad((len(Points) * 4)))
+// Write request to wire for PolyPoint
+func (c *Conn) PolyPoint(CoordinateMode byte, Drawable Id, Gc Id, Points []Point) {
+	size := (12 + pad((len(Points) * 4)))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 64 // request opcode
+	b += 1
+
+	buf[b] = CoordinateMode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Drawable))
+	b += 4
+
+	Put32(buf[b:], uint32(Gc))
+	b += 4
+
+	b += PointListBytes(buf[b:], Points)
+
+	c.sendRequest(false, buf)
+}
+
+// Request PolyLine
+// size: (12 + pad((len(Points) * 4)))
+// Write request to wire for PolyLine
+func (c *Conn) PolyLine(CoordinateMode byte, Drawable Id, Gc Id, Points []Point) {
+	size := (12 + pad((len(Points) * 4)))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 65 // request opcode
+	b += 1
+
+	buf[b] = CoordinateMode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Drawable))
+	b += 4
+
+	Put32(buf[b:], uint32(Gc))
+	b += 4
+
+	b += PointListBytes(buf[b:], Points)
+
+	c.sendRequest(false, buf)
+}
+
+// Request PolySegment
+// size: (12 + pad((len(Segments) * 8)))
+// Write request to wire for PolySegment
+func (c *Conn) PolySegment(Drawable Id, Gc Id, Segments []Segment) {
+	size := (12 + pad((len(Segments) * 8)))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 66 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Drawable))
+	b += 4
+
+	Put32(buf[b:], uint32(Gc))
+	b += 4
+
+	b += SegmentListBytes(buf[b:], Segments)
+
+	c.sendRequest(false, buf)
+}
+
+// Request PolyRectangle
+// size: (12 + pad((len(Rectangles) * 8)))
+// Write request to wire for PolyRectangle
+func (c *Conn) PolyRectangle(Drawable Id, Gc Id, Rectangles []Rectangle) {
+	size := (12 + pad((len(Rectangles) * 8)))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 67 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Drawable))
+	b += 4
+
+	Put32(buf[b:], uint32(Gc))
+	b += 4
+
+	b += RectangleListBytes(buf[b:], Rectangles)
+
+	c.sendRequest(false, buf)
+}
+
+// Request PolyArc
+// size: (12 + pad((len(Arcs) * 12)))
+// Write request to wire for PolyArc
+func (c *Conn) PolyArc(Drawable Id, Gc Id, Arcs []Arc) {
+	size := (12 + pad((len(Arcs) * 12)))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 68 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Drawable))
+	b += 4
+
+	Put32(buf[b:], uint32(Gc))
+	b += 4
+
+	b += ArcListBytes(buf[b:], Arcs)
+
+	c.sendRequest(false, buf)
+}
+
+// Request FillPoly
+// size: (16 + pad((len(Points) * 4)))
+// Write request to wire for FillPoly
+func (c *Conn) FillPoly(Drawable Id, Gc Id, Shape byte, CoordinateMode byte, Points []Point) {
+	size := (16 + pad((len(Points) * 4)))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 69 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Drawable))
+	b += 4
+
+	Put32(buf[b:], uint32(Gc))
+	b += 4
+
+	buf[b] = Shape
+	b += 1
+
+	buf[b] = CoordinateMode
+	b += 1
+
+	b += 2 // padding
+
+	b += PointListBytes(buf[b:], Points)
+
+	c.sendRequest(false, buf)
+}
+
+// Request PolyFillRectangle
+// size: (12 + pad((len(Rectangles) * 8)))
+// Write request to wire for PolyFillRectangle
+func (c *Conn) PolyFillRectangle(Drawable Id, Gc Id, Rectangles []Rectangle) {
+	size := (12 + pad((len(Rectangles) * 8)))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 70 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Drawable))
+	b += 4
+
+	Put32(buf[b:], uint32(Gc))
+	b += 4
+
+	b += RectangleListBytes(buf[b:], Rectangles)
+
+	c.sendRequest(false, buf)
+}
+
+// Request PolyFillArc
+// size: (12 + pad((len(Arcs) * 12)))
+// Write request to wire for PolyFillArc
+func (c *Conn) PolyFillArc(Drawable Id, Gc Id, Arcs []Arc) {
+	size := (12 + pad((len(Arcs) * 12)))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 71 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Drawable))
+	b += 4
+
+	Put32(buf[b:], uint32(Gc))
+	b += 4
+
+	b += ArcListBytes(buf[b:], Arcs)
+
+	c.sendRequest(false, buf)
+}
+
+// Request PutImage
+// size: (24 + pad((len(Data) * 1)))
+// Write request to wire for PutImage
+func (c *Conn) PutImage(Format byte, Drawable Id, Gc Id, Width uint16, Height uint16, DstX int16, DstY int16, LeftPad byte, Depth byte, Data []byte) {
+	size := (24 + pad((len(Data) * 1)))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 72 // request opcode
+	b += 1
+
+	buf[b] = Format
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Drawable))
+	b += 4
+
+	Put32(buf[b:], uint32(Gc))
+	b += 4
+
+	Put16(buf[b:], Width)
+	b += 2
+
+	Put16(buf[b:], Height)
+	b += 2
+
+	Put16(buf[b:], uint16(DstX))
+	b += 2
+
+	Put16(buf[b:], uint16(DstY))
+	b += 2
+
+	buf[b] = LeftPad
+	b += 1
+
+	buf[b] = Depth
+	b += 1
+
+	b += 2 // padding
+
+	copy(buf[b:], Data[:len(Data)])
+	b += pad(int(len(Data)))
+
+	c.sendRequest(false, buf)
+}
+
+// Request GetImage
+// size: 20
+func (c *Conn) GetImage(Format byte, Drawable Id, X int16, Y int16, Width uint16, Height uint16, PlaneMask uint32) (*GetImageReply, error) {
+	return c.GetImageReply(c.GetImageRequest(Format, Drawable, X, Y, Width, Height, PlaneMask))
+}
+
+// Write request to wire for GetImage
+func (c *Conn) GetImageRequest(Format byte, Drawable Id, X int16, Y int16, Width uint16, Height uint16, PlaneMask uint32) *Cookie {
+	size := 20
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 73 // request opcode
+	b += 1
+
+	buf[b] = Format
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Drawable))
+	b += 4
+
+	Put16(buf[b:], uint16(X))
+	b += 2
+
+	Put16(buf[b:], uint16(Y))
+	b += 2
+
+	Put16(buf[b:], Width)
+	b += 2
+
+	Put16(buf[b:], Height)
+	b += 2
+
+	Put32(buf[b:], PlaneMask)
+	b += 4
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for GetImage
+// size: (32 + pad(((int(Length) * 4) * 1)))
+type GetImageReply struct {
+	Sequence uint16
+	Length   uint32
+	Depth    byte
+	Visual   Visualid
+	// padding: 20 bytes
+	Data []byte // size: pad(((int(Length) * 4) * 1))
+}
+
+// Read reply GetImage
+func (c *Conn) GetImageReply(cook *Cookie) (*GetImageReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(GetImageReply)
+	b := 1 // skip reply determinant
+
+	v.Depth = buf[b]
+	b += 1
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.Visual = Visualid(Get32(buf[b:]))
+	b += 4
+
+	b += 20 // padding
+
+	v.Data = make([]byte, (int(v.Length) * 4))
+	copy(v.Data[:(int(v.Length)*4)], buf[b:])
+	b += pad(int((int(v.Length) * 4)))
+
+	return v, nil
+}
+
+// Request PolyText8
+// size: (16 + pad((len(Items) * 1)))
+// Write request to wire for PolyText8
+func (c *Conn) PolyText8(Drawable Id, Gc Id, X int16, Y int16, Items []byte) {
+	size := (16 + pad((len(Items) * 1)))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 74 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Drawable))
+	b += 4
+
+	Put32(buf[b:], uint32(Gc))
+	b += 4
+
+	Put16(buf[b:], uint16(X))
+	b += 2
+
+	Put16(buf[b:], uint16(Y))
+	b += 2
+
+	copy(buf[b:], Items[:len(Items)])
+	b += pad(int(len(Items)))
+
+	c.sendRequest(false, buf)
+}
+
+// Request PolyText16
+// size: (16 + pad((len(Items) * 1)))
+// Write request to wire for PolyText16
+func (c *Conn) PolyText16(Drawable Id, Gc Id, X int16, Y int16, Items []byte) {
+	size := (16 + pad((len(Items) * 1)))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 75 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Drawable))
+	b += 4
+
+	Put32(buf[b:], uint32(Gc))
+	b += 4
+
+	Put16(buf[b:], uint16(X))
+	b += 2
+
+	Put16(buf[b:], uint16(Y))
+	b += 2
+
+	copy(buf[b:], Items[:len(Items)])
+	b += pad(int(len(Items)))
+
+	c.sendRequest(false, buf)
+}
+
+// Request ImageText8
+// size: (16 + pad((int(StringLen) * 1)))
+// Write request to wire for ImageText8
+func (c *Conn) ImageText8(StringLen byte, Drawable Id, Gc Id, X int16, Y int16, String string) {
+	size := (16 + pad((int(StringLen) * 1)))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 76 // request opcode
+	b += 1
+
+	buf[b] = StringLen
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Drawable))
+	b += 4
+
+	Put32(buf[b:], uint32(Gc))
+	b += 4
+
+	Put16(buf[b:], uint16(X))
+	b += 2
+
+	Put16(buf[b:], uint16(Y))
+	b += 2
+
+	copy(buf[b:], String[:StringLen])
+	b += pad(int(StringLen))
+
+	c.sendRequest(false, buf)
+}
+
+// Request ImageText16
+// size: (16 + pad((int(StringLen) * 2)))
+// Write request to wire for ImageText16
+func (c *Conn) ImageText16(StringLen byte, Drawable Id, Gc Id, X int16, Y int16, String []Char2b) {
+	size := (16 + pad((int(StringLen) * 2)))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 77 // request opcode
+	b += 1
+
+	buf[b] = StringLen
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Drawable))
+	b += 4
+
+	Put32(buf[b:], uint32(Gc))
+	b += 4
+
+	Put16(buf[b:], uint16(X))
+	b += 2
+
+	Put16(buf[b:], uint16(Y))
+	b += 2
+
+	b += Char2bListBytes(buf[b:], String)
+
+	c.sendRequest(false, buf)
+}
+
+// Request CreateColormap
+// size: 16
+// Write request to wire for CreateColormap
+func (c *Conn) CreateColormap(Alloc byte, Mid Id, Window Id, Visual Visualid) {
+	size := 16
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 78 // request opcode
+	b += 1
+
+	buf[b] = Alloc
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Mid))
+	b += 4
+
+	Put32(buf[b:], uint32(Window))
+	b += 4
+
+	Put32(buf[b:], uint32(Visual))
+	b += 4
+
+	c.sendRequest(false, buf)
+}
+
+// Request FreeColormap
+// size: 8
+// Write request to wire for FreeColormap
+func (c *Conn) FreeColormap(Cmap Id) {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 79 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Cmap))
+	b += 4
+
+	c.sendRequest(false, buf)
+}
+
+// Request CopyColormapAndFree
+// size: 12
+// Write request to wire for CopyColormapAndFree
+func (c *Conn) CopyColormapAndFree(Mid Id, SrcCmap Id) {
+	size := 12
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 80 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Mid))
+	b += 4
+
+	Put32(buf[b:], uint32(SrcCmap))
+	b += 4
+
+	c.sendRequest(false, buf)
+}
+
+// Request InstallColormap
+// size: 8
+// Write request to wire for InstallColormap
+func (c *Conn) InstallColormap(Cmap Id) {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 81 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Cmap))
+	b += 4
+
+	c.sendRequest(false, buf)
+}
+
+// Request UninstallColormap
+// size: 8
+// Write request to wire for UninstallColormap
+func (c *Conn) UninstallColormap(Cmap Id) {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 82 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Cmap))
+	b += 4
+
+	c.sendRequest(false, buf)
+}
+
+// Request ListInstalledColormaps
+// size: 8
+func (c *Conn) ListInstalledColormaps(Window Id) (*ListInstalledColormapsReply, error) {
+	return c.ListInstalledColormapsReply(c.ListInstalledColormapsRequest(Window))
+}
+
+// Write request to wire for ListInstalledColormaps
+func (c *Conn) ListInstalledColormapsRequest(Window Id) *Cookie {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 83 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Window))
+	b += 4
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for ListInstalledColormaps
+// size: (32 + pad((int(CmapsLen) * 4)))
+type ListInstalledColormapsReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	CmapsLen uint16
+	// padding: 22 bytes
+	Cmaps []Id // size: pad((int(CmapsLen) * 4))
+}
+
+// Read reply ListInstalledColormaps
+func (c *Conn) ListInstalledColormapsReply(cook *Cookie) (*ListInstalledColormapsReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(ListInstalledColormapsReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.CmapsLen = Get16(buf[b:])
+	b += 2
+
+	b += 22 // padding
+
+	v.Cmaps = make([]Id, v.CmapsLen)
+	for i := 0; i < int(v.CmapsLen); i++ {
+		v.Cmaps[i] = Id(Get32(buf[b:]))
+		b += 4
+	}
+	b = pad(b)
+
+	return v, nil
+}
+
+// Request AllocColor
+// size: 16
+func (c *Conn) AllocColor(Cmap Id, Red uint16, Green uint16, Blue uint16) (*AllocColorReply, error) {
+	return c.AllocColorReply(c.AllocColorRequest(Cmap, Red, Green, Blue))
+}
+
+// Write request to wire for AllocColor
+func (c *Conn) AllocColorRequest(Cmap Id, Red uint16, Green uint16, Blue uint16) *Cookie {
+	size := 16
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 84 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Cmap))
+	b += 4
+
+	Put16(buf[b:], Red)
+	b += 2
+
+	Put16(buf[b:], Green)
+	b += 2
+
+	Put16(buf[b:], Blue)
+	b += 2
+
+	b += 2 // padding
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for AllocColor
+// size: 20
+type AllocColorReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	Red   uint16
+	Green uint16
+	Blue  uint16
+	// padding: 2 bytes
+	Pixel uint32
+}
+
+// Read reply AllocColor
+func (c *Conn) AllocColorReply(cook *Cookie) (*AllocColorReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(AllocColorReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.Red = Get16(buf[b:])
+	b += 2
+
+	v.Green = Get16(buf[b:])
+	b += 2
+
+	v.Blue = Get16(buf[b:])
+	b += 2
+
+	b += 2 // padding
+
+	v.Pixel = Get32(buf[b:])
+	b += 4
+
+	return v, nil
+}
+
+// Request AllocNamedColor
+// size: (12 + pad((int(NameLen) * 1)))
+func (c *Conn) AllocNamedColor(Cmap Id, NameLen uint16, Name string) (*AllocNamedColorReply, error) {
+	return c.AllocNamedColorReply(c.AllocNamedColorRequest(Cmap, NameLen, Name))
+}
+
+// Write request to wire for AllocNamedColor
+func (c *Conn) AllocNamedColorRequest(Cmap Id, NameLen uint16, Name string) *Cookie {
+	size := (12 + pad((int(NameLen) * 1)))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 85 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Cmap))
+	b += 4
+
+	Put16(buf[b:], NameLen)
+	b += 2
+
+	b += 2 // padding
+
+	copy(buf[b:], Name[:NameLen])
+	b += pad(int(NameLen))
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for AllocNamedColor
+// size: 24
+type AllocNamedColorReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	Pixel       uint32
+	ExactRed    uint16
+	ExactGreen  uint16
+	ExactBlue   uint16
+	VisualRed   uint16
+	VisualGreen uint16
+	VisualBlue  uint16
+}
+
+// Read reply AllocNamedColor
+func (c *Conn) AllocNamedColorReply(cook *Cookie) (*AllocNamedColorReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(AllocNamedColorReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.Pixel = Get32(buf[b:])
+	b += 4
+
+	v.ExactRed = Get16(buf[b:])
+	b += 2
+
+	v.ExactGreen = Get16(buf[b:])
+	b += 2
+
+	v.ExactBlue = Get16(buf[b:])
+	b += 2
+
+	v.VisualRed = Get16(buf[b:])
+	b += 2
+
+	v.VisualGreen = Get16(buf[b:])
+	b += 2
+
+	v.VisualBlue = Get16(buf[b:])
+	b += 2
+
+	return v, nil
+}
+
+// Request AllocColorCells
+// size: 12
+func (c *Conn) AllocColorCells(Contiguous bool, Cmap Id, Colors uint16, Planes uint16) (*AllocColorCellsReply, error) {
+	return c.AllocColorCellsReply(c.AllocColorCellsRequest(Contiguous, Cmap, Colors, Planes))
+}
+
+// Write request to wire for AllocColorCells
+func (c *Conn) AllocColorCellsRequest(Contiguous bool, Cmap Id, Colors uint16, Planes uint16) *Cookie {
+	size := 12
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 86 // request opcode
+	b += 1
+
+	if Contiguous {
+		buf[b] = 1
+	} else {
+		buf[b] = 0
+	}
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Cmap))
+	b += 4
+
+	Put16(buf[b:], Colors)
+	b += 2
+
+	Put16(buf[b:], Planes)
+	b += 2
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for AllocColorCells
+// size: ((32 + pad((int(PixelsLen) * 4))) + pad((int(MasksLen) * 4)))
+type AllocColorCellsReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	PixelsLen uint16
+	MasksLen  uint16
+	// padding: 20 bytes
+	Pixels []uint32 // size: pad((int(PixelsLen) * 4))
+	Masks  []uint32 // size: pad((int(MasksLen) * 4))
+}
+
+// Read reply AllocColorCells
+func (c *Conn) AllocColorCellsReply(cook *Cookie) (*AllocColorCellsReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(AllocColorCellsReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.PixelsLen = Get16(buf[b:])
+	b += 2
+
+	v.MasksLen = Get16(buf[b:])
+	b += 2
+
+	b += 20 // padding
+
+	v.Pixels = make([]uint32, v.PixelsLen)
+	for i := 0; i < int(v.PixelsLen); i++ {
+		v.Pixels[i] = Get32(buf[b:])
+		b += 4
+	}
+	b = pad(b)
+
+	v.Masks = make([]uint32, v.MasksLen)
+	for i := 0; i < int(v.MasksLen); i++ {
+		v.Masks[i] = Get32(buf[b:])
+		b += 4
+	}
+	b = pad(b)
+
+	return v, nil
+}
+
+// Request AllocColorPlanes
+// size: 16
+func (c *Conn) AllocColorPlanes(Contiguous bool, Cmap Id, Colors uint16, Reds uint16, Greens uint16, Blues uint16) (*AllocColorPlanesReply, error) {
+	return c.AllocColorPlanesReply(c.AllocColorPlanesRequest(Contiguous, Cmap, Colors, Reds, Greens, Blues))
+}
+
+// Write request to wire for AllocColorPlanes
+func (c *Conn) AllocColorPlanesRequest(Contiguous bool, Cmap Id, Colors uint16, Reds uint16, Greens uint16, Blues uint16) *Cookie {
+	size := 16
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 87 // request opcode
+	b += 1
+
+	if Contiguous {
+		buf[b] = 1
+	} else {
+		buf[b] = 0
+	}
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Cmap))
+	b += 4
+
+	Put16(buf[b:], Colors)
+	b += 2
+
+	Put16(buf[b:], Reds)
+	b += 2
+
+	Put16(buf[b:], Greens)
+	b += 2
+
+	Put16(buf[b:], Blues)
+	b += 2
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for AllocColorPlanes
+// size: (32 + pad((int(PixelsLen) * 4)))
+type AllocColorPlanesReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	PixelsLen uint16
+	// padding: 2 bytes
+	RedMask   uint32
+	GreenMask uint32
+	BlueMask  uint32
+	// padding: 8 bytes
+	Pixels []uint32 // size: pad((int(PixelsLen) * 4))
+}
+
+// Read reply AllocColorPlanes
+func (c *Conn) AllocColorPlanesReply(cook *Cookie) (*AllocColorPlanesReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(AllocColorPlanesReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.PixelsLen = Get16(buf[b:])
+	b += 2
+
+	b += 2 // padding
+
+	v.RedMask = Get32(buf[b:])
+	b += 4
+
+	v.GreenMask = Get32(buf[b:])
+	b += 4
+
+	v.BlueMask = Get32(buf[b:])
+	b += 4
+
+	b += 8 // padding
+
+	v.Pixels = make([]uint32, v.PixelsLen)
+	for i := 0; i < int(v.PixelsLen); i++ {
+		v.Pixels[i] = Get32(buf[b:])
+		b += 4
+	}
+	b = pad(b)
+
+	return v, nil
+}
+
+// Request FreeColors
+// size: (12 + pad((len(Pixels) * 4)))
+// Write request to wire for FreeColors
+func (c *Conn) FreeColors(Cmap Id, PlaneMask uint32, Pixels []uint32) {
+	size := (12 + pad((len(Pixels) * 4)))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 88 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Cmap))
+	b += 4
+
+	Put32(buf[b:], PlaneMask)
+	b += 4
+
+	for i := 0; i < int(len(Pixels)); i++ {
+		Put32(buf[b:], Pixels[i])
+		b += 4
+	}
+	b = pad(b)
+
+	c.sendRequest(false, buf)
+}
+
+// Request StoreColors
+// size: (8 + pad((len(Items) * 12)))
+// Write request to wire for StoreColors
+func (c *Conn) StoreColors(Cmap Id, Items []Coloritem) {
+	size := (8 + pad((len(Items) * 12)))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 89 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Cmap))
+	b += 4
+
+	b += ColoritemListBytes(buf[b:], Items)
+
+	c.sendRequest(false, buf)
+}
+
+// Request StoreNamedColor
+// size: (16 + pad((int(NameLen) * 1)))
+// Write request to wire for StoreNamedColor
+func (c *Conn) StoreNamedColor(Flags byte, Cmap Id, Pixel uint32, NameLen uint16, Name string) {
+	size := (16 + pad((int(NameLen) * 1)))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 90 // request opcode
+	b += 1
+
+	buf[b] = Flags
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Cmap))
+	b += 4
+
+	Put32(buf[b:], Pixel)
+	b += 4
+
+	Put16(buf[b:], NameLen)
+	b += 2
+
+	b += 2 // padding
+
+	copy(buf[b:], Name[:NameLen])
+	b += pad(int(NameLen))
+
+	c.sendRequest(false, buf)
+}
+
+// Request QueryColors
+// size: (8 + pad((len(Pixels) * 4)))
+func (c *Conn) QueryColors(Cmap Id, Pixels []uint32) (*QueryColorsReply, error) {
+	return c.QueryColorsReply(c.QueryColorsRequest(Cmap, Pixels))
+}
+
+// Write request to wire for QueryColors
+func (c *Conn) QueryColorsRequest(Cmap Id, Pixels []uint32) *Cookie {
+	size := (8 + pad((len(Pixels) * 4)))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 91 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Cmap))
+	b += 4
+
+	for i := 0; i < int(len(Pixels)); i++ {
+		Put32(buf[b:], Pixels[i])
+		b += 4
+	}
+	b = pad(b)
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for QueryColors
+// size: (32 + pad((int(ColorsLen) * 8)))
+type QueryColorsReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	ColorsLen uint16
+	// padding: 22 bytes
+	Colors []Rgb // size: pad((int(ColorsLen) * 8))
+}
+
+// Read reply QueryColors
+func (c *Conn) QueryColorsReply(cook *Cookie) (*QueryColorsReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(QueryColorsReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.ColorsLen = Get16(buf[b:])
+	b += 2
+
+	b += 22 // padding
+
+	v.Colors = make([]Rgb, v.ColorsLen)
+	b += ReadRgbList(buf[b:], v.Colors)
+
+	return v, nil
+}
+
+// Request LookupColor
+// size: (12 + pad((int(NameLen) * 1)))
+func (c *Conn) LookupColor(Cmap Id, NameLen uint16, Name string) (*LookupColorReply, error) {
+	return c.LookupColorReply(c.LookupColorRequest(Cmap, NameLen, Name))
+}
+
+// Write request to wire for LookupColor
+func (c *Conn) LookupColorRequest(Cmap Id, NameLen uint16, Name string) *Cookie {
+	size := (12 + pad((int(NameLen) * 1)))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 92 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Cmap))
+	b += 4
+
+	Put16(buf[b:], NameLen)
+	b += 2
+
+	b += 2 // padding
+
+	copy(buf[b:], Name[:NameLen])
+	b += pad(int(NameLen))
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for LookupColor
+// size: 20
+type LookupColorReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	ExactRed    uint16
+	ExactGreen  uint16
+	ExactBlue   uint16
+	VisualRed   uint16
+	VisualGreen uint16
+	VisualBlue  uint16
+}
+
+// Read reply LookupColor
+func (c *Conn) LookupColorReply(cook *Cookie) (*LookupColorReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(LookupColorReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.ExactRed = Get16(buf[b:])
+	b += 2
+
+	v.ExactGreen = Get16(buf[b:])
+	b += 2
+
+	v.ExactBlue = Get16(buf[b:])
+	b += 2
+
+	v.VisualRed = Get16(buf[b:])
+	b += 2
+
+	v.VisualGreen = Get16(buf[b:])
+	b += 2
+
+	v.VisualBlue = Get16(buf[b:])
+	b += 2
+
+	return v, nil
+}
+
+// Request CreateCursor
+// size: 32
+// Write request to wire for CreateCursor
+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) {
+	size := 32
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 93 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Cid))
+	b += 4
+
+	Put32(buf[b:], uint32(Source))
+	b += 4
+
+	Put32(buf[b:], uint32(Mask))
+	b += 4
+
+	Put16(buf[b:], ForeRed)
+	b += 2
+
+	Put16(buf[b:], ForeGreen)
+	b += 2
+
+	Put16(buf[b:], ForeBlue)
+	b += 2
+
+	Put16(buf[b:], BackRed)
+	b += 2
+
+	Put16(buf[b:], BackGreen)
+	b += 2
+
+	Put16(buf[b:], BackBlue)
+	b += 2
+
+	Put16(buf[b:], X)
+	b += 2
+
+	Put16(buf[b:], Y)
+	b += 2
+
+	c.sendRequest(false, buf)
+}
+
+// Request CreateGlyphCursor
+// size: 32
+// Write request to wire for CreateGlyphCursor
+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) {
+	size := 32
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 94 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Cid))
+	b += 4
+
+	Put32(buf[b:], uint32(SourceFont))
+	b += 4
+
+	Put32(buf[b:], uint32(MaskFont))
+	b += 4
+
+	Put16(buf[b:], SourceChar)
+	b += 2
+
+	Put16(buf[b:], MaskChar)
+	b += 2
+
+	Put16(buf[b:], ForeRed)
+	b += 2
+
+	Put16(buf[b:], ForeGreen)
+	b += 2
+
+	Put16(buf[b:], ForeBlue)
+	b += 2
+
+	Put16(buf[b:], BackRed)
+	b += 2
+
+	Put16(buf[b:], BackGreen)
+	b += 2
+
+	Put16(buf[b:], BackBlue)
+	b += 2
+
+	c.sendRequest(false, buf)
+}
+
+// Request FreeCursor
+// size: 8
+// Write request to wire for FreeCursor
+func (c *Conn) FreeCursor(Cursor Id) {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 95 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Cursor))
+	b += 4
+
+	c.sendRequest(false, buf)
+}
+
+// Request RecolorCursor
+// size: 20
+// Write request to wire for RecolorCursor
+func (c *Conn) RecolorCursor(Cursor Id, ForeRed uint16, ForeGreen uint16, ForeBlue uint16, BackRed uint16, BackGreen uint16, BackBlue uint16) {
+	size := 20
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 96 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Cursor))
+	b += 4
+
+	Put16(buf[b:], ForeRed)
+	b += 2
+
+	Put16(buf[b:], ForeGreen)
+	b += 2
+
+	Put16(buf[b:], ForeBlue)
+	b += 2
+
+	Put16(buf[b:], BackRed)
+	b += 2
+
+	Put16(buf[b:], BackGreen)
+	b += 2
+
+	Put16(buf[b:], BackBlue)
+	b += 2
+
+	c.sendRequest(false, buf)
+}
+
+// Request QueryBestSize
+// size: 12
+func (c *Conn) QueryBestSize(Class byte, Drawable Id, Width uint16, Height uint16) (*QueryBestSizeReply, error) {
+	return c.QueryBestSizeReply(c.QueryBestSizeRequest(Class, Drawable, Width, Height))
+}
+
+// Write request to wire for QueryBestSize
+func (c *Conn) QueryBestSizeRequest(Class byte, Drawable Id, Width uint16, Height uint16) *Cookie {
+	size := 12
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 97 // request opcode
+	b += 1
+
+	buf[b] = Class
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Drawable))
+	b += 4
+
+	Put16(buf[b:], Width)
+	b += 2
+
+	Put16(buf[b:], Height)
+	b += 2
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for QueryBestSize
+// size: 12
+type QueryBestSizeReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	Width  uint16
+	Height uint16
+}
+
+// Read reply QueryBestSize
+func (c *Conn) QueryBestSizeReply(cook *Cookie) (*QueryBestSizeReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(QueryBestSizeReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.Width = Get16(buf[b:])
+	b += 2
+
+	v.Height = Get16(buf[b:])
+	b += 2
+
+	return v, nil
+}
+
+// Request QueryExtension
+// size: (8 + pad((int(NameLen) * 1)))
+func (c *Conn) QueryExtension(NameLen uint16, Name string) (*QueryExtensionReply, error) {
+	return c.QueryExtensionReply(c.QueryExtensionRequest(NameLen, Name))
+}
+
+// Write request to wire for QueryExtension
+func (c *Conn) QueryExtensionRequest(NameLen uint16, Name string) *Cookie {
+	size := (8 + pad((int(NameLen) * 1)))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 98 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put16(buf[b:], NameLen)
+	b += 2
+
+	b += 2 // padding
+
+	copy(buf[b:], Name[:NameLen])
+	b += pad(int(NameLen))
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for QueryExtension
+// size: 12
+type QueryExtensionReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	Present     bool
+	MajorOpcode byte
+	FirstEvent  byte
+	FirstError  byte
+}
+
+// Read reply QueryExtension
+func (c *Conn) QueryExtensionReply(cook *Cookie) (*QueryExtensionReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(QueryExtensionReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	if buf[b] == 1 {
+		v.Present = true
+	} else {
+		v.Present = false
+	}
+	b += 1
+
+	v.MajorOpcode = buf[b]
+	b += 1
+
+	v.FirstEvent = buf[b]
+	b += 1
+
+	v.FirstError = buf[b]
+	b += 1
+
+	return v, nil
+}
+
+// Request ListExtensions
+// size: 3
+func (c *Conn) ListExtensions() (*ListExtensionsReply, error) {
+	return c.ListExtensionsReply(c.ListExtensionsRequest())
+}
+
+// Write request to wire for ListExtensions
+func (c *Conn) ListExtensionsRequest() *Cookie {
+	size := 3
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 99 // request opcode
+	b += 1
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for ListExtensions
+// size: (32 + StrListSize(Names))
+type ListExtensionsReply struct {
+	Sequence uint16
+	Length   uint32
+	NamesLen byte
+	// padding: 24 bytes
+	Names []Str // size: StrListSize(Names)
+}
+
+// Read reply ListExtensions
+func (c *Conn) ListExtensionsReply(cook *Cookie) (*ListExtensionsReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(ListExtensionsReply)
+	b := 1 // skip reply determinant
+
+	v.NamesLen = buf[b]
+	b += 1
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	b += 24 // padding
+
+	v.Names = make([]Str, v.NamesLen)
+	b += ReadStrList(buf[b:], v.Names)
+
+	return v, nil
+}
+
+// Request ChangeKeyboardMapping
+// size: (8 + pad(((int(KeycodeCount) * int(KeysymsPerKeycode)) * 4)))
+// Write request to wire for ChangeKeyboardMapping
+func (c *Conn) ChangeKeyboardMapping(KeycodeCount byte, FirstKeycode Keycode, KeysymsPerKeycode byte, Keysyms []Keysym) {
+	size := (8 + pad(((int(KeycodeCount) * int(KeysymsPerKeycode)) * 4)))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 100 // request opcode
+	b += 1
+
+	buf[b] = KeycodeCount
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	buf[b] = byte(FirstKeycode)
+	b += 1
+
+	buf[b] = KeysymsPerKeycode
+	b += 1
+
+	b += 2 // padding
+
+	for i := 0; i < int((int(KeycodeCount) * int(KeysymsPerKeycode))); i++ {
+		Put32(buf[b:], uint32(Keysyms[i]))
+		b += 4
+	}
+	b = pad(b)
+
+	c.sendRequest(false, buf)
+}
+
+// Request GetKeyboardMapping
+// size: 6
+func (c *Conn) GetKeyboardMapping(FirstKeycode Keycode, Count byte) (*GetKeyboardMappingReply, error) {
+	return c.GetKeyboardMappingReply(c.GetKeyboardMappingRequest(FirstKeycode, Count))
+}
+
+// Write request to wire for GetKeyboardMapping
+func (c *Conn) GetKeyboardMappingRequest(FirstKeycode Keycode, Count byte) *Cookie {
+	size := 6
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 101 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	buf[b] = byte(FirstKeycode)
+	b += 1
+
+	buf[b] = Count
+	b += 1
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for GetKeyboardMapping
+// size: (32 + pad((int(Length) * 4)))
+type GetKeyboardMappingReply struct {
+	Sequence          uint16
+	Length            uint32
+	KeysymsPerKeycode byte
+	// padding: 24 bytes
+	Keysyms []Keysym // size: pad((int(Length) * 4))
+}
+
+// Read reply GetKeyboardMapping
+func (c *Conn) GetKeyboardMappingReply(cook *Cookie) (*GetKeyboardMappingReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(GetKeyboardMappingReply)
+	b := 1 // skip reply determinant
+
+	v.KeysymsPerKeycode = buf[b]
+	b += 1
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	b += 24 // padding
+
+	v.Keysyms = make([]Keysym, v.Length)
+	for i := 0; i < int(v.Length); i++ {
+		v.Keysyms[i] = Keysym(Get32(buf[b:]))
+		b += 4
+	}
+	b = pad(b)
+
+	return v, nil
+}
+
+// Request ChangeKeyboardControl
+// size: (4 + (4 + pad((4 * popCount(int(ValueMask))))))
+// Write request to wire for ChangeKeyboardControl
+func (c *Conn) ChangeKeyboardControl(ValueMask uint32, ValueList []uint32) {
+	size := (4 + (4 + pad((4 * popCount(int(ValueMask))))))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 102 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], ValueMask)
+	b += 4
+	for i := 0; i < popCount(int(ValueMask)); i++ {
+		Put32(buf[b:], ValueList[i])
+		b += 4
+	}
+	b = pad(b)
+
+	c.sendRequest(false, buf)
+}
+
+// Request GetKeyboardControl
+// size: 3
+func (c *Conn) GetKeyboardControl() (*GetKeyboardControlReply, error) {
+	return c.GetKeyboardControlReply(c.GetKeyboardControlRequest())
+}
+
+// Write request to wire for GetKeyboardControl
+func (c *Conn) GetKeyboardControlRequest() *Cookie {
+	size := 3
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 103 // request opcode
+	b += 1
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for GetKeyboardControl
+// size: (20 + pad(32))
+type GetKeyboardControlReply struct {
+	Sequence         uint16
+	Length           uint32
+	GlobalAutoRepeat byte
+	LedMask          uint32
+	KeyClickPercent  byte
+	BellPercent      byte
+	BellPitch        uint16
+	BellDuration     uint16
+	// padding: 2 bytes
+	AutoRepeats []byte // size: pad(32)
+}
+
+// Read reply GetKeyboardControl
+func (c *Conn) GetKeyboardControlReply(cook *Cookie) (*GetKeyboardControlReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(GetKeyboardControlReply)
+	b := 1 // skip reply determinant
+
+	v.GlobalAutoRepeat = buf[b]
+	b += 1
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.LedMask = Get32(buf[b:])
+	b += 4
+
+	v.KeyClickPercent = buf[b]
+	b += 1
+
+	v.BellPercent = buf[b]
+	b += 1
+
+	v.BellPitch = Get16(buf[b:])
+	b += 2
+
+	v.BellDuration = Get16(buf[b:])
+	b += 2
+
+	b += 2 // padding
+
+	v.AutoRepeats = make([]byte, 32)
+	copy(v.AutoRepeats[:32], buf[b:])
+	b += pad(int(32))
+
+	return v, nil
+}
+
+// Request Bell
+// size: 4
+// Write request to wire for Bell
+func (c *Conn) Bell(Percent int8) {
+	size := 4
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 104 // request opcode
+	b += 1
+
+	buf[b] = byte(Percent)
+	b += 1
+
+	c.sendRequest(false, buf)
+}
+
+// Request ChangePointerControl
+// size: 12
+// Write request to wire for ChangePointerControl
+func (c *Conn) ChangePointerControl(AccelerationNumerator int16, AccelerationDenominator int16, Threshold int16, DoAcceleration bool, DoThreshold bool) {
+	size := 12
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 105 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put16(buf[b:], uint16(AccelerationNumerator))
+	b += 2
+
+	Put16(buf[b:], uint16(AccelerationDenominator))
+	b += 2
+
+	Put16(buf[b:], uint16(Threshold))
+	b += 2
+
+	if DoAcceleration {
+		buf[b] = 1
+	} else {
+		buf[b] = 0
+	}
+	b += 1
+
+	if DoThreshold {
+		buf[b] = 1
+	} else {
+		buf[b] = 0
+	}
+	b += 1
+
+	c.sendRequest(false, buf)
+}
+
+// Request GetPointerControl
+// size: 3
+func (c *Conn) GetPointerControl() (*GetPointerControlReply, error) {
+	return c.GetPointerControlReply(c.GetPointerControlRequest())
+}
+
+// Write request to wire for GetPointerControl
+func (c *Conn) GetPointerControlRequest() *Cookie {
+	size := 3
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 106 // request opcode
+	b += 1
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for GetPointerControl
+// size: 32
+type GetPointerControlReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	AccelerationNumerator   uint16
+	AccelerationDenominator uint16
+	Threshold               uint16
+	// padding: 18 bytes
+}
+
+// Read reply GetPointerControl
+func (c *Conn) GetPointerControlReply(cook *Cookie) (*GetPointerControlReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(GetPointerControlReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.AccelerationNumerator = Get16(buf[b:])
+	b += 2
+
+	v.AccelerationDenominator = Get16(buf[b:])
+	b += 2
+
+	v.Threshold = Get16(buf[b:])
+	b += 2
+
+	b += 18 // padding
+
+	return v, nil
+}
+
+// Request SetScreenSaver
+// size: 10
+// Write request to wire for SetScreenSaver
+func (c *Conn) SetScreenSaver(Timeout int16, Interval int16, PreferBlanking byte, AllowExposures byte) {
+	size := 10
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 107 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put16(buf[b:], uint16(Timeout))
+	b += 2
+
+	Put16(buf[b:], uint16(Interval))
+	b += 2
+
+	buf[b] = PreferBlanking
+	b += 1
+
+	buf[b] = AllowExposures
+	b += 1
+
+	c.sendRequest(false, buf)
+}
+
+// Request GetScreenSaver
+// size: 3
+func (c *Conn) GetScreenSaver() (*GetScreenSaverReply, error) {
+	return c.GetScreenSaverReply(c.GetScreenSaverRequest())
+}
+
+// Write request to wire for GetScreenSaver
+func (c *Conn) GetScreenSaverRequest() *Cookie {
+	size := 3
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 108 // request opcode
+	b += 1
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for GetScreenSaver
+// size: 32
+type GetScreenSaverReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	Timeout        uint16
+	Interval       uint16
+	PreferBlanking byte
+	AllowExposures byte
+	// padding: 18 bytes
+}
+
+// Read reply GetScreenSaver
+func (c *Conn) GetScreenSaverReply(cook *Cookie) (*GetScreenSaverReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(GetScreenSaverReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.Timeout = Get16(buf[b:])
+	b += 2
+
+	v.Interval = Get16(buf[b:])
+	b += 2
+
+	v.PreferBlanking = buf[b]
+	b += 1
+
+	v.AllowExposures = buf[b]
+	b += 1
+
+	b += 18 // padding
+
+	return v, nil
+}
+
+// Request ChangeHosts
+// size: (8 + pad((int(AddressLen) * 1)))
+// Write request to wire for ChangeHosts
+func (c *Conn) ChangeHosts(Mode byte, Family byte, AddressLen uint16, Address []byte) {
+	size := (8 + pad((int(AddressLen) * 1)))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 109 // request opcode
+	b += 1
+
+	buf[b] = Mode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	buf[b] = Family
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], AddressLen)
+	b += 2
+
+	copy(buf[b:], Address[:AddressLen])
+	b += pad(int(AddressLen))
+
+	c.sendRequest(false, buf)
+}
+
+// Request ListHosts
+// size: 3
+func (c *Conn) ListHosts() (*ListHostsReply, error) {
+	return c.ListHostsReply(c.ListHostsRequest())
+}
+
+// Write request to wire for ListHosts
+func (c *Conn) ListHostsRequest() *Cookie {
+	size := 3
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 110 // request opcode
+	b += 1
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for ListHosts
+// size: (32 + HostListSize(Hosts))
+type ListHostsReply struct {
+	Sequence uint16
+	Length   uint32
+	Mode     byte
+	HostsLen uint16
+	// padding: 22 bytes
+	Hosts []Host // size: HostListSize(Hosts)
+}
+
+// Read reply ListHosts
+func (c *Conn) ListHostsReply(cook *Cookie) (*ListHostsReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(ListHostsReply)
+	b := 1 // skip reply determinant
+
+	v.Mode = buf[b]
+	b += 1
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.HostsLen = Get16(buf[b:])
+	b += 2
+
+	b += 22 // padding
+
+	v.Hosts = make([]Host, v.HostsLen)
+	b += ReadHostList(buf[b:], v.Hosts)
+
+	return v, nil
+}
+
+// Request SetAccessControl
+// size: 4
+// Write request to wire for SetAccessControl
+func (c *Conn) SetAccessControl(Mode byte) {
+	size := 4
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 111 // request opcode
+	b += 1
+
+	buf[b] = Mode
+	b += 1
+
+	c.sendRequest(false, buf)
+}
+
+// Request SetCloseDownMode
+// size: 4
+// Write request to wire for SetCloseDownMode
+func (c *Conn) SetCloseDownMode(Mode byte) {
+	size := 4
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 112 // request opcode
+	b += 1
+
+	buf[b] = Mode
+	b += 1
+
+	c.sendRequest(false, buf)
+}
+
+// Request KillClient
+// size: 8
+// Write request to wire for KillClient
+func (c *Conn) KillClient(Resource uint32) {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 113 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], Resource)
+	b += 4
+
+	c.sendRequest(false, buf)
+}
+
+// Request RotateProperties
+// size: (12 + pad((int(AtomsLen) * 4)))
+// Write request to wire for RotateProperties
+func (c *Conn) RotateProperties(Window Id, AtomsLen uint16, Delta int16, Atoms []Id) {
+	size := (12 + pad((int(AtomsLen) * 4)))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 114 // request opcode
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Window))
+	b += 4
+
+	Put16(buf[b:], AtomsLen)
+	b += 2
+
+	Put16(buf[b:], uint16(Delta))
+	b += 2
+
+	for i := 0; i < int(AtomsLen); i++ {
+		Put32(buf[b:], uint32(Atoms[i]))
+		b += 4
+	}
+	b = pad(b)
+
+	c.sendRequest(false, buf)
+}
+
+// Request ForceScreenSaver
+// size: 4
+// Write request to wire for ForceScreenSaver
+func (c *Conn) ForceScreenSaver(Mode byte) {
+	size := 4
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 115 // request opcode
+	b += 1
+
+	buf[b] = Mode
+	b += 1
+
+	c.sendRequest(false, buf)
+}
+
+// Request SetPointerMapping
+// size: (4 + pad((int(MapLen) * 1)))
+func (c *Conn) SetPointerMapping(MapLen byte, Map []byte) (*SetPointerMappingReply, error) {
+	return c.SetPointerMappingReply(c.SetPointerMappingRequest(MapLen, Map))
+}
+
+// Write request to wire for SetPointerMapping
+func (c *Conn) SetPointerMappingRequest(MapLen byte, Map []byte) *Cookie {
+	size := (4 + pad((int(MapLen) * 1)))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 116 // request opcode
+	b += 1
+
+	buf[b] = MapLen
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	copy(buf[b:], Map[:MapLen])
+	b += pad(int(MapLen))
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for SetPointerMapping
+// size: 8
+type SetPointerMappingReply struct {
+	Sequence uint16
+	Length   uint32
+	Status   byte
+}
+
+// Read reply SetPointerMapping
+func (c *Conn) SetPointerMappingReply(cook *Cookie) (*SetPointerMappingReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(SetPointerMappingReply)
+	b := 1 // skip reply determinant
+
+	v.Status = buf[b]
+	b += 1
+
+	return v, nil
+}
+
+// Request GetPointerMapping
+// size: 3
+func (c *Conn) GetPointerMapping() (*GetPointerMappingReply, error) {
+	return c.GetPointerMappingReply(c.GetPointerMappingRequest())
+}
+
+// Write request to wire for GetPointerMapping
+func (c *Conn) GetPointerMappingRequest() *Cookie {
+	size := 3
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 117 // request opcode
+	b += 1
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for GetPointerMapping
+// size: (32 + pad((int(MapLen) * 1)))
+type GetPointerMappingReply struct {
+	Sequence uint16
+	Length   uint32
+	MapLen   byte
+	// padding: 24 bytes
+	Map []byte // size: pad((int(MapLen) * 1))
+}
+
+// Read reply GetPointerMapping
+func (c *Conn) GetPointerMappingReply(cook *Cookie) (*GetPointerMappingReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(GetPointerMappingReply)
+	b := 1 // skip reply determinant
+
+	v.MapLen = buf[b]
+	b += 1
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	b += 24 // padding
+
+	v.Map = make([]byte, v.MapLen)
+	copy(v.Map[:v.MapLen], buf[b:])
+	b += pad(int(v.MapLen))
+
+	return v, nil
+}
+
+// Request SetModifierMapping
+// size: (4 + pad(((int(KeycodesPerModifier) * 8) * 1)))
+func (c *Conn) SetModifierMapping(KeycodesPerModifier byte, Keycodes []Keycode) (*SetModifierMappingReply, error) {
+	return c.SetModifierMappingReply(c.SetModifierMappingRequest(KeycodesPerModifier, Keycodes))
+}
+
+// Write request to wire for SetModifierMapping
+func (c *Conn) SetModifierMappingRequest(KeycodesPerModifier byte, Keycodes []Keycode) *Cookie {
+	size := (4 + pad(((int(KeycodesPerModifier) * 8) * 1)))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 118 // request opcode
+	b += 1
+
+	buf[b] = KeycodesPerModifier
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	for i := 0; i < int((int(KeycodesPerModifier) * 8)); i++ {
+		buf[b] = byte(Keycodes[i])
+		b += 1
+	}
+	b = pad(b)
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for SetModifierMapping
+// size: 8
+type SetModifierMappingReply struct {
+	Sequence uint16
+	Length   uint32
+	Status   byte
+}
+
+// Read reply SetModifierMapping
+func (c *Conn) SetModifierMappingReply(cook *Cookie) (*SetModifierMappingReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(SetModifierMappingReply)
+	b := 1 // skip reply determinant
+
+	v.Status = buf[b]
+	b += 1
+
+	return v, nil
+}
+
+// Request GetModifierMapping
+// size: 3
+func (c *Conn) GetModifierMapping() (*GetModifierMappingReply, error) {
+	return c.GetModifierMappingReply(c.GetModifierMappingRequest())
+}
+
+// Write request to wire for GetModifierMapping
+func (c *Conn) GetModifierMappingRequest() *Cookie {
+	size := 3
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 119 // request opcode
+	b += 1
+
+	return c.sendRequest(true, buf)
+}
+
+// Request reply for GetModifierMapping
+// size: (32 + pad(((int(KeycodesPerModifier) * 8) * 1)))
+type GetModifierMappingReply struct {
+	Sequence            uint16
+	Length              uint32
+	KeycodesPerModifier byte
+	// padding: 24 bytes
+	Keycodes []Keycode // size: pad(((int(KeycodesPerModifier) * 8) * 1))
+}
+
+// Read reply GetModifierMapping
+func (c *Conn) GetModifierMappingReply(cook *Cookie) (*GetModifierMappingReply, error) {
+	buf, err := c.waitForReply(cook)
+	if err != nil {
+		return nil, err
+	}
+
+	v := new(GetModifierMappingReply)
+	b := 1 // skip reply determinant
+
+	v.KeycodesPerModifier = buf[b]
+	b += 1
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	b += 24 // padding
+
+	v.Keycodes = make([]Keycode, (int(v.KeycodesPerModifier) * 8))
+	for i := 0; i < int((int(v.KeycodesPerModifier) * 8)); i++ {
+		v.Keycodes[i] = Keycode(buf[b])
+		b += 1
+	}
+	b = pad(b)
+
+	return v, nil
+}
+
+// Request NoOperation
+// size: 3
+// Write request to wire for NoOperation
+func (c *Conn) NoOperation() {
+	size := 3
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 127 // request opcode
+	b += 1
+
+	c.sendRequest(false, buf)
+}
-- 
cgit v1.2.3-70-g09d2


From b6715f376f5ea3efb58146c58924dcc7b1536181 Mon Sep 17 00:00:00 2001
From: "Andrew Gallant (Ocelot)" <Andrew.Gallant@tufts.edu>
Date: Sat, 5 May 2012 18:21:48 -0400
Subject: fixing bugs related mostly to extension handling

---
 nexgb/xgbgen/expression.go       |  6 ++--
 nexgb/xgbgen/field.go            | 12 +++----
 nexgb/xgbgen/go.go               |  6 ++--
 nexgb/xgbgen/go_error.go         | 14 ++++++---
 nexgb/xgbgen/go_event.go         | 51 ++++++++++++++++++++++++++++++
 nexgb/xgbgen/go_request_reply.go | 67 ++++++++++++++++++++++++++--------------
 nexgb/xgbgen/representation.go   |  7 ++++-
 nexgb/xgbgen/translation.go      |  2 +-
 nexgb/xgbgen/type.go             |  2 +-
 9 files changed, 125 insertions(+), 42 deletions(-)

(limited to 'nexgb/xgbgen/type.go')

diff --git a/nexgb/xgbgen/expression.go b/nexgb/xgbgen/expression.go
index 6a8aa52..2350979 100644
--- a/nexgb/xgbgen/expression.go
+++ b/nexgb/xgbgen/expression.go
@@ -282,7 +282,7 @@ func (e *FieldRef) String() string {
 }
 
 func (e *FieldRef) Initialize(p *Protocol) {
-	e.Name = SrcName(e.Name)
+	e.Name = SrcName(p, e.Name)
 }
 
 type EnumRef struct {
@@ -309,7 +309,7 @@ func (e *EnumRef) String() string {
 
 func (e *EnumRef) Initialize(p *Protocol) {
 	e.EnumKind = e.EnumKind.(*Translation).RealType(p)
-	e.EnumItem = SrcName(e.EnumItem)
+	e.EnumItem = SrcName(p, e.EnumItem)
 }
 
 type SumOf struct {
@@ -337,5 +337,5 @@ func (e *SumOf) String() string {
 }
 
 func (e *SumOf) Initialize(p *Protocol) {
-	e.Name = SrcName(e.Name)
+	e.Name = SrcName(p, e.Name)
 }
diff --git a/nexgb/xgbgen/field.go b/nexgb/xgbgen/field.go
index ddc2028..5041f77 100644
--- a/nexgb/xgbgen/field.go
+++ b/nexgb/xgbgen/field.go
@@ -47,7 +47,7 @@ type SingleField struct {
 }
 
 func (f *SingleField) Initialize(p *Protocol) {
-	f.srcName = SrcName(f.XmlName())
+	f.srcName = SrcName(p, f.XmlName())
 	f.Type = f.Type.(*Translation).RealType(p)
 }
 
@@ -138,7 +138,7 @@ func (f *ListField) Size() Size {
 }
 
 func (f *ListField) Initialize(p *Protocol) {
-	f.srcName = SrcName(f.XmlName())
+	f.srcName = SrcName(p, f.XmlName())
 	f.Type = f.Type.(*Translation).RealType(p)
 	if f.LengthExpr != nil {
 		f.LengthExpr.Initialize(p)
@@ -173,7 +173,7 @@ func (f *ExprField) Size() Size {
 }
 
 func (f *ExprField) Initialize(p *Protocol) {
-	f.srcName = SrcName(f.XmlName())
+	f.srcName = SrcName(p, f.XmlName())
 	f.Type = f.Type.(*Translation).RealType(p)
 	f.Expr.Initialize(p)
 }
@@ -230,8 +230,8 @@ func (f *ValueField) ListLength() Size {
 
 func (f *ValueField) Initialize(p *Protocol) {
 	f.MaskType = f.MaskType.(*Translation).RealType(p)
-	f.MaskName = SrcName(f.MaskName)
-	f.ListName = SrcName(f.ListName)
+	f.MaskName = SrcName(p, f.MaskName)
+	f.ListName = SrcName(p, f.ListName)
 }
 
 type SwitchField struct {
@@ -260,7 +260,7 @@ func (f *SwitchField) Size() Size {
 }
 
 func (f *SwitchField) Initialize(p *Protocol) {
-	f.Name = SrcName(f.Name)
+	f.Name = SrcName(p, f.Name)
 	f.Expr.Initialize(p)
 	for _, bitcase := range f.Bitcases {
 		bitcase.Expr.Initialize(p)
diff --git a/nexgb/xgbgen/go.go b/nexgb/xgbgen/go.go
index 771cfcf..df12e69 100644
--- a/nexgb/xgbgen/go.go
+++ b/nexgb/xgbgen/go.go
@@ -65,7 +65,8 @@ var NameMap = map[string]string{}
 
 // Base types
 func (b *Base) Define(c *Context) {
-	c.Putln("// Skipping definition for base type '%s'", SrcName(b.XmlName()))
+	c.Putln("// Skipping definition for base type '%s'",
+		SrcName(c.protocol, b.XmlName()))
 	c.Putln("")
 }
 
@@ -81,7 +82,8 @@ func (enum *Enum) Define(c *Context) {
 
 // Resource types
 func (res *Resource) Define(c *Context) {
-	c.Putln("// Skipping resource definition of '%s'", SrcName(res.XmlName()))
+	c.Putln("// Skipping resource definition of '%s'",
+		SrcName(c.protocol, res.XmlName()))
 	c.Putln("")
 }
 
diff --git a/nexgb/xgbgen/go_error.go b/nexgb/xgbgen/go_error.go
index 5a51064..152db8b 100644
--- a/nexgb/xgbgen/go_error.go
+++ b/nexgb/xgbgen/go_error.go
@@ -64,11 +64,15 @@ func (e *Error) ImplementsError(c *Context) {
 	c.Putln("}")
 	c.Putln("")
 	c.Putln("func (err %s) BadId() Id {", e.ErrType())
-	c.Putln("return Id(err.BadValue)")
+	if c.protocol.Name == "xproto" {
+		c.Putln("return Id(err.BadValue)")
+	} else {
+		c.Putln("return 0")
+	}
 	c.Putln("}")
 	c.Putln("")
 	c.Putln("func (err %s) Error() string {", e.ErrType())
-	FieldString(c, e.Fields, e.ErrConst())
+	ErrorFieldString(c, e.Fields, e.ErrConst())
 	c.Putln("}")
 	c.Putln("")
 }
@@ -119,14 +123,14 @@ func (e *ErrorCopy) ImplementsError(c *Context) {
 	c.Putln("}")
 	c.Putln("")
 	c.Putln("func (err %s) Error() string {", e.ErrType())
-	FieldString(c, e.Old.(*Error).Fields, e.ErrConst())
+	ErrorFieldString(c, e.Old.(*Error).Fields, e.ErrConst())
 	c.Putln("}")
 	c.Putln("")
 }
 
-// FieldString works for both Error and ErrorCopy. It assembles all of the
+// ErrorFieldString works for both Error and ErrorCopy. It assembles all of the
 // fields in an error and formats them into a single string.
-func FieldString(c *Context, fields []Field, errName string) {
+func ErrorFieldString(c *Context, fields []Field, errName string) {
 	c.Putln("fieldVals := make([]string, 0, %d)", len(fields))
 	c.Putln("fieldVals = append(fieldVals, \"NiceName: \" + err.NiceName)")
 	c.Putln("fieldVals = append(fieldVals, " +
diff --git a/nexgb/xgbgen/go_event.go b/nexgb/xgbgen/go_event.go
index 41f9320..9bc6dfe 100644
--- a/nexgb/xgbgen/go_event.go
+++ b/nexgb/xgbgen/go_event.go
@@ -1,5 +1,9 @@
 package main
 
+import (
+	"fmt"
+)
+
 // Event types
 func (e *Event) Define(c *Context) {
 	c.Putln("// Event definition %s (%d)", e.SrcName(), e.Number)
@@ -36,6 +40,10 @@ func (e *Event) Define(c *Context) {
 	}
 	c.Putln("}")
 	c.Putln("")
+	c.Putln("func (v %s) String() string {", e.EvType())
+	EventFieldString(c, e.Fields, e.SrcName())
+	c.Putln("}")
+	c.Putln("")
 
 	// Let's the XGB event loop read this event.
 	c.Putln("func init() {")
@@ -115,6 +123,10 @@ func (e *EventCopy) Define(c *Context) {
 	}
 	c.Putln("}")
 	c.Putln("")
+	c.Putln("func (v %s) String() string {", e.EvType())
+	EventFieldString(c, e.Old.(*Event).Fields, e.SrcName())
+	c.Putln("}")
+	c.Putln("")
 
 	// Let's the XGB event loop read this event.
 	c.Putln("func init() {")
@@ -137,3 +149,42 @@ func (e *EventCopy) Write(c *Context) {
 	c.Putln("}")
 	c.Putln("")
 }
+
+// EventFieldString works for both Event and EventCopy. It assembles all of the
+// fields in an event and formats them into a single string.
+func EventFieldString(c *Context, fields []Field, evName string) {
+	c.Putln("fieldVals := make([]string, 0, %d)", len(fields))
+	if evName != "KeymapNotify" {
+		c.Putln("fieldVals = append(fieldVals, " +
+			"sprintf(\"Sequence: %s\", v.Sequence))", "%d")
+	}
+	for _, field := range fields {
+		switch f := field.(type) {
+		case *PadField:
+			continue
+		case *SingleField:
+			switch f.Type.(type) {
+			case *Base:
+			case *Resource:
+			case *TypeDef:
+			default: continue
+			}
+
+			switch field.SrcType() {
+			case "string":
+				format := fmt.Sprintf("sprintf(\"%s: %s\", v.%s)",
+					field.SrcName(), "%s", field.SrcName())
+				c.Putln("fieldVals = append(fieldVals, %s)", format)
+			case "bool":
+				format := fmt.Sprintf("sprintf(\"%s: %s\", v.%s)",
+					field.SrcName(), "%t", field.SrcName())
+				c.Putln("fieldVals = append(fieldVals, %s)", format)
+			default:
+				format := fmt.Sprintf("sprintf(\"%s: %s\", v.%s)",
+					field.SrcName(), "%d", field.SrcName())
+				c.Putln("fieldVals = append(fieldVals, %s)", format)
+			}
+		}
+	}
+	c.Putln("return \"%s {\" + stringsJoin(fieldVals, \", \") + \"}\"", evName)
+}
diff --git a/nexgb/xgbgen/go_request_reply.go b/nexgb/xgbgen/go_request_reply.go
index 00c48f9..e64e2a2 100644
--- a/nexgb/xgbgen/go_request_reply.go
+++ b/nexgb/xgbgen/go_request_reply.go
@@ -8,21 +8,24 @@ import (
 func (r *Request) Define(c *Context) {
 	c.Putln("// Request %s", r.SrcName())
 	c.Putln("// size: %s", r.Size(c))
-	c.Putln("type %s cookie", r.CookieName())
+	c.Putln("type %s struct {", r.CookieName())
+	c.Putln("*cookie")
+	c.Putln("}")
+	c.Putln("")
 	if r.Reply != nil {
 		c.Putln("func (c *Conn) %s(%s) %s {",
 			r.SrcName(), r.ParamNameTypes(), r.CookieName())
 		c.Putln("cookie := c.newCookie(true, true)")
-		c.Putln("c.newRequest(%s(%s), cookie)", r.ReqName(), r.ParamNames())
-		c.Putln("return %s(cookie)", r.CookieName())
+		c.Putln("c.newRequest(c.%s(%s), cookie)", r.ReqName(), r.ParamNames())
+		c.Putln("return %s{cookie}", r.CookieName())
 		c.Putln("}")
 		c.Putln("")
 
 		c.Putln("func (c *Conn) %sUnchecked(%s) %s {",
 			r.SrcName(), r.ParamNameTypes(), r.CookieName())
 		c.Putln("cookie := c.newCookie(false, true)")
-		c.Putln("c.newRequest(%s(%s), cookie)", r.ReqName(), r.ParamNames())
-		c.Putln("return %s(cookie)", r.CookieName())
+		c.Putln("c.newRequest(c.%s(%s), cookie)", r.ReqName(), r.ParamNames())
+		c.Putln("return %s{cookie}", r.CookieName())
 		c.Putln("}")
 		c.Putln("")
 
@@ -32,20 +35,24 @@ func (r *Request) Define(c *Context) {
 		c.Putln("func (c *Conn) %s(%s) %s {",
 			r.SrcName(), r.ParamNameTypes(), r.CookieName())
 		c.Putln("cookie := c.newCookie(false, false)")
-		c.Putln("c.newRequest(%s(%s), cookie)", r.ReqName(), r.ParamNames())
-		c.Putln("return %s(cookie)", r.CookieName())
+		c.Putln("c.newRequest(c.%s(%s), cookie)", r.ReqName(), r.ParamNames())
+		c.Putln("return %s{cookie}", r.CookieName())
 		c.Putln("}")
 		c.Putln("")
 
 		c.Putln("func (c *Conn) %sChecked(%s) %s {",
 			r.SrcName(), r.ParamNameTypes(), r.CookieName())
 		c.Putln("cookie := c.newCookie(true, false)")
-		c.Putln("c.newRequest(%s(%s), cookie)", r.ReqName(), r.ParamNames())
-		c.Putln("return %s(cookie)", r.CookieName())
+		c.Putln("c.newRequest(c.%s(%s), cookie)", r.ReqName(), r.ParamNames())
+		c.Putln("return %s{cookie}", r.CookieName())
 		c.Putln("}")
 		c.Putln("")
 	}
 
+	c.Putln("func (cook %s) Check() error {", r.CookieName())
+	c.Putln("return cook.check()")
+	c.Putln("}")
+	c.Putln("")
 	r.WriteRequest(c)
 }
 
@@ -64,10 +71,13 @@ func (r *Request) ReadReply(c *Context) {
 	c.Putln("// Waits and reads reply data from request %s", r.SrcName())
 	c.Putln("func (cook %s) Reply() (*%s, error) {",
 		r.CookieName(), r.ReplyTypeName())
-		c.Putln("buf, err := cookie(cook).reply()")
+		c.Putln("buf, err := cook.reply()")
 		c.Putln("if err != nil {")
 		c.Putln("return nil, err")
 		c.Putln("}")
+		c.Putln("if buf == nil {")
+		c.Putln("return nil, nil")
+		c.Putln("}")
 		c.Putln("return %s(buf), nil", r.ReplyName())
 	c.Putln("}")
 	c.Putln("")
@@ -79,7 +89,9 @@ func (r *Request) ReadReply(c *Context) {
 	c.Putln("b := 1 // skip reply determinant")
 	c.Putln("")
 	for i, field := range r.Reply.Fields {
-		if i == 1 {
+		field.Read(c, "v.")
+		c.Putln("")
+		if i == 0 {
 			c.Putln("v.Sequence = Get16(buf[b:])")
 			c.Putln("b += 2")
 			c.Putln("")
@@ -87,8 +99,6 @@ func (r *Request) ReadReply(c *Context) {
 			c.Putln("b += 4")
 			c.Putln("")
 		}
-		field.Read(c, "v.")
-		c.Putln("")
 	}
 	c.Putln("return v")
 	c.Putln("}")
@@ -96,30 +106,41 @@ func (r *Request) ReadReply(c *Context) {
 }
 
 func (r *Request) WriteRequest(c *Context) {
+	writeSize := func() {
+		c.Putln("Put16(buf[b:], uint16(size / 4)) "+
+			"// write request size in 4-byte units")
+		c.Putln("b += 2")
+		c.Putln("")
+	}
 	c.Putln("// Write request to wire for %s", r.SrcName())
-	c.Putln("func %s(%s) []byte {", r.ReqName(), r.ParamNameTypes())
+	c.Putln("func (c *Conn) %s(%s) []byte {", r.ReqName(), r.ParamNameTypes())
 	c.Putln("size := %s", r.Size(c))
 	c.Putln("b := 0")
 	c.Putln("buf := make([]byte, size)")
 	c.Putln("")
-	c.Putln("buf[b] = %d // request opcode", r.Opcode)
-	c.Putln("b += 1")
-	c.Putln("")
 	if strings.ToLower(c.protocol.Name) != "xproto" {
 		c.Putln("buf[b] = c.extensions[\"%s\"]",
 			strings.ToUpper(c.protocol.ExtXName))
 		c.Putln("b += 1")
 		c.Putln("")
 	}
-	for i, field := range r.Fields {
-		if i == 1 {
-			c.Putln("Put16(buf[b:], uint16(size / 4)) "+
-				"// write request size in 4-byte units")
-			c.Putln("b += 2")
-			c.Putln("")
+	c.Putln("buf[b] = %d // request opcode", r.Opcode)
+	c.Putln("b += 1")
+	c.Putln("")
+	if len(r.Fields) == 0 {
+		if strings.ToLower(c.protocol.Name) == "xproto" {
+			c.Putln("b += 1 // padding")
 		}
+		writeSize()
+	} else if strings.ToLower(c.protocol.Name) != "xproto" {
+		writeSize()
+	}
+	for i, field := range r.Fields {
 		field.Write(c, "")
 		c.Putln("")
+		if i == 0 && strings.ToLower(c.protocol.Name) == "xproto" {
+			writeSize()
+		}
 	}
 	c.Putln("return buf")
 	c.Putln("}")
diff --git a/nexgb/xgbgen/representation.go b/nexgb/xgbgen/representation.go
index be7accd..62a3eb2 100644
--- a/nexgb/xgbgen/representation.go
+++ b/nexgb/xgbgen/representation.go
@@ -3,6 +3,7 @@ package main
 import (
 	"fmt"
 	"log"
+	"strings"
 	"unicode"
 )
 
@@ -41,7 +42,11 @@ type Request struct {
 }
 
 func (r *Request) Initialize(p *Protocol) {
-	r.srcName = SrcName(r.xmlName)
+	r.srcName = SrcName(p, r.xmlName)
+	if p.Name != "xproto" {
+		r.srcName = strings.Title(strings.ToLower(p.Name)) + r.srcName
+	}
+
 	if r.Reply != nil {
 		r.Reply.Initialize(p)
 	}
diff --git a/nexgb/xgbgen/translation.go b/nexgb/xgbgen/translation.go
index fe5a52b..b650bc4 100644
--- a/nexgb/xgbgen/translation.go
+++ b/nexgb/xgbgen/translation.go
@@ -373,7 +373,7 @@ func (x *XMLBitcase) Translate() *Bitcase {
 
 // SrcName is used to translate any identifier into a Go name.
 // Mostly used for fields, but used in a couple other places too (enum items).
-func SrcName(name string) string {
+func SrcName(p *Protocol, name string) string {
 	// If it's in the name map, use that translation.
 	if newn, ok := NameMap[name]; ok {
 		return newn
diff --git a/nexgb/xgbgen/type.go b/nexgb/xgbgen/type.go
index 3498463..521f67e 100644
--- a/nexgb/xgbgen/type.go
+++ b/nexgb/xgbgen/type.go
@@ -123,7 +123,7 @@ func (enum *Enum) Size() Size {
 func (enum *Enum) Initialize(p *Protocol) {
 	enum.srcName = TypeSrcName(p, enum)
 	for _, item := range enum.Items {
-		item.srcName = SrcName(item.xmlName)
+		item.srcName = SrcName(p, item.xmlName)
 		if item.Expr != nil {
 			item.Expr.Initialize(p)
 		}
-- 
cgit v1.2.3-70-g09d2


From 4b20ffaf4f4cc756832a6d064d5dfe182f16b0e9 Mon Sep 17 00:00:00 2001
From: Andrew Gallant <jamslam@gmail.com>
Date: Sun, 11 Aug 2013 20:42:36 -0400
Subject: Updated to work with new xproto XML files.

Namely, the "doc" element is ignored. Also, I've sorted everything
before output so that diff isn't completely useless.
---
 nexgb/xgbgen/context.go       |  5 +++++
 nexgb/xgbgen/protocol.go      |  6 ++++++
 nexgb/xgbgen/request_reply.go |  6 ++++++
 nexgb/xgbgen/translation.go   | 28 ++++++++++++++++++----------
 nexgb/xgbgen/type.go          | 10 ++++++++++
 5 files changed, 45 insertions(+), 10 deletions(-)

(limited to 'nexgb/xgbgen/type.go')

diff --git a/nexgb/xgbgen/context.go b/nexgb/xgbgen/context.go
index c40313f..697413e 100644
--- a/nexgb/xgbgen/context.go
+++ b/nexgb/xgbgen/context.go
@@ -5,6 +5,7 @@ import (
 	"encoding/xml"
 	"fmt"
 	"log"
+	"sort"
 	"time"
 )
 
@@ -70,6 +71,8 @@ func (c *Context) Morph(xmlBytes []byte) {
 	if c.protocol.isExt() {
 		c.Putln("\"github.com/BurntSushi/xgb/xproto\"")
 	}
+
+	sort.Sort(Protocols(c.protocol.Imports))
 	for _, imp := range c.protocol.Imports {
 		// We always import xproto, so skip it if it's explicitly imported
 		if imp.Name == "xproto" {
@@ -142,6 +145,8 @@ func (c *Context) Morph(xmlBytes []byte) {
 	}
 
 	// Now write Go source code
+	sort.Sort(Types(c.protocol.Types))
+	sort.Sort(Requests(c.protocol.Requests))
 	for _, typ := range c.protocol.Types {
 		typ.Define(c)
 	}
diff --git a/nexgb/xgbgen/protocol.go b/nexgb/xgbgen/protocol.go
index d56663d..433f4e2 100644
--- a/nexgb/xgbgen/protocol.go
+++ b/nexgb/xgbgen/protocol.go
@@ -22,6 +22,12 @@ type Protocol struct {
 	Requests []*Request
 }
 
+type Protocols []*Protocol
+
+func (ps Protocols) Len() int           { return len(ps) }
+func (ps Protocols) Swap(i, j int)      { ps[i], ps[j] = ps[j], ps[i] }
+func (ps Protocols) Less(i, j int) bool { return ps[i].ExtName < ps[j].ExtName }
+
 // Initialize traverses all structures, looks for 'Translation' type,
 // and looks up the real type in the namespace. It also sets the source
 // name for all relevant fields/structures.
diff --git a/nexgb/xgbgen/request_reply.go b/nexgb/xgbgen/request_reply.go
index b8afe48..11a4e44 100644
--- a/nexgb/xgbgen/request_reply.go
+++ b/nexgb/xgbgen/request_reply.go
@@ -17,6 +17,12 @@ type Request struct {
 	Reply   *Reply  // A reply, if one exists for this request.
 }
 
+type Requests []*Request
+
+func (rs Requests) Len() int           { return len(rs) }
+func (rs Requests) Swap(i, j int)      { rs[i], rs[j] = rs[j], rs[i] }
+func (rs Requests) Less(i, j int) bool { return rs[i].xmlName < rs[j].xmlName }
+
 // Initialize creates the proper Go source name for this request.
 // It also initializes the reply if one exists, and all fields in this request.
 func (r *Request) Initialize(p *Protocol) {
diff --git a/nexgb/xgbgen/translation.go b/nexgb/xgbgen/translation.go
index 0123669..778304f 100644
--- a/nexgb/xgbgen/translation.go
+++ b/nexgb/xgbgen/translation.go
@@ -137,10 +137,13 @@ func (x *XMLEvent) Translate() *Event {
 		xmlName:    x.Name,
 		Number:     x.Number,
 		NoSequence: x.NoSequence,
-		Fields:     make([]Field, len(x.Fields)),
+		Fields:     make([]Field, 0, len(x.Fields)),
 	}
-	for i, field := range x.Fields {
-		ev.Fields[i] = field.Translate(ev)
+	for _, field := range x.Fields {
+		if field.XMLName.Local == "doc" {
+			continue
+		}
+		ev.Fields = append(ev.Fields, field.Translate(ev))
 	}
 	return ev
 }
@@ -200,11 +203,14 @@ func (x *XMLRequest) Translate() *Request {
 		xmlName: x.Name,
 		Opcode:  x.Opcode,
 		Combine: x.Combine,
-		Fields:  make([]Field, len(x.Fields)),
+		Fields:  make([]Field, 0, len(x.Fields)),
 		Reply:   x.Reply.Translate(),
 	}
-	for i, field := range x.Fields {
-		r.Fields[i] = field.Translate(r)
+	for _, field := range x.Fields {
+		if field.XMLName.Local == "doc" {
+			continue
+		}
+		r.Fields = append(r.Fields, field.Translate(r))
 	}
 
 	// Address bug (or legacy code) in QueryTextExtents.
@@ -229,10 +235,13 @@ func (x *XMLReply) Translate() *Reply {
 	}
 
 	r := &Reply{
-		Fields: make([]Field, len(x.Fields)),
+		Fields: make([]Field, 0, len(x.Fields)),
 	}
-	for i, field := range x.Fields {
-		r.Fields[i] = field.Translate(r)
+	for _, field := range x.Fields {
+		if field.XMLName.Local == "doc" {
+			continue
+		}
+		r.Fields = append(r.Fields, field.Translate(r))
 	}
 	return r
 }
@@ -380,7 +389,6 @@ func SrcName(p *Protocol, name string) string {
 	if newn, ok := NameMap[name]; ok {
 		return newn
 	}
-
 	return splitAndTitle(name)
 }
 
diff --git a/nexgb/xgbgen/type.go b/nexgb/xgbgen/type.go
index 521f67e..ded5be2 100644
--- a/nexgb/xgbgen/type.go
+++ b/nexgb/xgbgen/type.go
@@ -14,6 +14,16 @@ type Type interface {
 	Define(c *Context)
 }
 
+type Types []Type
+
+func (ts Types) Len() int      { return len(ts) }
+func (ts Types) Swap(i, j int) { ts[i], ts[j] = ts[j], ts[i] }
+func (ts Types) Less(i, j int) bool {
+	x1, x2 := ts[i].XmlName(), ts[j].XmlName()
+	s1, s2 := ts[i].SrcName(), ts[j].SrcName()
+	return (s1 == s2 && x1 < x2) || s1 < s2
+}
+
 // Translation is used *only* when transitioning from XML types to
 // our better representation. They are placeholders for the real types (below)
 // that will replace them.
-- 
cgit v1.2.3-70-g09d2


From a548d9d0f7b889627c43b18811357fad88760b2d Mon Sep 17 00:00:00 2001
From: aarzilli <alessandro.arzilli@gmail.com>
Date: Fri, 2 May 2014 15:09:23 +0200
Subject: Fix Issue #21: automatic calculation of alignment padding after lists

---
 nexgb/dri2/dri2.go               |   7 +-
 nexgb/examples/randr/main.go     |   2 +-
 nexgb/glx/glx.go                 |  93 ++++--------------
 nexgb/randr/randr.go             | 199 ++++++++++++++++++++++-----------------
 nexgb/record/record.go           |  35 ++++---
 nexgb/render/render.go           | 112 +++++++++++++---------
 nexgb/res/res.go                 |  16 ++--
 nexgb/xcmisc/xcmisc.go           |   1 -
 nexgb/xevie/xevie.go             |   2 +-
 nexgb/xf86dri/xf86dri.go         |   8 +-
 nexgb/xf86vidmode/xf86vidmode.go |  52 +++++-----
 nexgb/xfixes/xfixes.go           |  12 +--
 nexgb/xgbgen/aligngap.go         | 130 +++++++++++++++++++++++++
 nexgb/xgbgen/context.go          |   2 +
 nexgb/xgbgen/field.go            |  32 ++++---
 nexgb/xgbgen/go.go               |  18 +++-
 nexgb/xgbgen/go_list.go          |  10 +-
 nexgb/xgbgen/go_request_reply.go |  30 ++++--
 nexgb/xgbgen/go_struct.go        |   2 +-
 nexgb/xgbgen/request_reply.go    |  12 +--
 nexgb/xgbgen/size.go             |  13 +--
 nexgb/xgbgen/translation.go      |   2 +-
 nexgb/xgbgen/type.go             |  12 +--
 nexgb/xinerama/xinerama.go       |   2 +-
 nexgb/xprint/xprint.go           |  20 +---
 nexgb/xproto/xproto.go           | 169 ++++++++++++++++-----------------
 nexgb/xproto/xproto_test.go      |  17 ++++
 nexgb/xselinux/xselinux.go       |  20 ++--
 nexgb/xv/xv.go                   |  67 +++++++------
 nexgb/xvmc/xvmc.go               |   7 +-
 30 files changed, 630 insertions(+), 474 deletions(-)
 create mode 100644 nexgb/xgbgen/aligngap.go

(limited to 'nexgb/xgbgen/type.go')

diff --git a/nexgb/dri2/dri2.go b/nexgb/dri2/dri2.go
index 6cec3d0..5ad0306 100644
--- a/nexgb/dri2/dri2.go
+++ b/nexgb/dri2/dri2.go
@@ -76,7 +76,7 @@ func (v AttachFormat) Bytes() []byte {
 	xgb.Put32(buf[b:], v.Format)
 	b += 4
 
-	return buf
+	return buf[:b]
 }
 
 // AttachFormatListBytes writes a list of AttachFormat values to a byte slice.
@@ -281,7 +281,7 @@ func (v DRI2Buffer) Bytes() []byte {
 	xgb.Put32(buf[b:], v.Flags)
 	b += 4
 
-	return buf
+	return buf[:b]
 }
 
 // DRI2BufferListBytes writes a list of DRI2Buffer values to a byte slice.
@@ -567,7 +567,7 @@ func connectReply(buf []byte) *ConnectReply {
 
 	v.AlignmentPad = make([]byte, (((int(v.DriverNameLength) + 3) & -4) - int(v.DriverNameLength)))
 	copy(v.AlignmentPad[:(((int(v.DriverNameLength)+3)&-4)-int(v.DriverNameLength))], buf[b:])
-	b += xgb.Pad(int((((int(v.DriverNameLength) + 3) & -4) - int(v.DriverNameLength))))
+	b += int((((int(v.DriverNameLength) + 3) & -4) - int(v.DriverNameLength)))
 
 	{
 		byteString := make([]byte, v.DeviceNameLength)
@@ -914,7 +914,6 @@ func getBuffersRequest(c *xgb.Conn, Drawable xproto.Drawable, Count uint32, Atta
 		xgb.Put32(buf[b:], Attachments[i])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return buf
 }
diff --git a/nexgb/examples/randr/main.go b/nexgb/examples/randr/main.go
index 414ef8d..ac6fb7a 100644
--- a/nexgb/examples/randr/main.go
+++ b/nexgb/examples/randr/main.go
@@ -63,7 +63,7 @@ func main() {
 		if err != nil {
 			log.Fatal(err)
 		}
-		fmt.Printf("X: %d, Y: %d, Width: %d, Height: %d\n",
+		fmt.Printf("%v, X: %d, Y: %d, Width: %d, Height: %d\n",
 			info.X, info.Y, info.Width, info.Height)
 	}
 
diff --git a/nexgb/glx/glx.go b/nexgb/glx/glx.go
index 979d577..0951765 100644
--- a/nexgb/glx/glx.go
+++ b/nexgb/glx/glx.go
@@ -1097,7 +1097,6 @@ func areTexturesResidentReply(buf []byte) *AreTexturesResidentReply {
 		}
 		b += 1
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -1128,7 +1127,6 @@ func areTexturesResidentRequest(c *xgb.Conn, ContextTag ContextTag, N int32, Tex
 		xgb.Put32(buf[b:], Textures[i])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return buf
 }
@@ -1192,7 +1190,6 @@ func changeDrawableAttributesRequest(c *xgb.Conn, Drawable Drawable, NumAttribs
 		xgb.Put32(buf[b:], Attribs[i])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return buf
 }
@@ -1256,7 +1253,7 @@ func clientInfoRequest(c *xgb.Conn, MajorVersion uint32, MinorVersion uint32, St
 	b += 4
 
 	copy(buf[b:], String[:StrLen])
-	b += xgb.Pad(int(StrLen))
+	b += int(StrLen)
 
 	return buf
 }
@@ -1475,7 +1472,6 @@ func createContextAttribsARBRequest(c *xgb.Conn, Context Context, Fbconfig Fbcon
 		xgb.Put32(buf[b:], Attribs[i])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return buf
 }
@@ -1685,7 +1681,6 @@ func createPbufferRequest(c *xgb.Conn, Screen uint32, Fbconfig Fbconfig, Pbuffer
 		xgb.Put32(buf[b:], Attribs[i])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return buf
 }
@@ -1758,7 +1753,6 @@ func createPixmapRequest(c *xgb.Conn, Screen uint32, Fbconfig Fbconfig, Pixmap x
 		xgb.Put32(buf[b:], Attribs[i])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return buf
 }
@@ -1831,7 +1825,6 @@ func createWindowRequest(c *xgb.Conn, Screen uint32, Fbconfig Fbconfig, Window x
 		xgb.Put32(buf[b:], Attribs[i])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return buf
 }
@@ -1956,7 +1949,6 @@ func deleteQueriesARBRequest(c *xgb.Conn, ContextTag ContextTag, N int32, Ids []
 		xgb.Put32(buf[b:], Ids[i])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return buf
 }
@@ -2020,7 +2012,6 @@ func deleteTexturesRequest(c *xgb.Conn, ContextTag ContextTag, N int32, Textures
 		xgb.Put32(buf[b:], Textures[i])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return buf
 }
@@ -2714,7 +2705,6 @@ func genQueriesARBReply(buf []byte) *GenQueriesARBReply {
 		v.Data[i] = xgb.Get32(buf[b:])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -2812,7 +2802,6 @@ func genTexturesReply(buf []byte) *GenTexturesReply {
 		v.Data[i] = xgb.Get32(buf[b:])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -2929,7 +2918,6 @@ func getBooleanvReply(buf []byte) *GetBooleanvReply {
 		}
 		b += 1
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -3027,7 +3015,6 @@ func getClipPlaneReply(buf []byte) *GetClipPlaneReply {
 		v.Data[i] = Float64(xgb.Get64(buf[b:]))
 		b += 8
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -3129,7 +3116,7 @@ func getColorTableReply(buf []byte) *GetColorTableReply {
 
 	v.Data = make([]byte, (int(v.Length) * 4))
 	copy(v.Data[:(int(v.Length)*4)], buf[b:])
-	b += xgb.Pad(int((int(v.Length) * 4)))
+	b += int((int(v.Length) * 4))
 
 	return v
 }
@@ -3251,7 +3238,6 @@ func getColorTableParameterfvReply(buf []byte) *GetColorTableParameterfvReply {
 		v.Data[i] = Float32(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -3363,7 +3349,6 @@ func getColorTableParameterivReply(buf []byte) *GetColorTableParameterivReply {
 		v.Data[i] = int32(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -3468,7 +3453,7 @@ func getCompressedTexImageARBReply(buf []byte) *GetCompressedTexImageARBReply {
 
 	v.Data = make([]byte, (int(v.Length) * 4))
 	copy(v.Data[:(int(v.Length)*4)], buf[b:])
-	b += xgb.Pad(int((int(v.Length) * 4)))
+	b += int((int(v.Length) * 4))
 
 	return v
 }
@@ -3577,7 +3562,7 @@ func getConvolutionFilterReply(buf []byte) *GetConvolutionFilterReply {
 
 	v.Data = make([]byte, (int(v.Length) * 4))
 	copy(v.Data[:(int(v.Length)*4)], buf[b:])
-	b += xgb.Pad(int((int(v.Length) * 4)))
+	b += int((int(v.Length) * 4))
 
 	return v
 }
@@ -3699,7 +3684,6 @@ func getConvolutionParameterfvReply(buf []byte) *GetConvolutionParameterfvReply
 		v.Data[i] = Float32(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -3811,7 +3795,6 @@ func getConvolutionParameterivReply(buf []byte) *GetConvolutionParameterivReply
 		v.Data[i] = int32(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -3923,7 +3906,6 @@ func getDoublevReply(buf []byte) *GetDoublevReply {
 		v.Data[i] = Float64(xgb.Get64(buf[b:]))
 		b += 8
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -4025,7 +4007,6 @@ func getDrawableAttributesReply(buf []byte) *GetDrawableAttributesReply {
 		v.Attribs[i] = xgb.Get32(buf[b:])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -4216,7 +4197,6 @@ func getFBConfigsReply(buf []byte) *GetFBConfigsReply {
 		v.PropertyList[i] = xgb.Get32(buf[b:])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -4322,7 +4302,6 @@ func getFloatvReply(buf []byte) *GetFloatvReply {
 		v.Data[i] = Float32(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -4424,7 +4403,7 @@ func getHistogramReply(buf []byte) *GetHistogramReply {
 
 	v.Data = make([]byte, (int(v.Length) * 4))
 	copy(v.Data[:(int(v.Length)*4)], buf[b:])
-	b += xgb.Pad(int((int(v.Length) * 4)))
+	b += int((int(v.Length) * 4))
 
 	return v
 }
@@ -4553,7 +4532,6 @@ func getHistogramParameterfvReply(buf []byte) *GetHistogramParameterfvReply {
 		v.Data[i] = Float32(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -4665,7 +4643,6 @@ func getHistogramParameterivReply(buf []byte) *GetHistogramParameterivReply {
 		v.Data[i] = int32(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -4777,7 +4754,6 @@ func getIntegervReply(buf []byte) *GetIntegervReply {
 		v.Data[i] = int32(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -4886,7 +4862,6 @@ func getLightfvReply(buf []byte) *GetLightfvReply {
 		v.Data[i] = Float32(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -4998,7 +4973,6 @@ func getLightivReply(buf []byte) *GetLightivReply {
 		v.Data[i] = int32(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -5110,7 +5084,6 @@ func getMapdvReply(buf []byte) *GetMapdvReply {
 		v.Data[i] = Float64(xgb.Get64(buf[b:]))
 		b += 8
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -5222,7 +5195,6 @@ func getMapfvReply(buf []byte) *GetMapfvReply {
 		v.Data[i] = Float32(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -5334,7 +5306,6 @@ func getMapivReply(buf []byte) *GetMapivReply {
 		v.Data[i] = int32(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -5446,7 +5417,6 @@ func getMaterialfvReply(buf []byte) *GetMaterialfvReply {
 		v.Data[i] = Float32(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -5558,7 +5528,6 @@ func getMaterialivReply(buf []byte) *GetMaterialivReply {
 		v.Data[i] = int32(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -5656,7 +5625,7 @@ func getMinmaxReply(buf []byte) *GetMinmaxReply {
 
 	v.Data = make([]byte, (int(v.Length) * 4))
 	copy(v.Data[:(int(v.Length)*4)], buf[b:])
-	b += xgb.Pad(int((int(v.Length) * 4)))
+	b += int((int(v.Length) * 4))
 
 	return v
 }
@@ -5785,7 +5754,6 @@ func getMinmaxParameterfvReply(buf []byte) *GetMinmaxParameterfvReply {
 		v.Data[i] = Float32(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -5897,7 +5865,6 @@ func getMinmaxParameterivReply(buf []byte) *GetMinmaxParameterivReply {
 		v.Data[i] = int32(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -6009,7 +5976,6 @@ func getPixelMapfvReply(buf []byte) *GetPixelMapfvReply {
 		v.Data[i] = Float32(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -6118,7 +6084,6 @@ func getPixelMapuivReply(buf []byte) *GetPixelMapuivReply {
 		v.Data[i] = xgb.Get32(buf[b:])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -6227,7 +6192,6 @@ func getPixelMapusvReply(buf []byte) *GetPixelMapusvReply {
 		v.Data[i] = xgb.Get16(buf[b:])
 		b += 2
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -6322,7 +6286,7 @@ func getPolygonStippleReply(buf []byte) *GetPolygonStippleReply {
 
 	v.Data = make([]byte, (int(v.Length) * 4))
 	copy(v.Data[:(int(v.Length)*4)], buf[b:])
-	b += xgb.Pad(int((int(v.Length) * 4)))
+	b += int((int(v.Length) * 4))
 
 	return v
 }
@@ -6435,7 +6399,6 @@ func getQueryObjectivARBReply(buf []byte) *GetQueryObjectivARBReply {
 		v.Data[i] = int32(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -6547,7 +6510,6 @@ func getQueryObjectuivARBReply(buf []byte) *GetQueryObjectuivARBReply {
 		v.Data[i] = xgb.Get32(buf[b:])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -6659,7 +6621,6 @@ func getQueryivARBReply(buf []byte) *GetQueryivARBReply {
 		v.Data[i] = int32(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -6768,7 +6729,7 @@ func getSeparableFilterReply(buf []byte) *GetSeparableFilterReply {
 
 	v.RowsAndCols = make([]byte, (int(v.Length) * 4))
 	copy(v.RowsAndCols[:(int(v.Length)*4)], buf[b:])
-	b += xgb.Pad(int((int(v.Length) * 4)))
+	b += int((int(v.Length) * 4))
 
 	return v
 }
@@ -6995,7 +6956,6 @@ func getTexEnvfvReply(buf []byte) *GetTexEnvfvReply {
 		v.Data[i] = Float32(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -7107,7 +7067,6 @@ func getTexEnvivReply(buf []byte) *GetTexEnvivReply {
 		v.Data[i] = int32(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -7219,7 +7178,6 @@ func getTexGendvReply(buf []byte) *GetTexGendvReply {
 		v.Data[i] = Float64(xgb.Get64(buf[b:]))
 		b += 8
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -7331,7 +7289,6 @@ func getTexGenfvReply(buf []byte) *GetTexGenfvReply {
 		v.Data[i] = Float32(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -7443,7 +7400,6 @@ func getTexGenivReply(buf []byte) *GetTexGenivReply {
 		v.Data[i] = int32(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -7556,7 +7512,7 @@ func getTexImageReply(buf []byte) *GetTexImageReply {
 
 	v.Data = make([]byte, (int(v.Length) * 4))
 	copy(v.Data[:(int(v.Length)*4)], buf[b:])
-	b += xgb.Pad(int((int(v.Length) * 4)))
+	b += int((int(v.Length) * 4))
 
 	return v
 }
@@ -7681,7 +7637,6 @@ func getTexLevelParameterfvReply(buf []byte) *GetTexLevelParameterfvReply {
 		v.Data[i] = Float32(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -7796,7 +7751,6 @@ func getTexLevelParameterivReply(buf []byte) *GetTexLevelParameterivReply {
 		v.Data[i] = int32(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -7911,7 +7865,6 @@ func getTexParameterfvReply(buf []byte) *GetTexParameterfvReply {
 		v.Data[i] = Float32(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -8023,7 +7976,6 @@ func getTexParameterivReply(buf []byte) *GetTexParameterivReply {
 		v.Data[i] = int32(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -8132,7 +8084,6 @@ func getVisualConfigsReply(buf []byte) *GetVisualConfigsReply {
 		v.PropertyList[i] = xgb.Get32(buf[b:])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -8979,7 +8930,6 @@ func queryContextReply(buf []byte) *QueryContextReply {
 		v.Attribs[i] = xgb.Get32(buf[b:])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -9368,7 +9318,7 @@ func readPixelsReply(buf []byte) *ReadPixelsReply {
 
 	v.Data = make([]byte, (int(v.Length) * 4))
 	copy(v.Data[:(int(v.Length)*4)], buf[b:])
-	b += xgb.Pad(int((int(v.Length) * 4)))
+	b += int((int(v.Length) * 4))
 
 	return v
 }
@@ -9480,7 +9430,7 @@ func renderRequest(c *xgb.Conn, ContextTag ContextTag, Data []byte) []byte {
 	b += 4
 
 	copy(buf[b:], Data[:len(Data)])
-	b += xgb.Pad(int(len(Data)))
+	b += int(len(Data))
 
 	return buf
 }
@@ -9547,7 +9497,7 @@ func renderLargeRequest(c *xgb.Conn, ContextTag ContextTag, RequestNum uint16, R
 	b += 4
 
 	copy(buf[b:], Data[:DataLen])
-	b += xgb.Pad(int(DataLen))
+	b += int(DataLen)
 
 	return buf
 }
@@ -9632,7 +9582,6 @@ func renderModeReply(buf []byte) *RenderModeReply {
 		v.Data[i] = xgb.Get32(buf[b:])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -9788,13 +9737,12 @@ func setClientInfo2ARBRequest(c *xgb.Conn, MajorVersion uint32, MinorVersion uin
 		xgb.Put32(buf[b:], GlVersions[i])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	copy(buf[b:], GlExtensionString[:GlStrLen])
-	b += xgb.Pad(int(GlStrLen))
+	b += int(GlStrLen)
 
 	copy(buf[b:], GlxExtensionString[:GlxStrLen])
-	b += xgb.Pad(int(GlxStrLen))
+	b += int(GlxStrLen)
 
 	return buf
 }
@@ -9867,13 +9815,12 @@ func setClientInfoARBRequest(c *xgb.Conn, MajorVersion uint32, MinorVersion uint
 		xgb.Put32(buf[b:], GlVersions[i])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	copy(buf[b:], GlExtensionString[:GlStrLen])
-	b += xgb.Pad(int(GlStrLen))
+	b += int(GlStrLen)
 
 	copy(buf[b:], GlxExtensionString[:GlxStrLen])
-	b += xgb.Pad(int(GlxStrLen))
+	b += int(GlxStrLen)
 
 	return buf
 }
@@ -10059,7 +10006,7 @@ func vendorPrivateRequest(c *xgb.Conn, VendorCode uint32, ContextTag ContextTag,
 	b += 4
 
 	copy(buf[b:], Data[:len(Data)])
-	b += xgb.Pad(int(len(Data)))
+	b += int(len(Data))
 
 	return buf
 }
@@ -10131,11 +10078,11 @@ func vendorPrivateWithReplyReply(buf []byte) *VendorPrivateWithReplyReply {
 
 	v.Data1 = make([]byte, 24)
 	copy(v.Data1[:24], buf[b:])
-	b += xgb.Pad(int(24))
+	b += int(24)
 
 	v.Data2 = make([]byte, (int(v.Length) * 4))
 	copy(v.Data2[:(int(v.Length)*4)], buf[b:])
-	b += xgb.Pad(int((int(v.Length) * 4)))
+	b += int((int(v.Length) * 4))
 
 	return v
 }
@@ -10163,7 +10110,7 @@ func vendorPrivateWithReplyRequest(c *xgb.Conn, VendorCode uint32, ContextTag Co
 	b += 4
 
 	copy(buf[b:], Data[:len(Data)])
-	b += xgb.Pad(int(len(Data)))
+	b += int(len(Data))
 
 	return buf
 }
diff --git a/nexgb/randr/randr.go b/nexgb/randr/randr.go
index db45a23..20dc62a 100644
--- a/nexgb/randr/randr.go
+++ b/nexgb/randr/randr.go
@@ -331,7 +331,7 @@ func (v CrtcChange) Bytes() []byte {
 	xgb.Put16(buf[b:], v.Height)
 	b += 2
 
-	return buf
+	return buf[:b]
 }
 
 // CrtcChangeListBytes writes a list of CrtcChange values to a byte slice.
@@ -489,7 +489,7 @@ func (v ModeInfo) Bytes() []byte {
 	xgb.Put32(buf[b:], v.ModeFlags)
 	b += 4
 
-	return buf
+	return buf[:b]
 }
 
 // ModeInfoListBytes writes a list of ModeInfo values to a byte slice.
@@ -504,6 +504,15 @@ func ModeInfoListBytes(buf []byte, list []ModeInfo) int {
 	return xgb.Pad(b)
 }
 
+const (
+	NotifyCrtcChange       = 0
+	NotifyOutputChange     = 1
+	NotifyOutputProperty   = 2
+	NotifyProviderChange   = 3
+	NotifyProviderProperty = 4
+	NotifyResourceChange   = 5
+)
+
 // Notify is the event number for a NotifyEvent.
 const Notify = 1
 
@@ -572,15 +581,6 @@ func init() {
 	xgb.NewExtEventFuncs["RANDR"][1] = NotifyEventNew
 }
 
-const (
-	NotifyCrtcChange       = 0
-	NotifyOutputChange     = 1
-	NotifyOutputProperty   = 2
-	NotifyProviderChange   = 3
-	NotifyProviderProperty = 4
-	NotifyResourceChange   = 5
-)
-
 // NotifyDataUnion is a represention of the NotifyDataUnion union type.
 // Note that to *create* a Union, you should *never* create
 // this struct directly (unless you know what you're doing).
@@ -1034,7 +1034,7 @@ func (v OutputChange) Bytes() []byte {
 	buf[b] = v.SubpixelOrder
 	b += 1
 
-	return buf
+	return buf[:b]
 }
 
 // OutputChangeListBytes writes a list of OutputChange values to a byte slice.
@@ -1114,7 +1114,7 @@ func (v OutputProperty) Bytes() []byte {
 
 	b += 11 // padding
 
-	return buf
+	return buf[:b]
 }
 
 // OutputPropertyListBytes writes a list of OutputProperty values to a byte slice.
@@ -1197,7 +1197,7 @@ func (v ProviderChange) Bytes() []byte {
 
 	b += 16 // padding
 
-	return buf
+	return buf[:b]
 }
 
 // ProviderChangeListBytes writes a list of ProviderChange values to a byte slice.
@@ -1277,7 +1277,7 @@ func (v ProviderProperty) Bytes() []byte {
 
 	b += 11 // padding
 
-	return buf
+	return buf[:b]
 }
 
 // ProviderPropertyListBytes writes a list of ProviderProperty values to a byte slice.
@@ -1309,7 +1309,6 @@ func RefreshRatesRead(buf []byte, v *RefreshRates) int {
 		v.Rates[i] = xgb.Get16(buf[b:])
 		b += 2
 	}
-	b = xgb.Pad(b)
 
 	return b
 }
@@ -1336,9 +1335,8 @@ func (v RefreshRates) Bytes() []byte {
 		xgb.Put16(buf[b:], v.Rates[i])
 		b += 2
 	}
-	b = xgb.Pad(b)
 
-	return buf
+	return buf[:b]
 }
 
 // RefreshRatesListBytes writes a list of RefreshRates values to a byte slice.
@@ -1406,7 +1404,7 @@ func (v ResourceChange) Bytes() []byte {
 
 	b += 20 // padding
 
-	return buf
+	return buf[:b]
 }
 
 // ResourceChangeListBytes writes a list of ResourceChange values to a byte slice.
@@ -1621,7 +1619,7 @@ func (v ScreenSize) Bytes() []byte {
 	xgb.Put16(buf[b:], v.Mheight)
 	b += 2
 
-	return buf
+	return buf[:b]
 }
 
 // ScreenSizeListBytes writes a list of ScreenSize values to a byte slice.
@@ -1802,7 +1800,7 @@ func changeOutputPropertyRequest(c *xgb.Conn, Output Output, Property xproto.Ato
 	b += 4
 
 	copy(buf[b:], Data[:((int(NumUnits)*int(Format))/8)])
-	b += xgb.Pad(int(((int(NumUnits) * int(Format)) / 8)))
+	b += int(((int(NumUnits) * int(Format)) / 8))
 
 	return buf
 }
@@ -1877,7 +1875,7 @@ func changeProviderPropertyRequest(c *xgb.Conn, Provider Provider, Property xpro
 	b += 4
 
 	copy(buf[b:], Data[:(int(NumItems)*(int(Format)/8))])
-	b += xgb.Pad(int((int(NumItems) * (int(Format) / 8))))
+	b += int((int(NumItems) * (int(Format) / 8)))
 
 	return buf
 }
@@ -1957,7 +1955,6 @@ func configureOutputPropertyRequest(c *xgb.Conn, Output Output, Property xproto.
 		xgb.Put32(buf[b:], uint32(Values[i]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return buf
 }
@@ -2037,7 +2034,6 @@ func configureProviderPropertyRequest(c *xgb.Conn, Provider Provider, Property x
 		xgb.Put32(buf[b:], uint32(Values[i]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return buf
 }
@@ -2137,7 +2133,7 @@ func createModeRequest(c *xgb.Conn, Window xproto.Window, ModeInfo ModeInfo, Nam
 	}
 
 	copy(buf[b:], Name[:len(Name)])
-	b += xgb.Pad(int(len(Name)))
+	b += int(len(Name))
 
 	return buf
 }
@@ -2405,9 +2401,11 @@ type GetCrtcGammaReply struct {
 	// padding: 1 bytes
 	Size uint16
 	// padding: 22 bytes
-	Red   []uint16 // size: xgb.Pad((int(Size) * 2))
+	Red []uint16 // size: xgb.Pad((int(Size) * 2))
+	// alignment gap to multiple of 2
 	Green []uint16 // size: xgb.Pad((int(Size) * 2))
-	Blue  []uint16 // size: xgb.Pad((int(Size) * 2))
+	// alignment gap to multiple of 2
+	Blue []uint16 // size: xgb.Pad((int(Size) * 2))
 }
 
 // Reply blocks and returns the reply data for a GetCrtcGamma request.
@@ -2445,21 +2443,22 @@ func getCrtcGammaReply(buf []byte) *GetCrtcGammaReply {
 		v.Red[i] = xgb.Get16(buf[b:])
 		b += 2
 	}
-	b = xgb.Pad(b)
+
+	b = (b + 1) & ^1 // alignment gap
 
 	v.Green = make([]uint16, v.Size)
 	for i := 0; i < int(v.Size); i++ {
 		v.Green[i] = xgb.Get16(buf[b:])
 		b += 2
 	}
-	b = xgb.Pad(b)
+
+	b = (b + 1) & ^1 // alignment gap
 
 	v.Blue = make([]uint16, v.Size)
 	for i := 0; i < int(v.Size); i++ {
 		v.Blue[i] = xgb.Get16(buf[b:])
 		b += 2
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -2620,7 +2619,8 @@ type GetCrtcInfoReply struct {
 	NumOutputs         uint16
 	NumPossibleOutputs uint16
 	Outputs            []Output // size: xgb.Pad((int(NumOutputs) * 4))
-	Possible           []Output // size: xgb.Pad((int(NumPossibleOutputs) * 4))
+	// alignment gap to multiple of 4
+	Possible []Output // size: xgb.Pad((int(NumPossibleOutputs) * 4))
 }
 
 // Reply blocks and returns the reply data for a GetCrtcInfo request.
@@ -2684,14 +2684,14 @@ func getCrtcInfoReply(buf []byte) *GetCrtcInfoReply {
 		v.Outputs[i] = Output(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
+
+	b = (b + 3) & ^3 // alignment gap
 
 	v.Possible = make([]Output, v.NumPossibleOutputs)
 	for i := 0; i < int(v.NumPossibleOutputs); i++ {
 		v.Possible[i] = Output(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -2762,10 +2762,12 @@ type GetCrtcTransformReply struct {
 	PendingNparams    uint16
 	CurrentLen        uint16
 	CurrentNparams    uint16
-	PendingFilterName string         // size: xgb.Pad((int(PendingLen) * 1))
+	PendingFilterName string // size: xgb.Pad((int(PendingLen) * 1))
+	// alignment gap to multiple of 4
 	PendingParams     []render.Fixed // size: xgb.Pad((int(PendingNparams) * 4))
 	CurrentFilterName string         // size: xgb.Pad((int(CurrentLen) * 1))
-	CurrentParams     []render.Fixed // size: xgb.Pad((int(CurrentNparams) * 4))
+	// alignment gap to multiple of 4
+	CurrentParams []render.Fixed // size: xgb.Pad((int(CurrentNparams) * 4))
 }
 
 // Reply blocks and returns the reply data for a GetCrtcTransform request.
@@ -2829,12 +2831,13 @@ func getCrtcTransformReply(buf []byte) *GetCrtcTransformReply {
 		b += int(v.PendingLen)
 	}
 
+	b = (b + 3) & ^3 // alignment gap
+
 	v.PendingParams = make([]render.Fixed, v.PendingNparams)
 	for i := 0; i < int(v.PendingNparams); i++ {
 		v.PendingParams[i] = render.Fixed(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	{
 		byteString := make([]byte, v.CurrentLen)
@@ -2843,12 +2846,13 @@ func getCrtcTransformReply(buf []byte) *GetCrtcTransformReply {
 		b += int(v.CurrentLen)
 	}
 
+	b = (b + 3) & ^3 // alignment gap
+
 	v.CurrentParams = make([]render.Fixed, v.CurrentNparams)
 	for i := 0; i < int(v.CurrentNparams); i++ {
 		v.CurrentParams[i] = render.Fixed(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -2918,10 +2922,12 @@ type GetOutputInfoReply struct {
 	NumPreferred  uint16
 	NumClones     uint16
 	NameLen       uint16
-	Crtcs         []Crtc   // size: xgb.Pad((int(NumCrtcs) * 4))
-	Modes         []Mode   // size: xgb.Pad((int(NumModes) * 4))
-	Clones        []Output // size: xgb.Pad((int(NumClones) * 4))
-	Name          []byte   // size: xgb.Pad((int(NameLen) * 1))
+	Crtcs         []Crtc // size: xgb.Pad((int(NumCrtcs) * 4))
+	// alignment gap to multiple of 4
+	Modes []Mode // size: xgb.Pad((int(NumModes) * 4))
+	// alignment gap to multiple of 4
+	Clones []Output // size: xgb.Pad((int(NumClones) * 4))
+	Name   []byte   // size: xgb.Pad((int(NameLen) * 1))
 }
 
 // Reply blocks and returns the reply data for a GetOutputInfo request.
@@ -2988,25 +2994,26 @@ func getOutputInfoReply(buf []byte) *GetOutputInfoReply {
 		v.Crtcs[i] = Crtc(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
+
+	b = (b + 3) & ^3 // alignment gap
 
 	v.Modes = make([]Mode, v.NumModes)
 	for i := 0; i < int(v.NumModes); i++ {
 		v.Modes[i] = Mode(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
+
+	b = (b + 3) & ^3 // alignment gap
 
 	v.Clones = make([]Output, v.NumClones)
 	for i := 0; i < int(v.NumClones); i++ {
 		v.Clones[i] = Output(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	v.Name = make([]byte, v.NameLen)
 	copy(v.Name[:v.NameLen], buf[b:])
-	b += xgb.Pad(int(v.NameLen))
+	b += int(v.NameLen)
 
 	return v
 }
@@ -3202,7 +3209,7 @@ func getOutputPropertyReply(buf []byte) *GetOutputPropertyReply {
 
 	v.Data = make([]byte, (int(v.NumItems) * (int(v.Format) / 8)))
 	copy(v.Data[:(int(v.NumItems)*(int(v.Format)/8))], buf[b:])
-	b += xgb.Pad(int((int(v.NumItems) * (int(v.Format) / 8))))
+	b += int((int(v.NumItems) * (int(v.Format) / 8)))
 
 	return v
 }
@@ -3433,11 +3440,14 @@ type GetProviderInfoReply struct {
 	NumAssociatedProviders uint16
 	NameLen                uint16
 	// padding: 8 bytes
-	Crtcs                []Crtc     // size: xgb.Pad((int(NumCrtcs) * 4))
-	Outputs              []Output   // size: xgb.Pad((int(NumOutputs) * 4))
-	AssociatedProviders  []Provider // size: xgb.Pad((int(NumAssociatedProviders) * 4))
-	AssociatedCapability []uint32   // size: xgb.Pad((int(NumAssociatedProviders) * 4))
-	Name                 string     // size: xgb.Pad((int(NameLen) * 1))
+	Crtcs []Crtc // size: xgb.Pad((int(NumCrtcs) * 4))
+	// alignment gap to multiple of 4
+	Outputs []Output // size: xgb.Pad((int(NumOutputs) * 4))
+	// alignment gap to multiple of 4
+	AssociatedProviders []Provider // size: xgb.Pad((int(NumAssociatedProviders) * 4))
+	// alignment gap to multiple of 4
+	AssociatedCapability []uint32 // size: xgb.Pad((int(NumAssociatedProviders) * 4))
+	Name                 string   // size: xgb.Pad((int(NameLen) * 1))
 }
 
 // Reply blocks and returns the reply data for a GetProviderInfo request.
@@ -3491,28 +3501,30 @@ func getProviderInfoReply(buf []byte) *GetProviderInfoReply {
 		v.Crtcs[i] = Crtc(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
+
+	b = (b + 3) & ^3 // alignment gap
 
 	v.Outputs = make([]Output, v.NumOutputs)
 	for i := 0; i < int(v.NumOutputs); i++ {
 		v.Outputs[i] = Output(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
+
+	b = (b + 3) & ^3 // alignment gap
 
 	v.AssociatedProviders = make([]Provider, v.NumAssociatedProviders)
 	for i := 0; i < int(v.NumAssociatedProviders); i++ {
 		v.AssociatedProviders[i] = Provider(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
+
+	b = (b + 3) & ^3 // alignment gap
 
 	v.AssociatedCapability = make([]uint32, v.NumAssociatedProviders)
 	for i := 0; i < int(v.NumAssociatedProviders); i++ {
 		v.AssociatedCapability[i] = xgb.Get32(buf[b:])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	{
 		byteString := make([]byte, v.NameLen)
@@ -3627,7 +3639,7 @@ func getProviderPropertyReply(buf []byte) *GetProviderPropertyReply {
 
 	v.Data = make([]byte, (int(v.NumItems) * (int(v.Format) / 8)))
 	copy(v.Data[:(int(v.NumItems)*(int(v.Format)/8))], buf[b:])
-	b += xgb.Pad(int((int(v.NumItems) * (int(v.Format) / 8))))
+	b += int((int(v.NumItems) * (int(v.Format) / 8)))
 
 	return v
 }
@@ -3758,7 +3770,6 @@ func getProvidersReply(buf []byte) *GetProvidersReply {
 		v.Providers[i] = Provider(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -3826,7 +3837,8 @@ type GetScreenInfoReply struct {
 	Rate            uint16
 	NInfo           uint16
 	// padding: 2 bytes
-	Sizes []ScreenSize   // size: xgb.Pad((int(NSizes) * 8))
+	Sizes []ScreenSize // size: xgb.Pad((int(NSizes) * 8))
+	// alignment gap to multiple of 2
 	Rates []RefreshRates // size: RefreshRatesListSize(Rates)
 }
 
@@ -3885,6 +3897,8 @@ func getScreenInfoReply(buf []byte) *GetScreenInfoReply {
 	v.Sizes = make([]ScreenSize, v.NSizes)
 	b += ScreenSizeReadList(buf[b:], v.Sizes)
 
+	b = (b + 1) & ^1 // alignment gap
+
 	v.Rates = make([]RefreshRates, (int(v.NInfo) - int(v.NSizes)))
 	b += RefreshRatesReadList(buf[b:], v.Rates)
 
@@ -3952,10 +3966,12 @@ type GetScreenResourcesReply struct {
 	NumModes        uint16
 	NamesLen        uint16
 	// padding: 8 bytes
-	Crtcs   []Crtc     // size: xgb.Pad((int(NumCrtcs) * 4))
-	Outputs []Output   // size: xgb.Pad((int(NumOutputs) * 4))
-	Modes   []ModeInfo // size: xgb.Pad((int(NumModes) * 32))
-	Names   []byte     // size: xgb.Pad((int(NamesLen) * 1))
+	Crtcs []Crtc // size: xgb.Pad((int(NumCrtcs) * 4))
+	// alignment gap to multiple of 4
+	Outputs []Output // size: xgb.Pad((int(NumOutputs) * 4))
+	// alignment gap to multiple of 4
+	Modes []ModeInfo // size: xgb.Pad((int(NumModes) * 32))
+	Names []byte     // size: xgb.Pad((int(NamesLen) * 1))
 }
 
 // Reply blocks and returns the reply data for a GetScreenResources request.
@@ -4008,21 +4024,23 @@ func getScreenResourcesReply(buf []byte) *GetScreenResourcesReply {
 		v.Crtcs[i] = Crtc(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
+
+	b = (b + 3) & ^3 // alignment gap
 
 	v.Outputs = make([]Output, v.NumOutputs)
 	for i := 0; i < int(v.NumOutputs); i++ {
 		v.Outputs[i] = Output(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
+
+	b = (b + 3) & ^3 // alignment gap
 
 	v.Modes = make([]ModeInfo, v.NumModes)
 	b += ModeInfoReadList(buf[b:], v.Modes)
 
 	v.Names = make([]byte, v.NamesLen)
 	copy(v.Names[:v.NamesLen], buf[b:])
-	b += xgb.Pad(int(v.NamesLen))
+	b += int(v.NamesLen)
 
 	return v
 }
@@ -4088,10 +4106,12 @@ type GetScreenResourcesCurrentReply struct {
 	NumModes        uint16
 	NamesLen        uint16
 	// padding: 8 bytes
-	Crtcs   []Crtc     // size: xgb.Pad((int(NumCrtcs) * 4))
-	Outputs []Output   // size: xgb.Pad((int(NumOutputs) * 4))
-	Modes   []ModeInfo // size: xgb.Pad((int(NumModes) * 32))
-	Names   []byte     // size: xgb.Pad((int(NamesLen) * 1))
+	Crtcs []Crtc // size: xgb.Pad((int(NumCrtcs) * 4))
+	// alignment gap to multiple of 4
+	Outputs []Output // size: xgb.Pad((int(NumOutputs) * 4))
+	// alignment gap to multiple of 4
+	Modes []ModeInfo // size: xgb.Pad((int(NumModes) * 32))
+	Names []byte     // size: xgb.Pad((int(NamesLen) * 1))
 }
 
 // Reply blocks and returns the reply data for a GetScreenResourcesCurrent request.
@@ -4144,21 +4164,23 @@ func getScreenResourcesCurrentReply(buf []byte) *GetScreenResourcesCurrentReply
 		v.Crtcs[i] = Crtc(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
+
+	b = (b + 3) & ^3 // alignment gap
 
 	v.Outputs = make([]Output, v.NumOutputs)
 	for i := 0; i < int(v.NumOutputs); i++ {
 		v.Outputs[i] = Output(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
+
+	b = (b + 3) & ^3 // alignment gap
 
 	v.Modes = make([]ModeInfo, v.NumModes)
 	b += ModeInfoReadList(buf[b:], v.Modes)
 
 	v.Names = make([]byte, v.NamesLen)
 	copy(v.Names[:v.NamesLen], buf[b:])
-	b += xgb.Pad(int(v.NamesLen))
+	b += int(v.NamesLen)
 
 	return v
 }
@@ -4360,7 +4382,6 @@ func listOutputPropertiesReply(buf []byte) *ListOutputPropertiesReply {
 		v.Atoms[i] = xproto.Atom(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -4459,7 +4480,6 @@ func listProviderPropertiesReply(buf []byte) *ListProviderPropertiesReply {
 		v.Atoms[i] = xproto.Atom(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -4578,7 +4598,6 @@ func queryOutputPropertyReply(buf []byte) *QueryOutputPropertyReply {
 		v.ValidValues[i] = int32(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -4700,7 +4719,6 @@ func queryProviderPropertyReply(buf []byte) *QueryProviderPropertyReply {
 		v.ValidValues[i] = int32(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -5001,7 +5019,6 @@ func setCrtcConfigRequest(c *xgb.Conn, Crtc Crtc, Timestamp xproto.Timestamp, Co
 		xgb.Put32(buf[b:], uint32(Outputs[i]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return buf
 }
@@ -5042,7 +5059,7 @@ func (cook SetCrtcGammaCookie) Check() error {
 // Write request to wire for SetCrtcGamma
 // setCrtcGammaRequest writes a SetCrtcGamma request to a byte slice.
 func setCrtcGammaRequest(c *xgb.Conn, Crtc Crtc, Size uint16, Red []uint16, Green []uint16, Blue []uint16) []byte {
-	size := xgb.Pad((((12 + xgb.Pad((int(Size) * 2))) + xgb.Pad((int(Size) * 2))) + xgb.Pad((int(Size) * 2))))
+	size := xgb.Pad((((((12 + xgb.Pad((int(Size) * 2))) + 2) + xgb.Pad((int(Size) * 2))) + 2) + xgb.Pad((int(Size) * 2))))
 	b := 0
 	buf := make([]byte, size)
 
@@ -5052,7 +5069,7 @@ func setCrtcGammaRequest(c *xgb.Conn, Crtc Crtc, Size uint16, Red []uint16, Gree
 	buf[b] = 24 // request opcode
 	b += 1
 
-	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	blen := b
 	b += 2
 
 	xgb.Put32(buf[b:], uint32(Crtc))
@@ -5067,21 +5084,24 @@ func setCrtcGammaRequest(c *xgb.Conn, Crtc Crtc, Size uint16, Red []uint16, Gree
 		xgb.Put16(buf[b:], Red[i])
 		b += 2
 	}
-	b = xgb.Pad(b)
+
+	b = (b + 1) & ^1 // alignment gap
 
 	for i := 0; i < int(Size); i++ {
 		xgb.Put16(buf[b:], Green[i])
 		b += 2
 	}
-	b = xgb.Pad(b)
+
+	b = (b + 1) & ^1 // alignment gap
 
 	for i := 0; i < int(Size); i++ {
 		xgb.Put16(buf[b:], Blue[i])
 		b += 2
 	}
-	b = xgb.Pad(b)
 
-	return buf
+	b = xgb.Pad(b)
+	xgb.Put16(buf[blen:], uint16(b/4)) // write request size in 4-byte units
+	return buf[:b]
 }
 
 // SetCrtcTransformCookie is a cookie used only for SetCrtcTransform requests.
@@ -5120,7 +5140,7 @@ func (cook SetCrtcTransformCookie) Check() error {
 // Write request to wire for SetCrtcTransform
 // setCrtcTransformRequest writes a SetCrtcTransform request to a byte slice.
 func setCrtcTransformRequest(c *xgb.Conn, Crtc Crtc, Transform render.Transform, FilterLen uint16, FilterName string, FilterParams []render.Fixed) []byte {
-	size := xgb.Pad(((48 + xgb.Pad((int(FilterLen) * 1))) + xgb.Pad((len(FilterParams) * 4))))
+	size := xgb.Pad((((48 + xgb.Pad((int(FilterLen) * 1))) + 4) + xgb.Pad((len(FilterParams) * 4))))
 	b := 0
 	buf := make([]byte, size)
 
@@ -5130,7 +5150,7 @@ func setCrtcTransformRequest(c *xgb.Conn, Crtc Crtc, Transform render.Transform,
 	buf[b] = 26 // request opcode
 	b += 1
 
-	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	blen := b
 	b += 2
 
 	xgb.Put32(buf[b:], uint32(Crtc))
@@ -5148,15 +5168,18 @@ func setCrtcTransformRequest(c *xgb.Conn, Crtc Crtc, Transform render.Transform,
 	b += 2 // padding
 
 	copy(buf[b:], FilterName[:FilterLen])
-	b += xgb.Pad(int(FilterLen))
+	b += int(FilterLen)
+
+	b = (b + 3) & ^3 // alignment gap
 
 	for i := 0; i < int(len(FilterParams)); i++ {
 		xgb.Put32(buf[b:], uint32(FilterParams[i]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
-	return buf
+	b = xgb.Pad(b)
+	xgb.Put16(buf[blen:], uint16(b/4)) // write request size in 4-byte units
+	return buf[:b]
 }
 
 // SetOutputPrimaryCookie is a cookie used only for SetOutputPrimary requests.
diff --git a/nexgb/record/record.go b/nexgb/record/record.go
index 3777422..30be090 100644
--- a/nexgb/record/record.go
+++ b/nexgb/record/record.go
@@ -133,7 +133,7 @@ func (v ClientInfo) Bytes() []byte {
 
 	b += RangeListBytes(buf[b:], v.Ranges)
 
-	return buf
+	return buf[:b]
 }
 
 // ClientInfoListBytes writes a list of ClientInfo values to a byte slice.
@@ -222,7 +222,7 @@ func (v ExtRange) Bytes() []byte {
 		b += len(structBytes)
 	}
 
-	return buf
+	return buf[:b]
 }
 
 // ExtRangeListBytes writes a list of ExtRange values to a byte slice.
@@ -368,7 +368,7 @@ func (v Range) Bytes() []byte {
 	}
 	b += 1
 
-	return buf
+	return buf[:b]
 }
 
 // RangeListBytes writes a list of Range values to a byte slice.
@@ -422,7 +422,7 @@ func (v Range16) Bytes() []byte {
 	xgb.Put16(buf[b:], v.Last)
 	b += 2
 
-	return buf
+	return buf[:b]
 }
 
 // Range16ListBytes writes a list of Range16 values to a byte slice.
@@ -476,7 +476,7 @@ func (v Range8) Bytes() []byte {
 	buf[b] = v.Last
 	b += 1
 
-	return buf
+	return buf[:b]
 }
 
 // Range8ListBytes writes a list of Range8 values to a byte slice.
@@ -551,7 +551,7 @@ func (cook CreateContextCookie) Check() error {
 // Write request to wire for CreateContext
 // createContextRequest writes a CreateContext request to a byte slice.
 func createContextRequest(c *xgb.Conn, Context Context, ElementHeader ElementHeader, NumClientSpecs uint32, NumRanges uint32, ClientSpecs []ClientSpec, Ranges []Range) []byte {
-	size := xgb.Pad(((20 + xgb.Pad((int(NumClientSpecs) * 4))) + xgb.Pad((int(NumRanges) * 24))))
+	size := xgb.Pad((((20 + xgb.Pad((int(NumClientSpecs) * 4))) + 4) + xgb.Pad((int(NumRanges) * 24))))
 	b := 0
 	buf := make([]byte, size)
 
@@ -561,7 +561,7 @@ func createContextRequest(c *xgb.Conn, Context Context, ElementHeader ElementHea
 	buf[b] = 1 // request opcode
 	b += 1
 
-	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	blen := b
 	b += 2
 
 	xgb.Put32(buf[b:], uint32(Context))
@@ -582,11 +582,14 @@ func createContextRequest(c *xgb.Conn, Context Context, ElementHeader ElementHea
 		xgb.Put32(buf[b:], uint32(ClientSpecs[i]))
 		b += 4
 	}
-	b = xgb.Pad(b)
+
+	b = (b + 3) & ^3 // alignment gap
 
 	b += RangeListBytes(buf[b:], Ranges)
 
-	return buf
+	b = xgb.Pad(b)
+	xgb.Put16(buf[blen:], uint16(b/4)) // write request size in 4-byte units
+	return buf[:b]
 }
 
 // DisableContextCookie is a cookie used only for DisableContext requests.
@@ -737,7 +740,7 @@ func enableContextReply(buf []byte) *EnableContextReply {
 
 	v.Data = make([]byte, (int(v.Length) * 4))
 	copy(v.Data[:(int(v.Length)*4)], buf[b:])
-	b += xgb.Pad(int((int(v.Length) * 4)))
+	b += int((int(v.Length) * 4))
 
 	return v
 }
@@ -1057,7 +1060,7 @@ func (cook RegisterClientsCookie) Check() error {
 // Write request to wire for RegisterClients
 // registerClientsRequest writes a RegisterClients request to a byte slice.
 func registerClientsRequest(c *xgb.Conn, Context Context, ElementHeader ElementHeader, NumClientSpecs uint32, NumRanges uint32, ClientSpecs []ClientSpec, Ranges []Range) []byte {
-	size := xgb.Pad(((20 + xgb.Pad((int(NumClientSpecs) * 4))) + xgb.Pad((int(NumRanges) * 24))))
+	size := xgb.Pad((((20 + xgb.Pad((int(NumClientSpecs) * 4))) + 4) + xgb.Pad((int(NumRanges) * 24))))
 	b := 0
 	buf := make([]byte, size)
 
@@ -1067,7 +1070,7 @@ func registerClientsRequest(c *xgb.Conn, Context Context, ElementHeader ElementH
 	buf[b] = 2 // request opcode
 	b += 1
 
-	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	blen := b
 	b += 2
 
 	xgb.Put32(buf[b:], uint32(Context))
@@ -1088,11 +1091,14 @@ func registerClientsRequest(c *xgb.Conn, Context Context, ElementHeader ElementH
 		xgb.Put32(buf[b:], uint32(ClientSpecs[i]))
 		b += 4
 	}
-	b = xgb.Pad(b)
+
+	b = (b + 3) & ^3 // alignment gap
 
 	b += RangeListBytes(buf[b:], Ranges)
 
-	return buf
+	b = xgb.Pad(b)
+	xgb.Put16(buf[blen:], uint16(b/4)) // write request size in 4-byte units
+	return buf[:b]
 }
 
 // UnregisterClientsCookie is a cookie used only for UnregisterClients requests.
@@ -1154,7 +1160,6 @@ func unregisterClientsRequest(c *xgb.Conn, Context Context, NumClientSpecs uint3
 		xgb.Put32(buf[b:], uint32(ClientSpecs[i]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return buf
 }
diff --git a/nexgb/render/render.go b/nexgb/render/render.go
index 80f4be7..f90065b 100644
--- a/nexgb/render/render.go
+++ b/nexgb/render/render.go
@@ -76,7 +76,7 @@ func (v Animcursorelt) Bytes() []byte {
 	xgb.Put32(buf[b:], v.Delay)
 	b += 4
 
-	return buf
+	return buf[:b]
 }
 
 // AnimcursoreltListBytes writes a list of Animcursorelt values to a byte slice.
@@ -144,7 +144,7 @@ func (v Color) Bytes() []byte {
 	xgb.Put16(buf[b:], v.Alpha)
 	b += 2
 
-	return buf
+	return buf[:b]
 }
 
 // ColorListBytes writes a list of Color values to a byte slice.
@@ -256,7 +256,7 @@ func (v Directformat) Bytes() []byte {
 	xgb.Put16(buf[b:], v.AlphaMask)
 	b += 2
 
-	return buf
+	return buf[:b]
 }
 
 // DirectformatListBytes writes a list of Directformat values to a byte slice.
@@ -434,7 +434,7 @@ func (v Glyphinfo) Bytes() []byte {
 	xgb.Put16(buf[b:], uint16(v.YOff))
 	b += 2
 
-	return buf
+	return buf[:b]
 }
 
 // GlyphinfoListBytes writes a list of Glyphinfo values to a byte slice.
@@ -519,7 +519,7 @@ func (v Indexvalue) Bytes() []byte {
 	xgb.Put16(buf[b:], v.Alpha)
 	b += 2
 
-	return buf
+	return buf[:b]
 }
 
 // IndexvalueListBytes writes a list of Indexvalue values to a byte slice.
@@ -579,7 +579,7 @@ func (v Linefix) Bytes() []byte {
 		b += len(structBytes)
 	}
 
-	return buf
+	return buf[:b]
 }
 
 // LinefixListBytes writes a list of Linefix values to a byte slice.
@@ -802,7 +802,7 @@ func (v Pictdepth) Bytes() []byte {
 
 	b += PictvisualListBytes(buf[b:], v.Visuals)
 
-	return buf
+	return buf[:b]
 }
 
 // PictdepthListBytes writes a list of Pictdepth values to a byte slice.
@@ -904,7 +904,7 @@ func (v Pictforminfo) Bytes() []byte {
 	xgb.Put32(buf[b:], uint32(v.Colormap))
 	b += 4
 
-	return buf
+	return buf[:b]
 }
 
 // PictforminfoListBytes writes a list of Pictforminfo values to a byte slice.
@@ -964,7 +964,7 @@ func (v Pictscreen) Bytes() []byte {
 
 	b += PictdepthListBytes(buf[b:], v.Depths)
 
-	return buf
+	return buf[:b]
 }
 
 // PictscreenListBytes writes a list of Pictscreen values to a byte slice.
@@ -1087,7 +1087,7 @@ func (v Pictvisual) Bytes() []byte {
 	xgb.Put32(buf[b:], uint32(v.Format))
 	b += 4
 
-	return buf
+	return buf[:b]
 }
 
 // PictvisualListBytes writes a list of Pictvisual values to a byte slice.
@@ -1141,7 +1141,7 @@ func (v Pointfix) Bytes() []byte {
 	xgb.Put32(buf[b:], uint32(v.Y))
 	b += 4
 
-	return buf
+	return buf[:b]
 }
 
 // PointfixListBytes writes a list of Pointfix values to a byte slice.
@@ -1219,7 +1219,7 @@ func (v Spanfix) Bytes() []byte {
 	xgb.Put32(buf[b:], uint32(v.Y))
 	b += 4
 
-	return buf
+	return buf[:b]
 }
 
 // SpanfixListBytes writes a list of Spanfix values to a byte slice.
@@ -1331,7 +1331,7 @@ func (v Transform) Bytes() []byte {
 	xgb.Put32(buf[b:], uint32(v.Matrix33))
 	b += 4
 
-	return buf
+	return buf[:b]
 }
 
 // TransformListBytes writes a list of Transform values to a byte slice.
@@ -1391,7 +1391,7 @@ func (v Trap) Bytes() []byte {
 		b += len(structBytes)
 	}
 
-	return buf
+	return buf[:b]
 }
 
 // TrapListBytes writes a list of Trap values to a byte slice.
@@ -1465,7 +1465,7 @@ func (v Trapezoid) Bytes() []byte {
 		b += len(structBytes)
 	}
 
-	return buf
+	return buf[:b]
 }
 
 // TrapezoidListBytes writes a list of Trapezoid values to a byte slice.
@@ -1535,7 +1535,7 @@ func (v Triangle) Bytes() []byte {
 		b += len(structBytes)
 	}
 
-	return buf
+	return buf[:b]
 }
 
 // TriangleListBytes writes a list of Triangle values to a byte slice.
@@ -1610,7 +1610,7 @@ func (cook AddGlyphsCookie) Check() error {
 // Write request to wire for AddGlyphs
 // addGlyphsRequest writes a AddGlyphs request to a byte slice.
 func addGlyphsRequest(c *xgb.Conn, Glyphset Glyphset, GlyphsLen uint32, Glyphids []uint32, Glyphs []Glyphinfo, Data []byte) []byte {
-	size := xgb.Pad((((12 + xgb.Pad((int(GlyphsLen) * 4))) + xgb.Pad((int(GlyphsLen) * 12))) + xgb.Pad((len(Data) * 1))))
+	size := xgb.Pad(((((12 + xgb.Pad((int(GlyphsLen) * 4))) + 4) + xgb.Pad((int(GlyphsLen) * 12))) + xgb.Pad((len(Data) * 1))))
 	b := 0
 	buf := make([]byte, size)
 
@@ -1620,7 +1620,7 @@ func addGlyphsRequest(c *xgb.Conn, Glyphset Glyphset, GlyphsLen uint32, Glyphids
 	buf[b] = 20 // request opcode
 	b += 1
 
-	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	blen := b
 	b += 2
 
 	xgb.Put32(buf[b:], uint32(Glyphset))
@@ -1633,14 +1633,17 @@ func addGlyphsRequest(c *xgb.Conn, Glyphset Glyphset, GlyphsLen uint32, Glyphids
 		xgb.Put32(buf[b:], Glyphids[i])
 		b += 4
 	}
-	b = xgb.Pad(b)
+
+	b = (b + 3) & ^3 // alignment gap
 
 	b += GlyphinfoListBytes(buf[b:], Glyphs)
 
 	copy(buf[b:], Data[:len(Data)])
-	b += xgb.Pad(int(len(Data)))
+	b += int(len(Data))
 
-	return buf
+	b = xgb.Pad(b)
+	xgb.Put16(buf[blen:], uint16(b/4)) // write request size in 4-byte units
+	return buf[:b]
 }
 
 // AddTrapsCookie is a cookie used only for AddTraps requests.
@@ -1932,7 +1935,7 @@ func compositeGlyphs16Request(c *xgb.Conn, Op byte, Src Picture, Dst Picture, Ma
 	b += 2
 
 	copy(buf[b:], Glyphcmds[:len(Glyphcmds)])
-	b += xgb.Pad(int(len(Glyphcmds)))
+	b += int(len(Glyphcmds))
 
 	return buf
 }
@@ -2010,7 +2013,7 @@ func compositeGlyphs32Request(c *xgb.Conn, Op byte, Src Picture, Dst Picture, Ma
 	b += 2
 
 	copy(buf[b:], Glyphcmds[:len(Glyphcmds)])
-	b += xgb.Pad(int(len(Glyphcmds)))
+	b += int(len(Glyphcmds))
 
 	return buf
 }
@@ -2088,7 +2091,7 @@ func compositeGlyphs8Request(c *xgb.Conn, Op byte, Src Picture, Dst Picture, Mas
 	b += 2
 
 	copy(buf[b:], Glyphcmds[:len(Glyphcmds)])
-	b += xgb.Pad(int(len(Glyphcmds)))
+	b += int(len(Glyphcmds))
 
 	return buf
 }
@@ -2186,7 +2189,7 @@ func (cook CreateConicalGradientCookie) Check() error {
 // Write request to wire for CreateConicalGradient
 // createConicalGradientRequest writes a CreateConicalGradient request to a byte slice.
 func createConicalGradientRequest(c *xgb.Conn, Picture Picture, Center Pointfix, Angle Fixed, NumStops uint32, Stops []Fixed, Colors []Color) []byte {
-	size := xgb.Pad(((24 + xgb.Pad((int(NumStops) * 4))) + xgb.Pad((int(NumStops) * 8))))
+	size := xgb.Pad((((24 + xgb.Pad((int(NumStops) * 4))) + 4) + xgb.Pad((int(NumStops) * 8))))
 	b := 0
 	buf := make([]byte, size)
 
@@ -2196,7 +2199,7 @@ func createConicalGradientRequest(c *xgb.Conn, Picture Picture, Center Pointfix,
 	buf[b] = 36 // request opcode
 	b += 1
 
-	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	blen := b
 	b += 2
 
 	xgb.Put32(buf[b:], uint32(Picture))
@@ -2218,11 +2221,14 @@ func createConicalGradientRequest(c *xgb.Conn, Picture Picture, Center Pointfix,
 		xgb.Put32(buf[b:], uint32(Stops[i]))
 		b += 4
 	}
-	b = xgb.Pad(b)
+
+	b = (b + 3) & ^3 // alignment gap
 
 	b += ColorListBytes(buf[b:], Colors)
 
-	return buf
+	b = xgb.Pad(b)
+	xgb.Put16(buf[blen:], uint16(b/4)) // write request size in 4-byte units
+	return buf[:b]
 }
 
 // CreateCursorCookie is a cookie used only for CreateCursor requests.
@@ -2383,7 +2389,7 @@ func (cook CreateLinearGradientCookie) Check() error {
 // Write request to wire for CreateLinearGradient
 // createLinearGradientRequest writes a CreateLinearGradient request to a byte slice.
 func createLinearGradientRequest(c *xgb.Conn, Picture Picture, P1 Pointfix, P2 Pointfix, NumStops uint32, Stops []Fixed, Colors []Color) []byte {
-	size := xgb.Pad(((28 + xgb.Pad((int(NumStops) * 4))) + xgb.Pad((int(NumStops) * 8))))
+	size := xgb.Pad((((28 + xgb.Pad((int(NumStops) * 4))) + 4) + xgb.Pad((int(NumStops) * 8))))
 	b := 0
 	buf := make([]byte, size)
 
@@ -2393,7 +2399,7 @@ func createLinearGradientRequest(c *xgb.Conn, Picture Picture, P1 Pointfix, P2 P
 	buf[b] = 34 // request opcode
 	b += 1
 
-	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	blen := b
 	b += 2
 
 	xgb.Put32(buf[b:], uint32(Picture))
@@ -2418,11 +2424,14 @@ func createLinearGradientRequest(c *xgb.Conn, Picture Picture, P1 Pointfix, P2 P
 		xgb.Put32(buf[b:], uint32(Stops[i]))
 		b += 4
 	}
-	b = xgb.Pad(b)
+
+	b = (b + 3) & ^3 // alignment gap
 
 	b += ColorListBytes(buf[b:], Colors)
 
-	return buf
+	b = xgb.Pad(b)
+	xgb.Put16(buf[blen:], uint16(b/4)) // write request size in 4-byte units
+	return buf[:b]
 }
 
 // CreatePictureCookie is a cookie used only for CreatePicture requests.
@@ -2530,7 +2539,7 @@ func (cook CreateRadialGradientCookie) Check() error {
 // Write request to wire for CreateRadialGradient
 // createRadialGradientRequest writes a CreateRadialGradient request to a byte slice.
 func createRadialGradientRequest(c *xgb.Conn, Picture Picture, Inner Pointfix, Outer Pointfix, InnerRadius Fixed, OuterRadius Fixed, NumStops uint32, Stops []Fixed, Colors []Color) []byte {
-	size := xgb.Pad(((36 + xgb.Pad((int(NumStops) * 4))) + xgb.Pad((int(NumStops) * 8))))
+	size := xgb.Pad((((36 + xgb.Pad((int(NumStops) * 4))) + 4) + xgb.Pad((int(NumStops) * 8))))
 	b := 0
 	buf := make([]byte, size)
 
@@ -2540,7 +2549,7 @@ func createRadialGradientRequest(c *xgb.Conn, Picture Picture, Inner Pointfix, O
 	buf[b] = 35 // request opcode
 	b += 1
 
-	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	blen := b
 	b += 2
 
 	xgb.Put32(buf[b:], uint32(Picture))
@@ -2571,11 +2580,14 @@ func createRadialGradientRequest(c *xgb.Conn, Picture Picture, Inner Pointfix, O
 		xgb.Put32(buf[b:], uint32(Stops[i]))
 		b += 4
 	}
-	b = xgb.Pad(b)
+
+	b = (b + 3) & ^3 // alignment gap
 
 	b += ColorListBytes(buf[b:], Colors)
 
-	return buf
+	b = xgb.Pad(b)
+	xgb.Put16(buf[blen:], uint16(b/4)) // write request size in 4-byte units
+	return buf[:b]
 }
 
 // CreateSolidFillCookie is a cookie used only for CreateSolidFill requests.
@@ -2818,7 +2830,6 @@ func freeGlyphsRequest(c *xgb.Conn, Glyphset Glyphset, Glyphs []Glyph) []byte {
 		xgb.Put32(buf[b:], uint32(Glyphs[i]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return buf
 }
@@ -2955,7 +2966,6 @@ func queryFiltersReply(buf []byte) *QueryFiltersReply {
 		v.Aliases[i] = xgb.Get16(buf[b:])
 		b += 2
 	}
-	b = xgb.Pad(b)
 
 	v.Filters = make([]xproto.Str, v.NumFilters)
 	b += xproto.StrReadList(buf[b:], v.Filters)
@@ -3023,9 +3033,11 @@ type QueryPictFormatsReply struct {
 	NumVisuals  uint32
 	NumSubpixel uint32
 	// padding: 4 bytes
-	Formats   []Pictforminfo // size: xgb.Pad((int(NumFormats) * 28))
-	Screens   []Pictscreen   // size: PictscreenListSize(Screens)
-	Subpixels []uint32       // size: xgb.Pad((int(NumSubpixel) * 4))
+	Formats []Pictforminfo // size: xgb.Pad((int(NumFormats) * 28))
+	// alignment gap to multiple of 4
+	Screens []Pictscreen // size: PictscreenListSize(Screens)
+	// alignment gap to multiple of 4
+	Subpixels []uint32 // size: xgb.Pad((int(NumSubpixel) * 4))
 }
 
 // Reply blocks and returns the reply data for a QueryPictFormats request.
@@ -3073,15 +3085,18 @@ func queryPictFormatsReply(buf []byte) *QueryPictFormatsReply {
 	v.Formats = make([]Pictforminfo, v.NumFormats)
 	b += PictforminfoReadList(buf[b:], v.Formats)
 
+	b = (b + 3) & ^3 // alignment gap
+
 	v.Screens = make([]Pictscreen, v.NumScreens)
 	b += PictscreenReadList(buf[b:], v.Screens)
 
+	b = (b + 3) & ^3 // alignment gap
+
 	v.Subpixels = make([]uint32, v.NumSubpixel)
 	for i := 0; i < int(v.NumSubpixel); i++ {
 		v.Subpixels[i] = xgb.Get32(buf[b:])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -3455,7 +3470,7 @@ func (cook SetPictureFilterCookie) Check() error {
 // Write request to wire for SetPictureFilter
 // setPictureFilterRequest writes a SetPictureFilter request to a byte slice.
 func setPictureFilterRequest(c *xgb.Conn, Picture Picture, FilterLen uint16, Filter string, Values []Fixed) []byte {
-	size := xgb.Pad(((12 + xgb.Pad((int(FilterLen) * 1))) + xgb.Pad((len(Values) * 4))))
+	size := xgb.Pad((((12 + xgb.Pad((int(FilterLen) * 1))) + 4) + xgb.Pad((len(Values) * 4))))
 	b := 0
 	buf := make([]byte, size)
 
@@ -3465,7 +3480,7 @@ func setPictureFilterRequest(c *xgb.Conn, Picture Picture, FilterLen uint16, Fil
 	buf[b] = 30 // request opcode
 	b += 1
 
-	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	blen := b
 	b += 2
 
 	xgb.Put32(buf[b:], uint32(Picture))
@@ -3477,15 +3492,18 @@ func setPictureFilterRequest(c *xgb.Conn, Picture Picture, FilterLen uint16, Fil
 	b += 2 // padding
 
 	copy(buf[b:], Filter[:FilterLen])
-	b += xgb.Pad(int(FilterLen))
+	b += int(FilterLen)
+
+	b = (b + 3) & ^3 // alignment gap
 
 	for i := 0; i < int(len(Values)); i++ {
 		xgb.Put32(buf[b:], uint32(Values[i]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
-	return buf
+	b = xgb.Pad(b)
+	xgb.Put16(buf[blen:], uint16(b/4)) // write request size in 4-byte units
+	return buf[:b]
 }
 
 // SetPictureTransformCookie is a cookie used only for SetPictureTransform requests.
diff --git a/nexgb/res/res.go b/nexgb/res/res.go
index 8311f95..dd53857 100644
--- a/nexgb/res/res.go
+++ b/nexgb/res/res.go
@@ -76,7 +76,7 @@ func (v Client) Bytes() []byte {
 	xgb.Put32(buf[b:], v.ResourceMask)
 	b += 4
 
-	return buf
+	return buf[:b]
 }
 
 // ClientListBytes writes a list of Client values to a byte slice.
@@ -135,7 +135,7 @@ func (v ClientIdSpec) Bytes() []byte {
 	xgb.Put32(buf[b:], v.Mask)
 	b += 4
 
-	return buf
+	return buf[:b]
 }
 
 // ClientIdSpecListBytes writes a list of ClientIdSpec values to a byte slice.
@@ -171,7 +171,6 @@ func ClientIdValueRead(buf []byte, v *ClientIdValue) int {
 		v.Value[i] = xgb.Get32(buf[b:])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return b
 }
@@ -204,9 +203,8 @@ func (v ClientIdValue) Bytes() []byte {
 		xgb.Put32(buf[b:], v.Value[i])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
-	return buf
+	return buf[:b]
 }
 
 // ClientIdValueListBytes writes a list of ClientIdValue values to a byte slice.
@@ -269,7 +267,7 @@ func (v ResourceIdSpec) Bytes() []byte {
 	xgb.Put32(buf[b:], v.Type)
 	b += 4
 
-	return buf
+	return buf[:b]
 }
 
 // ResourceIdSpecListBytes writes a list of ResourceIdSpec values to a byte slice.
@@ -340,7 +338,7 @@ func (v ResourceSizeSpec) Bytes() []byte {
 	xgb.Put32(buf[b:], v.UseCount)
 	b += 4
 
-	return buf
+	return buf[:b]
 }
 
 // ResourceSizeSpecListBytes writes a list of ResourceSizeSpec values to a byte slice.
@@ -403,7 +401,7 @@ func (v ResourceSizeValue) Bytes() []byte {
 
 	b += ResourceSizeSpecListBytes(buf[b:], v.CrossReferences)
 
-	return buf
+	return buf[:b]
 }
 
 // ResourceSizeValueListBytes writes a list of ResourceSizeValue values to a byte slice.
@@ -466,7 +464,7 @@ func (v Type) Bytes() []byte {
 	xgb.Put32(buf[b:], v.Count)
 	b += 4
 
-	return buf
+	return buf[:b]
 }
 
 // TypeListBytes writes a list of Type values to a byte slice.
diff --git a/nexgb/xcmisc/xcmisc.go b/nexgb/xcmisc/xcmisc.go
index 5cff5f1..2240ee1 100644
--- a/nexgb/xcmisc/xcmisc.go
+++ b/nexgb/xcmisc/xcmisc.go
@@ -228,7 +228,6 @@ func getXIDListReply(buf []byte) *GetXIDListReply {
 		v.Ids[i] = xgb.Get32(buf[b:])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
diff --git a/nexgb/xevie/xevie.go b/nexgb/xevie/xevie.go
index f77d405..7e18f8d 100644
--- a/nexgb/xevie/xevie.go
+++ b/nexgb/xevie/xevie.go
@@ -72,7 +72,7 @@ func (v Event) Bytes() []byte {
 
 	b += 32 // padding
 
-	return buf
+	return buf[:b]
 }
 
 // EventListBytes writes a list of Event values to a byte slice.
diff --git a/nexgb/xf86dri/xf86dri.go b/nexgb/xf86dri/xf86dri.go
index d88cc5d..6a07e41 100644
--- a/nexgb/xf86dri/xf86dri.go
+++ b/nexgb/xf86dri/xf86dri.go
@@ -90,7 +90,7 @@ func (v DrmClipRect) Bytes() []byte {
 	xgb.Put16(buf[b:], uint16(v.X3))
 	b += 2
 
-	return buf
+	return buf[:b]
 }
 
 // DrmClipRectListBytes writes a list of DrmClipRect values to a byte slice.
@@ -776,7 +776,6 @@ func getDeviceInfoReply(buf []byte) *GetDeviceInfoReply {
 		v.DevicePrivate[i] = xgb.Get32(buf[b:])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -846,7 +845,8 @@ type GetDrawableInfoReply struct {
 	BackY              int16
 	NumBackClipRects   uint32
 	ClipRects          []DrmClipRect // size: xgb.Pad((int(NumClipRects) * 8))
-	BackClipRects      []DrmClipRect // size: xgb.Pad((int(NumBackClipRects) * 8))
+	// alignment gap to multiple of 4
+	BackClipRects []DrmClipRect // size: xgb.Pad((int(NumBackClipRects) * 8))
 }
 
 // Reply blocks and returns the reply data for a GetDrawableInfo request.
@@ -907,6 +907,8 @@ func getDrawableInfoReply(buf []byte) *GetDrawableInfoReply {
 	v.ClipRects = make([]DrmClipRect, v.NumClipRects)
 	b += DrmClipRectReadList(buf[b:], v.ClipRects)
 
+	b = (b + 3) & ^3 // alignment gap
+
 	v.BackClipRects = make([]DrmClipRect, v.NumBackClipRects)
 	b += DrmClipRectReadList(buf[b:], v.BackClipRects)
 
diff --git a/nexgb/xf86vidmode/xf86vidmode.go b/nexgb/xf86vidmode/xf86vidmode.go
index 8abb44e..5b0f1f8 100644
--- a/nexgb/xf86vidmode/xf86vidmode.go
+++ b/nexgb/xf86vidmode/xf86vidmode.go
@@ -408,7 +408,7 @@ func (v ModeInfo) Bytes() []byte {
 	xgb.Put32(buf[b:], v.Privsize)
 	b += 4
 
-	return buf
+	return buf[:b]
 }
 
 // ModeInfoListBytes writes a list of ModeInfo values to a byte slice.
@@ -676,7 +676,7 @@ func addModeLineRequest(c *xgb.Conn, Screen uint32, Dotclock Dotclock, Hdisplay
 	b += 12 // padding
 
 	copy(buf[b:], Private[:Privsize])
-	b += xgb.Pad(int(Privsize))
+	b += int(Privsize)
 
 	return buf
 }
@@ -774,7 +774,7 @@ func deleteModeLineRequest(c *xgb.Conn, Screen uint32, Dotclock Dotclock, Hdispl
 	b += 4
 
 	copy(buf[b:], Private[:Privsize])
-	b += xgb.Pad(int(Privsize))
+	b += int(Privsize)
 
 	return buf
 }
@@ -956,7 +956,6 @@ func getDotClocksReply(buf []byte) *GetDotClocksReply {
 		v.Clock[i] = xgb.Get32(buf[b:])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -1120,9 +1119,11 @@ type GetGammaRampReply struct {
 	// padding: 1 bytes
 	Size uint16
 	// padding: 22 bytes
-	Red   []uint16 // size: xgb.Pad((((int(Size) + 1) & -2) * 2))
+	Red []uint16 // size: xgb.Pad((((int(Size) + 1) & -2) * 2))
+	// alignment gap to multiple of 2
 	Green []uint16 // size: xgb.Pad((((int(Size) + 1) & -2) * 2))
-	Blue  []uint16 // size: xgb.Pad((((int(Size) + 1) & -2) * 2))
+	// alignment gap to multiple of 2
+	Blue []uint16 // size: xgb.Pad((((int(Size) + 1) & -2) * 2))
 }
 
 // Reply blocks and returns the reply data for a GetGammaRamp request.
@@ -1160,21 +1161,22 @@ func getGammaRampReply(buf []byte) *GetGammaRampReply {
 		v.Red[i] = xgb.Get16(buf[b:])
 		b += 2
 	}
-	b = xgb.Pad(b)
+
+	b = (b + 1) & ^1 // alignment gap
 
 	v.Green = make([]uint16, ((int(v.Size) + 1) & -2))
 	for i := 0; i < int(((int(v.Size) + 1) & -2)); i++ {
 		v.Green[i] = xgb.Get16(buf[b:])
 		b += 2
 	}
-	b = xgb.Pad(b)
+
+	b = (b + 1) & ^1 // alignment gap
 
 	v.Blue = make([]uint16, ((int(v.Size) + 1) & -2))
 	for i := 0; i < int(((int(v.Size) + 1) & -2)); i++ {
 		v.Blue[i] = xgb.Get16(buf[b:])
 		b += 2
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -1413,7 +1415,7 @@ func getModeLineReply(buf []byte) *GetModeLineReply {
 
 	v.Private = make([]byte, v.Privsize)
 	copy(v.Private[:v.Privsize], buf[b:])
-	b += xgb.Pad(int(v.Privsize))
+	b += int(v.Privsize)
 
 	return v
 }
@@ -1479,7 +1481,8 @@ type GetMonitorReply struct {
 	NumHsync     byte
 	NumVsync     byte
 	// padding: 20 bytes
-	Hsync        []Syncrange // size: xgb.Pad((int(NumHsync) * 4))
+	Hsync []Syncrange // size: xgb.Pad((int(NumHsync) * 4))
+	// alignment gap to multiple of 4
 	Vsync        []Syncrange // size: xgb.Pad((int(NumVsync) * 4))
 	Vendor       string      // size: xgb.Pad((int(VendorLength) * 1))
 	AlignmentPad []byte      // size: xgb.Pad(((((int(VendorLength) + 3) & -4) - int(VendorLength)) * 1))
@@ -1530,14 +1533,14 @@ func getMonitorReply(buf []byte) *GetMonitorReply {
 		v.Hsync[i] = Syncrange(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
+
+	b = (b + 3) & ^3 // alignment gap
 
 	v.Vsync = make([]Syncrange, v.NumVsync)
 	for i := 0; i < int(v.NumVsync); i++ {
 		v.Vsync[i] = Syncrange(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	{
 		byteString := make([]byte, v.VendorLength)
@@ -1548,7 +1551,7 @@ func getMonitorReply(buf []byte) *GetMonitorReply {
 
 	v.AlignmentPad = make([]byte, (((int(v.VendorLength) + 3) & -4) - int(v.VendorLength)))
 	copy(v.AlignmentPad[:(((int(v.VendorLength)+3)&-4)-int(v.VendorLength))], buf[b:])
-	b += xgb.Pad(int((((int(v.VendorLength) + 3) & -4) - int(v.VendorLength))))
+	b += int((((int(v.VendorLength) + 3) & -4) - int(v.VendorLength)))
 
 	{
 		byteString := make([]byte, v.ModelLength)
@@ -1922,7 +1925,7 @@ func modModeLineRequest(c *xgb.Conn, Screen uint32, Hdisplay uint16, Hsyncstart
 	b += 4
 
 	copy(buf[b:], Private[:Privsize])
-	b += xgb.Pad(int(Privsize))
+	b += int(Privsize)
 
 	return buf
 }
@@ -2178,7 +2181,7 @@ func (cook SetGammaRampCookie) Check() error {
 // Write request to wire for SetGammaRamp
 // setGammaRampRequest writes a SetGammaRamp request to a byte slice.
 func setGammaRampRequest(c *xgb.Conn, Screen uint16, Size uint16, Red []uint16, Green []uint16, Blue []uint16) []byte {
-	size := xgb.Pad((((8 + xgb.Pad((((int(Size) + 1) & -2) * 2))) + xgb.Pad((((int(Size) + 1) & -2) * 2))) + xgb.Pad((((int(Size) + 1) & -2) * 2))))
+	size := xgb.Pad((((((8 + xgb.Pad((((int(Size) + 1) & -2) * 2))) + 2) + xgb.Pad((((int(Size) + 1) & -2) * 2))) + 2) + xgb.Pad((((int(Size) + 1) & -2) * 2))))
 	b := 0
 	buf := make([]byte, size)
 
@@ -2188,7 +2191,7 @@ func setGammaRampRequest(c *xgb.Conn, Screen uint16, Size uint16, Red []uint16,
 	buf[b] = 18 // request opcode
 	b += 1
 
-	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	blen := b
 	b += 2
 
 	xgb.Put16(buf[b:], Screen)
@@ -2201,21 +2204,24 @@ func setGammaRampRequest(c *xgb.Conn, Screen uint16, Size uint16, Red []uint16,
 		xgb.Put16(buf[b:], Red[i])
 		b += 2
 	}
-	b = xgb.Pad(b)
+
+	b = (b + 1) & ^1 // alignment gap
 
 	for i := 0; i < int(((int(Size) + 1) & -2)); i++ {
 		xgb.Put16(buf[b:], Green[i])
 		b += 2
 	}
-	b = xgb.Pad(b)
+
+	b = (b + 1) & ^1 // alignment gap
 
 	for i := 0; i < int(((int(Size) + 1) & -2)); i++ {
 		xgb.Put16(buf[b:], Blue[i])
 		b += 2
 	}
-	b = xgb.Pad(b)
 
-	return buf
+	b = xgb.Pad(b)
+	xgb.Put16(buf[blen:], uint16(b/4)) // write request size in 4-byte units
+	return buf[:b]
 }
 
 // SetViewPortCookie is a cookie used only for SetViewPort requests.
@@ -2432,7 +2438,7 @@ func switchToModeRequest(c *xgb.Conn, Screen uint32, Dotclock Dotclock, Hdisplay
 	b += 4
 
 	copy(buf[b:], Private[:Privsize])
-	b += xgb.Pad(int(Privsize))
+	b += int(Privsize)
 
 	return buf
 }
@@ -2566,7 +2572,7 @@ func validateModeLineRequest(c *xgb.Conn, Screen uint32, Dotclock Dotclock, Hdis
 	b += 4
 
 	copy(buf[b:], Private[:Privsize])
-	b += xgb.Pad(int(Privsize))
+	b += int(Privsize)
 
 	return buf
 }
diff --git a/nexgb/xfixes/xfixes.go b/nexgb/xfixes/xfixes.go
index 9a08c93..ef08c9a 100644
--- a/nexgb/xfixes/xfixes.go
+++ b/nexgb/xfixes/xfixes.go
@@ -489,7 +489,7 @@ func changeCursorByNameRequest(c *xgb.Conn, Src xproto.Cursor, Nbytes uint16, Na
 	b += 2 // padding
 
 	copy(buf[b:], Name[:Nbytes])
-	b += xgb.Pad(int(Nbytes))
+	b += int(Nbytes)
 
 	return buf
 }
@@ -697,7 +697,6 @@ func createPointerBarrierRequest(c *xgb.Conn, Barrier Barrier, Window xproto.Win
 		xgb.Put16(buf[b:], Devices[i])
 		b += 2
 	}
-	b = xgb.Pad(b)
 
 	return buf
 }
@@ -1367,7 +1366,6 @@ func getCursorImageReply(buf []byte) *GetCursorImageReply {
 		v.CursorImage[i] = xgb.Get32(buf[b:])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -1433,7 +1431,8 @@ type GetCursorImageAndNameReply struct {
 	CursorAtom   xproto.Atom
 	Nbytes       uint16
 	// padding: 2 bytes
-	Name        string   // size: xgb.Pad((int(Nbytes) * 1))
+	Name string // size: xgb.Pad((int(Nbytes) * 1))
+	// alignment gap to multiple of 4
 	CursorImage []uint32 // size: xgb.Pad(((int(Width) * int(Height)) * 4))
 }
 
@@ -1498,12 +1497,13 @@ func getCursorImageAndNameReply(buf []byte) *GetCursorImageAndNameReply {
 		b += int(v.Nbytes)
 	}
 
+	b = (b + 3) & ^3 // alignment gap
+
 	v.CursorImage = make([]uint32, (int(v.Width) * int(v.Height)))
 	for i := 0; i < int((int(v.Width) * int(v.Height))); i++ {
 		v.CursorImage[i] = xgb.Get32(buf[b:])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -2143,7 +2143,7 @@ func setCursorNameRequest(c *xgb.Conn, Cursor xproto.Cursor, Nbytes uint16, Name
 	b += 2 // padding
 
 	copy(buf[b:], Name[:Nbytes])
-	b += xgb.Pad(int(Nbytes))
+	b += int(Nbytes)
 
 	return buf
 }
diff --git a/nexgb/xgbgen/aligngap.go b/nexgb/xgbgen/aligngap.go
new file mode 100644
index 0000000..1e07e18
--- /dev/null
+++ b/nexgb/xgbgen/aligngap.go
@@ -0,0 +1,130 @@
+package main
+
+import (
+	"fmt"
+	"os"
+)
+
+func (p *Protocol) AddAlignGaps() {
+	for i := range p.Imports {
+		p.Imports[i].AddAlignGaps()
+	}
+	for i := range p.Types {
+		switch t := p.Types[i].(type) {
+		case *Struct:
+			t.Fields = addAlignGapsToFields(t.xmlName, t.Fields)
+		case *Event:
+			t.Fields = addAlignGapsToFields(t.xmlName, t.Fields)
+		case *Error:
+			t.Fields = addAlignGapsToFields(t.xmlName, t.Fields)
+		}
+	}
+	for i := range p.Requests {
+		p.Requests[i].Fields = addAlignGapsToFields(p.Requests[i].xmlName, p.Requests[i].Fields)
+		if p.Requests[i].Reply != nil {
+			p.Requests[i].Reply.Fields = addAlignGapsToFields(p.Requests[i].xmlName, p.Requests[i].Reply.Fields)
+		}
+	}
+}
+
+func addAlignGapsToFields(name string, fields []Field) []Field {
+	var i int
+	for i = 0; i < len(fields); i++ {
+		if _, ok := fields[i].(*ListField); ok {
+			break
+		}
+	}
+	if i >= len(fields) {
+		return fields
+	}
+
+	r := make([]Field, 0, len(fields)+2)
+	r = append(r, fields[:i]...)
+
+	r = append(r, fields[i])
+	for i = i + 1; i < len(fields); i++ {
+		switch f := fields[i].(type) {
+		case *ListField:
+			// ok, add padding
+			sz := xcbSizeOfType(f.Type)
+			switch {
+			case sz == 1:
+				// nothing
+			case sz == 2:
+				r = append(r, &PadField{0, 2})
+			case sz == 3:
+				panic(fmt.Errorf("Alignment is not a power of 2"))
+			case sz >= 4:
+				r = append(r, &PadField{0, 4})
+			}
+
+		case *LocalField:
+			// nothing
+
+		default:
+			fmt.Fprintf(os.Stderr, "Can't add alignment gaps, mix of list and non-list fields: %s\n", name)
+			return fields
+		}
+		r = append(r, fields[i])
+	}
+
+	return r
+}
+
+func xcbSizeOfField(fld Field) int {
+	switch f := fld.(type) {
+	case *PadField:
+		return int(f.Bytes)
+
+	case *SingleField:
+		return xcbSizeOfType(f.Type)
+
+	case *ListField:
+		return 0
+
+	case *ExprField:
+		return xcbSizeOfType(f.Type)
+
+	case *ValueField:
+		return xcbSizeOfType(f.MaskType)
+
+	case *SwitchField:
+		return 0
+
+	default:
+		return 0
+	}
+}
+
+func xcbSizeOfType(typ Type) int {
+	switch t := typ.(type) {
+	case *Resource:
+		return 4
+
+	case *TypeDef:
+		return t.Size().Eval()
+
+	case *Base:
+		return t.Size().Eval()
+
+	case *Struct:
+		sz := 0
+		for i := range t.Fields {
+			sz += xcbSizeOfField(t.Fields[i])
+		}
+		return sz
+
+	case *Union:
+		sz := 0
+		for i := range t.Fields {
+			csz := xcbSizeOfField(t.Fields[i])
+			if csz > sz {
+				sz = csz
+			}
+		}
+		return sz
+
+	default:
+		return 0
+	}
+}
diff --git a/nexgb/xgbgen/context.go b/nexgb/xgbgen/context.go
index af0f598..f64f339 100644
--- a/nexgb/xgbgen/context.go
+++ b/nexgb/xgbgen/context.go
@@ -50,6 +50,8 @@ func (c *Context) Morph(xmlBytes []byte) {
 	// Translate XML types to nice types
 	c.protocol = parsedXml.Translate(nil)
 
+	c.protocol.AddAlignGaps()
+
 	// Start with Go header.
 	c.Putln("// Package %s is the X client API for the %s extension.",
 		c.protocol.PkgName(), c.protocol.ExtXName)
diff --git a/nexgb/xgbgen/field.go b/nexgb/xgbgen/field.go
index 16760d4..bf3b3be 100644
--- a/nexgb/xgbgen/field.go
+++ b/nexgb/xgbgen/field.go
@@ -50,6 +50,7 @@ func (pad *PadField) Initialize(p *Protocol) {}
 // It is also used in size calculation.
 type PadField struct {
 	Bytes uint
+	Align uint16
 }
 
 func (p *PadField) SrcName() string {
@@ -65,7 +66,11 @@ func (f *PadField) SrcType() string {
 }
 
 func (p *PadField) Size() Size {
-	return newFixedSize(p.Bytes)
+	if p.Align > 0 {
+		return newFixedSize(uint(p.Align), false)
+	} else {
+		return newFixedSize(p.Bytes, true)
+	}
 }
 
 // SingleField represents most of the fields in an XML protocol description.
@@ -130,9 +135,9 @@ func (f *ListField) Length() Size {
 			Expr: &FieldRef{
 				Name: f.SrcName(),
 			},
-		})
+		}, true)
 	}
-	return newExpressionSize(f.LengthExpr)
+	return newExpressionSize(f.LengthExpr, true)
 }
 
 // Size computes the *size* of a list (in bytes).
@@ -142,8 +147,9 @@ func (f *ListField) Length() Size {
 // special function written in go_struct.go to compute the size (since the
 // size in this case can only be computed recursively).
 func (f *ListField) Size() Size {
+	elsz := f.Type.Size()
 	simpleLen := &Padding{
-		Expr: newBinaryOp("*", f.Length().Expression, f.Type.Size().Expression),
+		Expr: newBinaryOp("*", f.Length().Expression, elsz.Expression),
 	}
 
 	switch field := f.Type.(type) {
@@ -153,18 +159,18 @@ func (f *ListField) Size() Size {
 				Name: fmt.Sprintf("%sListSize", f.Type.SrcName()),
 				Expr: &FieldRef{Name: f.SrcName()},
 			}
-			return newExpressionSize(sizeFun)
+			return newExpressionSize(sizeFun, elsz.exact)
 		} else {
-			return newExpressionSize(simpleLen)
+			return newExpressionSize(simpleLen, elsz.exact)
 		}
 	case *Union:
-		return newExpressionSize(simpleLen)
+		return newExpressionSize(simpleLen, elsz.exact)
 	case *Base:
-		return newExpressionSize(simpleLen)
+		return newExpressionSize(simpleLen, elsz.exact)
 	case *Resource:
-		return newExpressionSize(simpleLen)
+		return newExpressionSize(simpleLen, elsz.exact)
 	case *TypeDef:
-		return newExpressionSize(simpleLen)
+		return newExpressionSize(simpleLen, elsz.exact)
 	default:
 		log.Panicf("Cannot compute list size with type '%T'.", f.Type)
 	}
@@ -258,7 +264,7 @@ func (f *ValueField) Size() Size {
 				},
 			},
 		},
-	})
+	}, true)
 	return maskSize.Add(listSize)
 }
 
@@ -270,7 +276,7 @@ func (f *ValueField) ListLength() Size {
 				Name: f.MaskName,
 			},
 		},
-	})
+	}, true)
 }
 
 func (f *ValueField) Initialize(p *Protocol) {
@@ -303,7 +309,7 @@ func (f *SwitchField) SrcType() string {
 // expression that finds *which* bitcase fields are included, and sums the
 // sizes of those fields.
 func (f *SwitchField) Size() Size {
-	return newFixedSize(0)
+	return newFixedSize(0, true)
 }
 
 func (f *SwitchField) Initialize(p *Protocol) {
diff --git a/nexgb/xgbgen/go.go b/nexgb/xgbgen/go.go
index 6c680e8..ace4e00 100644
--- a/nexgb/xgbgen/go.go
+++ b/nexgb/xgbgen/go.go
@@ -103,15 +103,27 @@ func (td *TypeDef) Define(c *Context) {
 
 // Pad fields
 func (f *PadField) Define(c *Context) {
-	c.Putln("// padding: %d bytes", f.Bytes)
+	if f.Align > 0 {
+		c.Putln("// alignment gap to multiple of %d", f.Align)
+	} else {
+		c.Putln("// padding: %d bytes", f.Bytes)
+	}
 }
 
 func (f *PadField) Read(c *Context, prefix string) {
-	c.Putln("b += %s // padding", f.Size())
+	if f.Align > 0 {
+		c.Putln("b = (b + %d) & ^%d // alignment gap", f.Align-1, f.Align-1)
+	} else {
+		c.Putln("b += %s // padding", f.Size())
+	}
 }
 
 func (f *PadField) Write(c *Context, prefix string) {
-	c.Putln("b += %s // padding", f.Size())
+	if f.Align > 0 {
+		c.Putln("b = (b + %d) & ^%d // alignment gap", f.Align-1, f.Align-1)
+	} else {
+		c.Putln("b += %s // padding", f.Size())
+	}
 }
 
 // Local fields
diff --git a/nexgb/xgbgen/go_list.go b/nexgb/xgbgen/go_list.go
index fa8df69..1e85d9f 100644
--- a/nexgb/xgbgen/go_list.go
+++ b/nexgb/xgbgen/go_list.go
@@ -21,7 +21,6 @@ func (f *ListField) Read(c *Context, prefix string) {
 		c.Putln("for i := 0; i < int(%s); i++ {", length)
 		ReadSimpleSingleField(c, fmt.Sprintf("%s%s[i]", prefix, f.SrcName()), t)
 		c.Putln("}")
-		c.Putln("b = xgb.Pad(b)")
 	case *Base:
 		length := f.LengthExpr.Reduce(prefix)
 		if strings.ToLower(t.XmlName()) == "char" {
@@ -38,7 +37,7 @@ func (f *ListField) Read(c *Context, prefix string) {
 			c.Putln("%s%s = make([]%s, %s)",
 				prefix, f.SrcName(), t.SrcName(), length)
 			c.Putln("copy(%s%s[:%s], buf[b:])", prefix, f.SrcName(), length)
-			c.Putln("b += xgb.Pad(int(%s))", length)
+			c.Putln("b += int(%s)", length)
 		} else {
 			c.Putln("%s%s = make([]%s, %s)",
 				prefix, f.SrcName(), t.SrcName(), length)
@@ -46,7 +45,6 @@ func (f *ListField) Read(c *Context, prefix string) {
 			ReadSimpleSingleField(c,
 				fmt.Sprintf("%s%s[i]", prefix, f.SrcName()), t)
 			c.Putln("}")
-			c.Putln("b = xgb.Pad(b)")
 		}
 	case *TypeDef:
 		length := f.LengthExpr.Reduce(prefix)
@@ -55,7 +53,6 @@ func (f *ListField) Read(c *Context, prefix string) {
 		c.Putln("for i := 0; i < int(%s); i++ {", length)
 		ReadSimpleSingleField(c, fmt.Sprintf("%s%s[i]", prefix, f.SrcName()), t)
 		c.Putln("}")
-		c.Putln("b = xgb.Pad(b)")
 	case *Union:
 		c.Putln("%s%s = make([]%s, %s)",
 			prefix, f.SrcName(), t.SrcName(), f.LengthExpr.Reduce(prefix))
@@ -80,18 +77,16 @@ func (f *ListField) Write(c *Context, prefix string) {
 		WriteSimpleSingleField(c,
 			fmt.Sprintf("%s%s[i]", prefix, f.SrcName()), t)
 		c.Putln("}")
-		c.Putln("b = xgb.Pad(b)")
 	case *Base:
 		length := f.Length().Reduce(prefix)
 		if t.SrcName() == "byte" {
 			c.Putln("copy(buf[b:], %s%s[:%s])", prefix, f.SrcName(), length)
-			c.Putln("b += xgb.Pad(int(%s))", length)
+			c.Putln("b += int(%s)", length)
 		} else {
 			c.Putln("for i := 0; i < int(%s); i++ {", length)
 			WriteSimpleSingleField(c,
 				fmt.Sprintf("%s%s[i]", prefix, f.SrcName()), t)
 			c.Putln("}")
-			c.Putln("b = xgb.Pad(b)")
 		}
 	case *TypeDef:
 		length := f.Length().Reduce(prefix)
@@ -99,7 +94,6 @@ func (f *ListField) Write(c *Context, prefix string) {
 		WriteSimpleSingleField(c,
 			fmt.Sprintf("%s%s[i]", prefix, f.SrcName()), t)
 		c.Putln("}")
-		c.Putln("b = xgb.Pad(b)")
 	case *Union:
 		c.Putln("b += %sListBytes(buf[b:], %s%s)",
 			t.SrcName(), prefix, f.SrcName())
diff --git a/nexgb/xgbgen/go_request_reply.go b/nexgb/xgbgen/go_request_reply.go
index a2c6d9c..d82e157 100644
--- a/nexgb/xgbgen/go_request_reply.go
+++ b/nexgb/xgbgen/go_request_reply.go
@@ -138,18 +138,32 @@ func (r *Request) ReadReply(c *Context) {
 }
 
 func (r *Request) WriteRequest(c *Context) {
-	writeSize := func() {
-		c.Putln("xgb.Put16(buf[b:], uint16(size / 4)) " +
-			"// write request size in 4-byte units")
+	sz := r.Size(c)
+	writeSize1 := func() {
+		if sz.exact {
+			c.Putln("xgb.Put16(buf[b:], uint16(size / 4)) " +
+				"// write request size in 4-byte units")
+		} else {
+			c.Putln("blen := b")
+		}
 		c.Putln("b += 2")
 		c.Putln("")
 	}
+	writeSize2 := func() {
+		if sz.exact {
+			c.Putln("return buf")
+			return
+		}
+		c.Putln("b = xgb.Pad(b)")
+		c.Putln("xgb.Put16(buf[blen:], uint16(b / 4)) // write request size in 4-byte units")
+		c.Putln("return buf[:b]")
+	}
 	c.Putln("// Write request to wire for %s", r.SrcName())
 	c.Putln("// %s writes a %s request to a byte slice.",
 		r.ReqName(), r.SrcName())
 	c.Putln("func %s(c *xgb.Conn, %s) []byte {",
 		r.ReqName(), r.ParamNameTypes())
-	c.Putln("size := %s", r.Size(c))
+	c.Putln("size := %s", sz)
 	c.Putln("b := 0")
 	c.Putln("buf := make([]byte, size)")
 	c.Putln("")
@@ -165,18 +179,18 @@ func (r *Request) WriteRequest(c *Context) {
 		if !c.protocol.isExt() {
 			c.Putln("b += 1 // padding")
 		}
-		writeSize()
+		writeSize1()
 	} else if c.protocol.isExt() {
-		writeSize()
+		writeSize1()
 	}
 	for i, field := range r.Fields {
 		field.Write(c, "")
 		c.Putln("")
 		if i == 0 && !c.protocol.isExt() {
-			writeSize()
+			writeSize1()
 		}
 	}
-	c.Putln("return buf")
+	writeSize2()
 	c.Putln("}")
 	c.Putln("")
 }
diff --git a/nexgb/xgbgen/go_struct.go b/nexgb/xgbgen/go_struct.go
index 0f18084..ee74d90 100644
--- a/nexgb/xgbgen/go_struct.go
+++ b/nexgb/xgbgen/go_struct.go
@@ -78,7 +78,7 @@ func (s *Struct) Write(c *Context) {
 		field.Write(c, "v.")
 		c.Putln("")
 	}
-	c.Putln("return buf")
+	c.Putln("return buf[:b]")
 	c.Putln("}")
 	c.Putln("")
 }
diff --git a/nexgb/xgbgen/request_reply.go b/nexgb/xgbgen/request_reply.go
index 11a4e44..ae4eccb 100644
--- a/nexgb/xgbgen/request_reply.go
+++ b/nexgb/xgbgen/request_reply.go
@@ -91,7 +91,7 @@ func (r *Request) CookieName() string {
 // If it's a core protocol request, then we only account for *three*
 // bytes of the header (remove the extension opcode).
 func (r *Request) Size(c *Context) Size {
-	size := newFixedSize(0)
+	size := newFixedSize(0, true)
 
 	// If this is a core protocol request, we squeeze in an extra byte of
 	// data (from the fields below) between the opcode and the size of the
@@ -99,9 +99,9 @@ func (r *Request) Size(c *Context) Size {
 	// by the opcode of the request (while the first byte is always occupied
 	// by the opcode of the extension).
 	if !c.protocol.isExt() {
-		size = size.Add(newFixedSize(3))
+		size = size.Add(newFixedSize(3, true))
 	} else {
-		size = size.Add(newFixedSize(4))
+		size = size.Add(newFixedSize(4, true))
 	}
 
 	for _, field := range r.Fields {
@@ -122,7 +122,7 @@ func (r *Request) Size(c *Context) Size {
 	}
 	return newExpressionSize(&Padding{
 		Expr: size.Expression,
-	})
+	}, size.exact)
 }
 
 // Reply encapsulates the fields associated with a 'reply' element.
@@ -136,10 +136,10 @@ type Reply struct {
 // 2 bytes: A sequence number
 // 4 bytes: Number of additional bytes in 4-byte units past initial 32 bytes.
 func (r *Reply) Size() Size {
-	size := newFixedSize(0)
+	size := newFixedSize(0, true)
 
 	// Account for reply discriminant, sequence number and reply length
-	size = size.Add(newFixedSize(7))
+	size = size.Add(newFixedSize(7, true))
 
 	for _, field := range r.Fields {
 		size = size.Add(field.Size())
diff --git a/nexgb/xgbgen/size.go b/nexgb/xgbgen/size.go
index 8836892..6e49371 100644
--- a/nexgb/xgbgen/size.go
+++ b/nexgb/xgbgen/size.go
@@ -7,24 +7,25 @@ package main
 // for adding and multiplying sizes.
 type Size struct {
 	Expression
+	exact bool
 }
 
 // newFixedSize creates a new Size with some fixed and known value.
-func newFixedSize(fixed uint) Size {
-	return Size{&Value{v: int(fixed)}}
+func newFixedSize(fixed uint, exact bool) Size {
+	return Size{&Value{v: int(fixed)}, exact}
 }
 
 // newExpressionSize creates a new Size with some expression.
-func newExpressionSize(variable Expression) Size {
-	return Size{variable}
+func newExpressionSize(variable Expression, exact bool) Size {
+	return Size{variable, exact}
 }
 
 // Add adds s1 and s2 and returns a new Size.
 func (s1 Size) Add(s2 Size) Size {
-	return Size{newBinaryOp("+", s1, s2)}
+	return Size{newBinaryOp("+", s1, s2), s1.exact && s2.exact}
 }
 
 // Multiply mupltiplies s1 and s2 and returns a new Size.
 func (s1 Size) Multiply(s2 Size) Size {
-	return Size{newBinaryOp("*", s1, s2)}
+	return Size{newBinaryOp("*", s1, s2), s1.exact && s2.exact}
 }
diff --git a/nexgb/xgbgen/translation.go b/nexgb/xgbgen/translation.go
index b7e67e2..f595e5f 100644
--- a/nexgb/xgbgen/translation.go
+++ b/nexgb/xgbgen/translation.go
@@ -43,7 +43,7 @@ func (xml *XML) Translate(parent *Protocol) *Protocol {
 		newBaseType := &Base{
 			srcName: srcName,
 			xmlName: xmlName,
-			size:    newFixedSize(BaseTypeSizes[xmlName]),
+			size:    newFixedSize(BaseTypeSizes[xmlName], true),
 		}
 		protocol.Types = append(protocol.Types, newBaseType)
 	}
diff --git a/nexgb/xgbgen/type.go b/nexgb/xgbgen/type.go
index ded5be2..59f1a2d 100644
--- a/nexgb/xgbgen/type.go
+++ b/nexgb/xgbgen/type.go
@@ -154,7 +154,7 @@ func (r *Resource) XmlName() string {
 }
 
 func (r *Resource) Size() Size {
-	return newFixedSize(BaseTypeSizes["Id"])
+	return newFixedSize(BaseTypeSizes["Id"], true)
 }
 
 func (r *Resource) Initialize(p *Protocol) {
@@ -201,7 +201,7 @@ func (e *Event) XmlName() string {
 }
 
 func (e *Event) Size() Size {
-	return newExpressionSize(&Value{v: 32})
+	return newExpressionSize(&Value{v: 32}, true)
 }
 
 func (e *Event) Initialize(p *Protocol) {
@@ -231,7 +231,7 @@ func (e *EventCopy) XmlName() string {
 }
 
 func (e *EventCopy) Size() Size {
-	return newExpressionSize(&Value{v: 32})
+	return newExpressionSize(&Value{v: 32}, true)
 }
 
 func (e *EventCopy) Initialize(p *Protocol) {
@@ -262,7 +262,7 @@ func (e *Error) XmlName() string {
 }
 
 func (e *Error) Size() Size {
-	return newExpressionSize(&Value{v: 32})
+	return newExpressionSize(&Value{v: 32}, true)
 }
 
 func (e *Error) Initialize(p *Protocol) {
@@ -296,7 +296,7 @@ func (e *ErrorCopy) XmlName() string {
 }
 
 func (e *ErrorCopy) Size() Size {
-	return newExpressionSize(&Value{v: 32})
+	return newExpressionSize(&Value{v: 32}, true)
 }
 
 func (e *ErrorCopy) Initialize(p *Protocol) {
@@ -330,7 +330,7 @@ func (s *Struct) XmlName() string {
 }
 
 func (s *Struct) Size() Size {
-	size := newFixedSize(0)
+	size := newFixedSize(0, true)
 	for _, field := range s.Fields {
 		size = size.Add(field.Size())
 	}
diff --git a/nexgb/xinerama/xinerama.go b/nexgb/xinerama/xinerama.go
index 28410c6..75c773c 100644
--- a/nexgb/xinerama/xinerama.go
+++ b/nexgb/xinerama/xinerama.go
@@ -90,7 +90,7 @@ func (v ScreenInfo) Bytes() []byte {
 	xgb.Put16(buf[b:], v.Height)
 	b += 2
 
-	return buf
+	return buf[:b]
 }
 
 // ScreenInfoListBytes writes a list of ScreenInfo values to a byte slice.
diff --git a/nexgb/xprint/xprint.go b/nexgb/xprint/xprint.go
index 7a7279f..5ed49a0 100644
--- a/nexgb/xprint/xprint.go
+++ b/nexgb/xprint/xprint.go
@@ -336,7 +336,6 @@ func PrinterRead(buf []byte, v *Printer) int {
 		v.Name[i] = String8(buf[b])
 		b += 1
 	}
-	b = xgb.Pad(b)
 
 	v.DescLen = xgb.Get32(buf[b:])
 	b += 4
@@ -346,7 +345,6 @@ func PrinterRead(buf []byte, v *Printer) int {
 		v.Description[i] = String8(buf[b])
 		b += 1
 	}
-	b = xgb.Pad(b)
 
 	return b
 }
@@ -373,7 +371,6 @@ func (v Printer) Bytes() []byte {
 		buf[b] = byte(v.Name[i])
 		b += 1
 	}
-	b = xgb.Pad(b)
 
 	xgb.Put32(buf[b:], v.DescLen)
 	b += 4
@@ -382,9 +379,8 @@ func (v Printer) Bytes() []byte {
 		buf[b] = byte(v.Description[i])
 		b += 1
 	}
-	b = xgb.Pad(b)
 
-	return buf
+	return buf[:b]
 }
 
 // PrinterListBytes writes a list of Printer values to a byte slice.
@@ -496,13 +492,11 @@ func createContextRequest(c *xgb.Conn, ContextId uint32, PrinterNameLen uint32,
 		buf[b] = byte(PrinterName[i])
 		b += 1
 	}
-	b = xgb.Pad(b)
 
 	for i := 0; i < int(LocaleLen); i++ {
 		buf[b] = byte(Locale[i])
 		b += 1
 	}
-	b = xgb.Pad(b)
 
 	return buf
 }
@@ -1003,7 +997,7 @@ func printGetDocumentDataReply(buf []byte) *PrintGetDocumentDataReply {
 
 	v.Data = make([]byte, v.DataLen)
 	copy(v.Data[:v.DataLen], buf[b:])
-	b += xgb.Pad(int(v.DataLen))
+	b += int(v.DataLen)
 
 	return v
 }
@@ -1193,7 +1187,6 @@ func printGetOneAttributesReply(buf []byte) *PrintGetOneAttributesReply {
 		v.Value[i] = String8(buf[b])
 		b += 1
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -1229,7 +1222,6 @@ func printGetOneAttributesRequest(c *xgb.Conn, Context Pcontext, NameLen uint32,
 		buf[b] = byte(Name[i])
 		b += 1
 	}
-	b = xgb.Pad(b)
 
 	return buf
 }
@@ -1441,13 +1433,11 @@ func printGetPrinterListRequest(c *xgb.Conn, PrinterNameLen uint32, LocaleLen ui
 		buf[b] = byte(PrinterName[i])
 		b += 1
 	}
-	b = xgb.Pad(b)
 
 	for i := 0; i < int(LocaleLen); i++ {
 		buf[b] = byte(Locale[i])
 		b += 1
 	}
-	b = xgb.Pad(b)
 
 	return buf
 }
@@ -1707,19 +1697,17 @@ func printPutDocumentDataRequest(c *xgb.Conn, Drawable xproto.Drawable, LenData
 	b += 2
 
 	copy(buf[b:], Data[:LenData])
-	b += xgb.Pad(int(LenData))
+	b += int(LenData)
 
 	for i := 0; i < int(len(DocFormat)); i++ {
 		buf[b] = byte(DocFormat[i])
 		b += 1
 	}
-	b = xgb.Pad(b)
 
 	for i := 0; i < int(len(Options)); i++ {
 		buf[b] = byte(Options[i])
 		b += 1
 	}
-	b = xgb.Pad(b)
 
 	return buf
 }
@@ -1796,7 +1784,6 @@ func printQueryScreensReply(buf []byte) *PrintQueryScreensReply {
 		v.Roots[i] = xproto.Window(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -2091,7 +2078,6 @@ func printSetAttributesRequest(c *xgb.Conn, Context Pcontext, StringLen uint32,
 		buf[b] = byte(Attributes[i])
 		b += 1
 	}
-	b = xgb.Pad(b)
 
 	return buf
 }
diff --git a/nexgb/xproto/xproto.go b/nexgb/xproto/xproto.go
index 36ab545..728f85f 100644
--- a/nexgb/xproto/xproto.go
+++ b/nexgb/xproto/xproto.go
@@ -179,7 +179,7 @@ func (v Arc) Bytes() []byte {
 	xgb.Put16(buf[b:], uint16(v.Angle2))
 	b += 2
 
-	return buf
+	return buf[:b]
 }
 
 // ArcListBytes writes a list of Arc values to a byte slice.
@@ -603,7 +603,7 @@ func (v Char2b) Bytes() []byte {
 	buf[b] = v.Byte2
 	b += 1
 
-	return buf
+	return buf[:b]
 }
 
 // Char2bListBytes writes a list of Char2b values to a byte slice.
@@ -685,7 +685,7 @@ func (v Charinfo) Bytes() []byte {
 	xgb.Put16(buf[b:], v.Attributes)
 	b += 2
 
-	return buf
+	return buf[:b]
 }
 
 // CharinfoListBytes writes a list of Charinfo values to a byte slice.
@@ -932,7 +932,7 @@ func ClientMessageDataUnionData8New(Data8 []byte) ClientMessageDataUnion {
 	buf := make([]byte, 20)
 
 	copy(buf[b:], Data8[:20])
-	b += xgb.Pad(int(20))
+	b += int(20)
 
 	// Create the Union type
 	v := ClientMessageDataUnion{}
@@ -942,7 +942,7 @@ func ClientMessageDataUnionData8New(Data8 []byte) ClientMessageDataUnion {
 	b = 0 // always read the same bytes
 	v.Data8 = make([]byte, 20)
 	copy(v.Data8[:20], buf[b:])
-	b += xgb.Pad(int(20))
+	b += int(20)
 
 	b = 0 // always read the same bytes
 	v.Data16 = make([]uint16, 10)
@@ -950,7 +950,6 @@ func ClientMessageDataUnionData8New(Data8 []byte) ClientMessageDataUnion {
 		v.Data16[i] = xgb.Get16(buf[b:])
 		b += 2
 	}
-	b = xgb.Pad(b)
 
 	b = 0 // always read the same bytes
 	v.Data32 = make([]uint32, 5)
@@ -958,7 +957,6 @@ func ClientMessageDataUnionData8New(Data8 []byte) ClientMessageDataUnion {
 		v.Data32[i] = xgb.Get32(buf[b:])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -972,7 +970,6 @@ func ClientMessageDataUnionData16New(Data16 []uint16) ClientMessageDataUnion {
 		xgb.Put16(buf[b:], Data16[i])
 		b += 2
 	}
-	b = xgb.Pad(b)
 
 	// Create the Union type
 	v := ClientMessageDataUnion{}
@@ -982,7 +979,7 @@ func ClientMessageDataUnionData16New(Data16 []uint16) ClientMessageDataUnion {
 	b = 0 // always read the same bytes
 	v.Data8 = make([]byte, 20)
 	copy(v.Data8[:20], buf[b:])
-	b += xgb.Pad(int(20))
+	b += int(20)
 
 	b = 0 // always read the same bytes
 	v.Data16 = make([]uint16, 10)
@@ -990,7 +987,6 @@ func ClientMessageDataUnionData16New(Data16 []uint16) ClientMessageDataUnion {
 		v.Data16[i] = xgb.Get16(buf[b:])
 		b += 2
 	}
-	b = xgb.Pad(b)
 
 	b = 0 // always read the same bytes
 	v.Data32 = make([]uint32, 5)
@@ -998,7 +994,6 @@ func ClientMessageDataUnionData16New(Data16 []uint16) ClientMessageDataUnion {
 		v.Data32[i] = xgb.Get32(buf[b:])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -1012,7 +1007,6 @@ func ClientMessageDataUnionData32New(Data32 []uint32) ClientMessageDataUnion {
 		xgb.Put32(buf[b:], Data32[i])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	// Create the Union type
 	v := ClientMessageDataUnion{}
@@ -1022,7 +1016,7 @@ func ClientMessageDataUnionData32New(Data32 []uint32) ClientMessageDataUnion {
 	b = 0 // always read the same bytes
 	v.Data8 = make([]byte, 20)
 	copy(v.Data8[:20], buf[b:])
-	b += xgb.Pad(int(20))
+	b += int(20)
 
 	b = 0 // always read the same bytes
 	v.Data16 = make([]uint16, 10)
@@ -1030,7 +1024,6 @@ func ClientMessageDataUnionData32New(Data32 []uint32) ClientMessageDataUnion {
 		v.Data16[i] = xgb.Get16(buf[b:])
 		b += 2
 	}
-	b = xgb.Pad(b)
 
 	b = 0 // always read the same bytes
 	v.Data32 = make([]uint32, 5)
@@ -1038,7 +1031,6 @@ func ClientMessageDataUnionData32New(Data32 []uint32) ClientMessageDataUnion {
 		v.Data32[i] = xgb.Get32(buf[b:])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -1050,7 +1042,7 @@ func ClientMessageDataUnionRead(buf []byte, v *ClientMessageDataUnion) int {
 	b = 0 // re-read the same bytes
 	v.Data8 = make([]byte, 20)
 	copy(v.Data8[:20], buf[b:])
-	b += xgb.Pad(int(20))
+	b += int(20)
 
 	b = 0 // re-read the same bytes
 	v.Data16 = make([]uint16, 10)
@@ -1058,7 +1050,6 @@ func ClientMessageDataUnionRead(buf []byte, v *ClientMessageDataUnion) int {
 		v.Data16[i] = xgb.Get16(buf[b:])
 		b += 2
 	}
-	b = xgb.Pad(b)
 
 	b = 0 // re-read the same bytes
 	v.Data32 = make([]uint32, 5)
@@ -1066,7 +1057,6 @@ func ClientMessageDataUnionRead(buf []byte, v *ClientMessageDataUnion) int {
 		v.Data32[i] = xgb.Get32(buf[b:])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return 20
 }
@@ -1089,7 +1079,7 @@ func (v ClientMessageDataUnion) Bytes() []byte {
 	b := 0
 
 	copy(buf[b:], v.Data8[:20])
-	b += xgb.Pad(int(20))
+	b += int(20)
 	return buf
 }
 
@@ -1189,7 +1179,7 @@ func (v Coloritem) Bytes() []byte {
 
 	b += 1 // padding
 
-	return buf
+	return buf[:b]
 }
 
 // ColoritemListBytes writes a list of Coloritem values to a byte slice.
@@ -1908,7 +1898,7 @@ func (v DepthInfo) Bytes() []byte {
 
 	b += VisualInfoListBytes(buf[b:], v.Visuals)
 
-	return buf
+	return buf[:b]
 }
 
 // DepthInfoListBytes writes a list of DepthInfo values to a byte slice.
@@ -2580,7 +2570,7 @@ func (v Fontprop) Bytes() []byte {
 	xgb.Put32(buf[b:], v.Value)
 	b += 4
 
-	return buf
+	return buf[:b]
 }
 
 // FontpropListBytes writes a list of Fontprop values to a byte slice.
@@ -2646,7 +2636,7 @@ func (v Format) Bytes() []byte {
 
 	b += 5 // padding
 
-	return buf
+	return buf[:b]
 }
 
 // FormatListBytes writes a list of Format values to a byte slice.
@@ -3072,7 +3062,7 @@ func HostRead(buf []byte, v *Host) int {
 
 	v.Address = make([]byte, v.AddressLen)
 	copy(v.Address[:v.AddressLen], buf[b:])
-	b += xgb.Pad(int(v.AddressLen))
+	b += int(v.AddressLen)
 
 	return b
 }
@@ -3101,9 +3091,9 @@ func (v Host) Bytes() []byte {
 	b += 2
 
 	copy(buf[b:], v.Address[:v.AddressLen])
-	b += xgb.Pad(int(v.AddressLen))
+	b += int(v.AddressLen)
 
-	return buf
+	return buf[:b]
 }
 
 // HostListBytes writes a list of Host values to a byte slice.
@@ -3469,7 +3459,7 @@ func KeymapNotifyEventNew(buf []byte) xgb.Event {
 
 	v.Keys = make([]byte, 31)
 	copy(v.Keys[:31], buf[b:])
-	b += xgb.Pad(int(31))
+	b += int(31)
 
 	return v
 }
@@ -3484,7 +3474,7 @@ func (v KeymapNotifyEvent) Bytes() []byte {
 	b += 1
 
 	copy(buf[b:], v.Keys[:31])
-	b += xgb.Pad(int(31))
+	b += int(31)
 
 	return buf
 }
@@ -4323,7 +4313,7 @@ func (v Point) Bytes() []byte {
 	xgb.Put16(buf[b:], uint16(v.Y))
 	b += 2
 
-	return buf
+	return buf[:b]
 }
 
 // PointListBytes writes a list of Point values to a byte slice.
@@ -4506,7 +4496,7 @@ func (v Rectangle) Bytes() []byte {
 	xgb.Put16(buf[b:], v.Height)
 	b += 2
 
-	return buf
+	return buf[:b]
 }
 
 // RectangleListBytes writes a list of Rectangle values to a byte slice.
@@ -4831,7 +4821,7 @@ func (v Rgb) Bytes() []byte {
 
 	b += 2 // padding
 
-	return buf
+	return buf[:b]
 }
 
 // RgbListBytes writes a list of Rgb values to a byte slice.
@@ -4997,7 +4987,7 @@ func (v ScreenInfo) Bytes() []byte {
 
 	b += DepthInfoListBytes(buf[b:], v.AllowedDepths)
 
-	return buf
+	return buf[:b]
 }
 
 // ScreenInfoListBytes writes a list of ScreenInfo values to a byte slice.
@@ -5079,7 +5069,7 @@ func (v Segment) Bytes() []byte {
 	xgb.Put16(buf[b:], uint16(v.Y2))
 	b += 2
 
-	return buf
+	return buf[:b]
 }
 
 // SegmentListBytes writes a list of Segment values to a byte slice.
@@ -5434,9 +5424,9 @@ func (v SetupAuthenticate) Bytes() []byte {
 	b += 2
 
 	copy(buf[b:], v.Reason[:(int(v.Length)*4)])
-	b += xgb.Pad(int((int(v.Length) * 4)))
+	b += int((int(v.Length) * 4))
 
-	return buf
+	return buf[:b]
 }
 
 // SetupAuthenticateListBytes writes a list of SetupAuthenticate values to a byte slice.
@@ -5529,9 +5519,9 @@ func (v SetupFailed) Bytes() []byte {
 	b += 2
 
 	copy(buf[b:], v.Reason[:v.ReasonLen])
-	b += xgb.Pad(int(v.ReasonLen))
+	b += int(v.ReasonLen)
 
-	return buf
+	return buf[:b]
 }
 
 // SetupFailedListBytes writes a list of SetupFailed values to a byte slice.
@@ -5576,9 +5566,11 @@ type SetupInfo struct {
 	MinKeycode               Keycode
 	MaxKeycode               Keycode
 	// padding: 4 bytes
-	Vendor        string       // size: xgb.Pad((int(VendorLen) * 1))
-	PixmapFormats []Format     // size: xgb.Pad((int(PixmapFormatsLen) * 8))
-	Roots         []ScreenInfo // size: ScreenInfoListSize(Roots)
+	Vendor string // size: xgb.Pad((int(VendorLen) * 1))
+	// alignment gap to multiple of 4
+	PixmapFormats []Format // size: xgb.Pad((int(PixmapFormatsLen) * 8))
+	// alignment gap to multiple of 4
+	Roots []ScreenInfo // size: ScreenInfoListSize(Roots)
 }
 
 // SetupInfoRead reads a byte slice into a SetupInfo value.
@@ -5650,9 +5642,13 @@ func SetupInfoRead(buf []byte, v *SetupInfo) int {
 		b += int(v.VendorLen)
 	}
 
+	b = (b + 3) & ^3 // alignment gap
+
 	v.PixmapFormats = make([]Format, v.PixmapFormatsLen)
 	b += FormatReadList(buf[b:], v.PixmapFormats)
 
+	b = (b + 3) & ^3 // alignment gap
+
 	v.Roots = make([]ScreenInfo, v.RootsLen)
 	b += ScreenInfoReadList(buf[b:], v.Roots)
 
@@ -5671,7 +5667,7 @@ func SetupInfoReadList(buf []byte, dest []SetupInfo) int {
 
 // Bytes writes a SetupInfo value to a byte slice.
 func (v SetupInfo) Bytes() []byte {
-	buf := make([]byte, (((40 + xgb.Pad((int(v.VendorLen) * 1))) + xgb.Pad((int(v.PixmapFormatsLen) * 8))) + ScreenInfoListSize(v.Roots)))
+	buf := make([]byte, (((((40 + xgb.Pad((int(v.VendorLen) * 1))) + 4) + xgb.Pad((int(v.PixmapFormatsLen) * 8))) + 4) + ScreenInfoListSize(v.Roots)))
 	b := 0
 
 	buf[b] = v.Status
@@ -5733,13 +5729,17 @@ func (v SetupInfo) Bytes() []byte {
 	b += 4 // padding
 
 	copy(buf[b:], v.Vendor[:v.VendorLen])
-	b += xgb.Pad(int(v.VendorLen))
+	b += int(v.VendorLen)
+
+	b = (b + 3) & ^3 // alignment gap
 
 	b += FormatListBytes(buf[b:], v.PixmapFormats)
 
+	b = (b + 3) & ^3 // alignment gap
+
 	b += ScreenInfoListBytes(buf[b:], v.Roots)
 
-	return buf
+	return buf[:b]
 }
 
 // SetupInfoListBytes writes a list of SetupInfo values to a byte slice.
@@ -5758,7 +5758,7 @@ func SetupInfoListBytes(buf []byte, list []SetupInfo) int {
 func SetupInfoListSize(list []SetupInfo) int {
 	size := 0
 	for _, item := range list {
-		size += (((40 + xgb.Pad((int(item.VendorLen) * 1))) + xgb.Pad((int(item.PixmapFormatsLen) * 8))) + ScreenInfoListSize(item.Roots))
+		size += (((((40 + xgb.Pad((int(item.VendorLen) * 1))) + 4) + xgb.Pad((int(item.PixmapFormatsLen) * 8))) + 4) + ScreenInfoListSize(item.Roots))
 	}
 	return size
 }
@@ -5850,12 +5850,12 @@ func (v SetupRequest) Bytes() []byte {
 	b += 2 // padding
 
 	copy(buf[b:], v.AuthorizationProtocolName[:v.AuthorizationProtocolNameLen])
-	b += xgb.Pad(int(v.AuthorizationProtocolNameLen))
+	b += int(v.AuthorizationProtocolNameLen)
 
 	copy(buf[b:], v.AuthorizationProtocolData[:v.AuthorizationProtocolDataLen])
-	b += xgb.Pad(int(v.AuthorizationProtocolDataLen))
+	b += int(v.AuthorizationProtocolDataLen)
 
-	return buf
+	return buf[:b]
 }
 
 // SetupRequestListBytes writes a list of SetupRequest values to a byte slice.
@@ -5928,9 +5928,9 @@ func (v Str) Bytes() []byte {
 	b += 1
 
 	copy(buf[b:], v.Name[:v.NameLen])
-	b += xgb.Pad(int(v.NameLen))
+	b += int(v.NameLen)
 
-	return buf
+	return buf[:b]
 }
 
 // StrListBytes writes a list of Str values to a byte slice.
@@ -6009,7 +6009,7 @@ func (v Timecoord) Bytes() []byte {
 	xgb.Put16(buf[b:], uint16(v.Y))
 	b += 2
 
-	return buf
+	return buf[:b]
 }
 
 // TimecoordListBytes writes a list of Timecoord values to a byte slice.
@@ -6352,7 +6352,7 @@ func (v VisualInfo) Bytes() []byte {
 
 	b += 4 // padding
 
-	return buf
+	return buf[:b]
 }
 
 // VisualInfoListBytes writes a list of VisualInfo values to a byte slice.
@@ -6588,7 +6588,8 @@ type AllocColorCellsReply struct {
 	MasksLen  uint16
 	// padding: 20 bytes
 	Pixels []uint32 // size: xgb.Pad((int(PixelsLen) * 4))
-	Masks  []uint32 // size: xgb.Pad((int(MasksLen) * 4))
+	// alignment gap to multiple of 4
+	Masks []uint32 // size: xgb.Pad((int(MasksLen) * 4))
 }
 
 // Reply blocks and returns the reply data for a AllocColorCells request.
@@ -6629,14 +6630,14 @@ func allocColorCellsReply(buf []byte) *AllocColorCellsReply {
 		v.Pixels[i] = xgb.Get32(buf[b:])
 		b += 4
 	}
-	b = xgb.Pad(b)
+
+	b = (b + 3) & ^3 // alignment gap
 
 	v.Masks = make([]uint32, v.MasksLen)
 	for i := 0; i < int(v.MasksLen); i++ {
 		v.Masks[i] = xgb.Get32(buf[b:])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -6754,7 +6755,6 @@ func allocColorPlanesReply(buf []byte) *AllocColorPlanesReply {
 		v.Pixels[i] = xgb.Get32(buf[b:])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -6905,7 +6905,7 @@ func allocNamedColorRequest(c *xgb.Conn, Cmap Colormap, NameLen uint16, Name str
 	b += 2 // padding
 
 	copy(buf[b:], Name[:NameLen])
-	b += xgb.Pad(int(NameLen))
+	b += int(NameLen)
 
 	return buf
 }
@@ -7169,7 +7169,7 @@ func changeHostsRequest(c *xgb.Conn, Mode byte, Family byte, AddressLen uint16,
 	b += 2
 
 	copy(buf[b:], Address[:AddressLen])
-	b += xgb.Pad(int(AddressLen))
+	b += int(AddressLen)
 
 	return buf
 }
@@ -7282,7 +7282,6 @@ func changeKeyboardMappingRequest(c *xgb.Conn, KeycodeCount byte, FirstKeycode K
 		xgb.Put32(buf[b:], uint32(Keysyms[i]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return buf
 }
@@ -7416,7 +7415,7 @@ func changePropertyRequest(c *xgb.Conn, Mode byte, Window Window, Property Atom,
 	b += 4
 
 	copy(buf[b:], Data[:((int(DataLen)*int(Format))/8)])
-	b += xgb.Pad(int(((int(DataLen) * int(Format)) / 8)))
+	b += int(((int(DataLen) * int(Format)) / 8))
 
 	return buf
 }
@@ -8822,7 +8821,6 @@ func freeColorsRequest(c *xgb.Conn, Cmap Colormap, PlaneMask uint32, Pixels []ui
 		xgb.Put32(buf[b:], Pixels[i])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return buf
 }
@@ -9316,7 +9314,7 @@ func getImageReply(buf []byte) *GetImageReply {
 
 	v.Data = make([]byte, (int(v.Length) * 4))
 	copy(v.Data[:(int(v.Length)*4)], buf[b:])
-	b += xgb.Pad(int((int(v.Length) * 4)))
+	b += int((int(v.Length) * 4))
 
 	return v
 }
@@ -9516,7 +9514,7 @@ func getKeyboardControlReply(buf []byte) *GetKeyboardControlReply {
 
 	v.AutoRepeats = make([]byte, 32)
 	copy(v.AutoRepeats[:32], buf[b:])
-	b += xgb.Pad(int(32))
+	b += int(32)
 
 	return v
 }
@@ -9601,7 +9599,6 @@ func getKeyboardMappingReply(buf []byte) *GetKeyboardMappingReply {
 		v.Keysyms[i] = Keysym(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -9693,7 +9690,6 @@ func getModifierMappingReply(buf []byte) *GetModifierMappingReply {
 		v.Keycodes[i] = Keycode(buf[b])
 		b += 1
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -9957,7 +9953,7 @@ func getPointerMappingReply(buf []byte) *GetPointerMappingReply {
 
 	v.Map = make([]byte, v.MapLen)
 	copy(v.Map[:v.MapLen], buf[b:])
-	b += xgb.Pad(int(v.MapLen))
+	b += int(v.MapLen)
 
 	return v
 }
@@ -10051,7 +10047,7 @@ func getPropertyReply(buf []byte) *GetPropertyReply {
 
 	v.Value = make([]byte, (int(v.ValueLen) * (int(v.Format) / 8)))
 	copy(v.Value[:(int(v.ValueLen)*(int(v.Format)/8))], buf[b:])
-	b += xgb.Pad(int((int(v.ValueLen) * (int(v.Format) / 8))))
+	b += int((int(v.ValueLen) * (int(v.Format) / 8)))
 
 	return v
 }
@@ -10914,7 +10910,7 @@ func imageText8Request(c *xgb.Conn, StringLen byte, Drawable Drawable, Gc Gconte
 	b += 2
 
 	copy(buf[b:], String[:StringLen])
-	b += xgb.Pad(int(StringLen))
+	b += int(StringLen)
 
 	return buf
 }
@@ -11053,7 +11049,7 @@ func internAtomRequest(c *xgb.Conn, OnlyIfExists bool, NameLen uint16, Name stri
 	b += 2 // padding
 
 	copy(buf[b:], Name[:NameLen])
-	b += xgb.Pad(int(NameLen))
+	b += int(NameLen)
 
 	return buf
 }
@@ -11276,7 +11272,7 @@ func listFontsRequest(c *xgb.Conn, MaxNames uint16, PatternLen uint16, Pattern s
 	b += 2
 
 	copy(buf[b:], Pattern[:PatternLen])
-	b += xgb.Pad(int(PatternLen))
+	b += int(PatternLen)
 
 	return buf
 }
@@ -11434,7 +11430,7 @@ func listFontsWithInfoRequest(c *xgb.Conn, MaxNames uint16, PatternLen uint16, P
 	b += 2
 
 	copy(buf[b:], Pattern[:PatternLen])
-	b += xgb.Pad(int(PatternLen))
+	b += int(PatternLen)
 
 	return buf
 }
@@ -11590,7 +11586,6 @@ func listInstalledColormapsReply(buf []byte) *ListInstalledColormapsReply {
 		v.Cmaps[i] = Colormap(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -11682,7 +11677,6 @@ func listPropertiesReply(buf []byte) *ListPropertiesReply {
 		v.Atoms[i] = Atom(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -11812,7 +11806,7 @@ func lookupColorRequest(c *xgb.Conn, Cmap Colormap, NameLen uint16, Name string)
 	b += 2 // padding
 
 	copy(buf[b:], Name[:NameLen])
-	b += xgb.Pad(int(NameLen))
+	b += int(NameLen)
 
 	return buf
 }
@@ -12008,7 +12002,7 @@ func openFontRequest(c *xgb.Conn, Fid Font, NameLen uint16, Name string) []byte
 	b += 2 // padding
 
 	copy(buf[b:], Name[:NameLen])
-	b += xgb.Pad(int(NameLen))
+	b += int(NameLen)
 
 	return buf
 }
@@ -12441,7 +12435,7 @@ func polyText16Request(c *xgb.Conn, Drawable Drawable, Gc Gcontext, X int16, Y i
 	b += 2
 
 	copy(buf[b:], Items[:len(Items)])
-	b += xgb.Pad(int(len(Items)))
+	b += int(len(Items))
 
 	return buf
 }
@@ -12501,7 +12495,7 @@ func polyText8Request(c *xgb.Conn, Drawable Drawable, Gc Gcontext, X int16, Y in
 	b += 2
 
 	copy(buf[b:], Items[:len(Items)])
-	b += xgb.Pad(int(len(Items)))
+	b += int(len(Items))
 
 	return buf
 }
@@ -12576,7 +12570,7 @@ func putImageRequest(c *xgb.Conn, Format byte, Drawable Drawable, Gc Gcontext, W
 	b += 2 // padding
 
 	copy(buf[b:], Data[:len(Data)])
-	b += xgb.Pad(int(len(Data)))
+	b += int(len(Data))
 
 	return buf
 }
@@ -12762,7 +12756,6 @@ func queryColorsRequest(c *xgb.Conn, Cmap Colormap, Pixels []uint32) []byte {
 		xgb.Put32(buf[b:], Pixels[i])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return buf
 }
@@ -12864,7 +12857,7 @@ func queryExtensionRequest(c *xgb.Conn, NameLen uint16, Name string) []byte {
 	b += 2 // padding
 
 	copy(buf[b:], Name[:NameLen])
-	b += xgb.Pad(int(NameLen))
+	b += int(NameLen)
 
 	return buf
 }
@@ -12911,7 +12904,8 @@ type QueryFontReply struct {
 	FontDescent    int16
 	CharInfosLen   uint32
 	Properties     []Fontprop // size: xgb.Pad((int(PropertiesLen) * 8))
-	CharInfos      []Charinfo // size: xgb.Pad((int(CharInfosLen) * 12))
+	// alignment gap to multiple of 4
+	CharInfos []Charinfo // size: xgb.Pad((int(CharInfosLen) * 12))
 }
 
 // Reply blocks and returns the reply data for a QueryFont request.
@@ -12989,6 +12983,8 @@ func queryFontReply(buf []byte) *QueryFontReply {
 	v.Properties = make([]Fontprop, v.PropertiesLen)
 	b += FontpropReadList(buf[b:], v.Properties)
 
+	b = (b + 3) & ^3 // alignment gap
+
 	v.CharInfos = make([]Charinfo, v.CharInfosLen)
 	b += CharinfoReadList(buf[b:], v.CharInfos)
 
@@ -13072,7 +13068,7 @@ func queryKeymapReply(buf []byte) *QueryKeymapReply {
 
 	v.Keys = make([]byte, 32)
 	copy(v.Keys[:32], buf[b:])
-	b += xgb.Pad(int(32))
+	b += int(32)
 
 	return v
 }
@@ -13392,7 +13388,6 @@ func queryTreeReply(buf []byte) *QueryTreeReply {
 		v.Children[i] = Window(xgb.Get32(buf[b:]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -13596,7 +13591,6 @@ func rotatePropertiesRequest(c *xgb.Conn, Window Window, AtomsLen uint16, Delta
 		xgb.Put32(buf[b:], uint32(Atoms[i]))
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return buf
 }
@@ -13655,7 +13649,7 @@ func sendEventRequest(c *xgb.Conn, Propagate bool, Destination Window, EventMask
 	b += 4
 
 	copy(buf[b:], Event[:32])
-	b += xgb.Pad(int(32))
+	b += int(32)
 
 	return buf
 }
@@ -13861,7 +13855,7 @@ func setDashesRequest(c *xgb.Conn, Gc Gcontext, DashOffset uint16, DashesLen uin
 	b += 2
 
 	copy(buf[b:], Dashes[:DashesLen])
-	b += xgb.Pad(int(DashesLen))
+	b += int(DashesLen)
 
 	return buf
 }
@@ -14047,7 +14041,6 @@ func setModifierMappingRequest(c *xgb.Conn, KeycodesPerModifier byte, Keycodes [
 		buf[b] = byte(Keycodes[i])
 		b += 1
 	}
-	b = xgb.Pad(b)
 
 	return buf
 }
@@ -14126,7 +14119,7 @@ func setPointerMappingRequest(c *xgb.Conn, MapLen byte, Map []byte) []byte {
 	b += 2
 
 	copy(buf[b:], Map[:MapLen])
-	b += xgb.Pad(int(MapLen))
+	b += int(MapLen)
 
 	return buf
 }
@@ -14347,7 +14340,7 @@ func storeNamedColorRequest(c *xgb.Conn, Flags byte, Cmap Colormap, Pixel uint32
 	b += 2 // padding
 
 	copy(buf[b:], Name[:NameLen])
-	b += xgb.Pad(int(NameLen))
+	b += int(NameLen)
 
 	return buf
 }
diff --git a/nexgb/xproto/xproto_test.go b/nexgb/xproto/xproto_test.go
index 44d3285..a5bec71 100644
--- a/nexgb/xproto/xproto_test.go
+++ b/nexgb/xproto/xproto_test.go
@@ -204,6 +204,23 @@ func TestWindowEvents(t *testing.T) {
 	}
 }
 
+// Calls GetFontPath function, Issue #12
+func TestGetFontPath(t *testing.T) {
+	fontPathReply, err := GetFontPath(X).Reply()
+	if err != nil {
+		t.Fatalf("GetFontPath: %v", err)
+	}
+	_ = fontPathReply
+}
+
+func TestListFonts(t *testing.T) {
+	listFontsReply, err := ListFonts(X, 10, 1, "*").Reply()
+	if err != nil {
+		t.Fatalf("ListFonts: %v", err)
+	}
+	_ = listFontsReply
+}
+
 /******************************************************************************/
 // Benchmarks
 /******************************************************************************/
diff --git a/nexgb/xselinux/xselinux.go b/nexgb/xselinux/xselinux.go
index a4cd35e..87d8f98 100644
--- a/nexgb/xselinux/xselinux.go
+++ b/nexgb/xselinux/xselinux.go
@@ -100,12 +100,12 @@ func (v ListItem) Bytes() []byte {
 	b += 4
 
 	copy(buf[b:], v.ObjectContext[:v.ObjectContextLen])
-	b += xgb.Pad(int(v.ObjectContextLen))
+	b += int(v.ObjectContextLen)
 
 	copy(buf[b:], v.DataContext[:v.DataContextLen])
-	b += xgb.Pad(int(v.DataContextLen))
+	b += int(v.DataContextLen)
 
-	return buf
+	return buf[:b]
 }
 
 // ListItemListBytes writes a list of ListItem values to a byte slice.
@@ -1766,7 +1766,7 @@ func setDeviceContextRequest(c *xgb.Conn, Device uint32, ContextLen uint32, Cont
 	b += 4
 
 	copy(buf[b:], Context[:ContextLen])
-	b += xgb.Pad(int(ContextLen))
+	b += int(ContextLen)
 
 	return buf
 }
@@ -1824,7 +1824,7 @@ func setDeviceCreateContextRequest(c *xgb.Conn, ContextLen uint32, Context strin
 	b += 4
 
 	copy(buf[b:], Context[:ContextLen])
-	b += xgb.Pad(int(ContextLen))
+	b += int(ContextLen)
 
 	return buf
 }
@@ -1882,7 +1882,7 @@ func setPropertyCreateContextRequest(c *xgb.Conn, ContextLen uint32, Context str
 	b += 4
 
 	copy(buf[b:], Context[:ContextLen])
-	b += xgb.Pad(int(ContextLen))
+	b += int(ContextLen)
 
 	return buf
 }
@@ -1940,7 +1940,7 @@ func setPropertyUseContextRequest(c *xgb.Conn, ContextLen uint32, Context string
 	b += 4
 
 	copy(buf[b:], Context[:ContextLen])
-	b += xgb.Pad(int(ContextLen))
+	b += int(ContextLen)
 
 	return buf
 }
@@ -1998,7 +1998,7 @@ func setSelectionCreateContextRequest(c *xgb.Conn, ContextLen uint32, Context st
 	b += 4
 
 	copy(buf[b:], Context[:ContextLen])
-	b += xgb.Pad(int(ContextLen))
+	b += int(ContextLen)
 
 	return buf
 }
@@ -2056,7 +2056,7 @@ func setSelectionUseContextRequest(c *xgb.Conn, ContextLen uint32, Context strin
 	b += 4
 
 	copy(buf[b:], Context[:ContextLen])
-	b += xgb.Pad(int(ContextLen))
+	b += int(ContextLen)
 
 	return buf
 }
@@ -2114,7 +2114,7 @@ func setWindowCreateContextRequest(c *xgb.Conn, ContextLen uint32, Context strin
 	b += 4
 
 	copy(buf[b:], Context[:ContextLen])
-	b += xgb.Pad(int(ContextLen))
+	b += int(ContextLen)
 
 	return buf
 }
diff --git a/nexgb/xv/xv.go b/nexgb/xv/xv.go
index ec87d02..1c406b0 100644
--- a/nexgb/xv/xv.go
+++ b/nexgb/xv/xv.go
@@ -45,7 +45,8 @@ type AdaptorInfo struct {
 	NumFormats uint16
 	Type       byte
 	// padding: 1 bytes
-	Name    string   // size: xgb.Pad((int(NameSize) * 1))
+	Name string // size: xgb.Pad((int(NameSize) * 1))
+	// alignment gap to multiple of 4
 	Formats []Format // size: xgb.Pad((int(NumFormats) * 8))
 }
 
@@ -77,6 +78,8 @@ func AdaptorInfoRead(buf []byte, v *AdaptorInfo) int {
 		b += int(v.NameSize)
 	}
 
+	b = (b + 3) & ^3 // alignment gap
+
 	v.Formats = make([]Format, v.NumFormats)
 	b += FormatReadList(buf[b:], v.Formats)
 
@@ -95,7 +98,7 @@ func AdaptorInfoReadList(buf []byte, dest []AdaptorInfo) int {
 
 // Bytes writes a AdaptorInfo value to a byte slice.
 func (v AdaptorInfo) Bytes() []byte {
-	buf := make([]byte, ((12 + xgb.Pad((int(v.NameSize) * 1))) + xgb.Pad((int(v.NumFormats) * 8))))
+	buf := make([]byte, (((12 + xgb.Pad((int(v.NameSize) * 1))) + 4) + xgb.Pad((int(v.NumFormats) * 8))))
 	b := 0
 
 	xgb.Put32(buf[b:], uint32(v.BaseId))
@@ -116,11 +119,13 @@ func (v AdaptorInfo) Bytes() []byte {
 	b += 1 // padding
 
 	copy(buf[b:], v.Name[:v.NameSize])
-	b += xgb.Pad(int(v.NameSize))
+	b += int(v.NameSize)
+
+	b = (b + 3) & ^3 // alignment gap
 
 	b += FormatListBytes(buf[b:], v.Formats)
 
-	return buf
+	return buf[:b]
 }
 
 // AdaptorInfoListBytes writes a list of AdaptorInfo values to a byte slice.
@@ -139,7 +144,7 @@ func AdaptorInfoListBytes(buf []byte, list []AdaptorInfo) int {
 func AdaptorInfoListSize(list []AdaptorInfo) int {
 	size := 0
 	for _, item := range list {
-		size += ((12 + xgb.Pad((int(item.NameSize) * 1))) + xgb.Pad((int(item.NumFormats) * 8)))
+		size += (((12 + xgb.Pad((int(item.NameSize) * 1))) + 4) + xgb.Pad((int(item.NumFormats) * 8)))
 	}
 	return size
 }
@@ -211,9 +216,9 @@ func (v AttributeInfo) Bytes() []byte {
 	b += 4
 
 	copy(buf[b:], v.Name[:v.Size])
-	b += xgb.Pad(int(v.Size))
+	b += int(v.Size)
 
-	return buf
+	return buf[:b]
 }
 
 // AttributeInfoListBytes writes a list of AttributeInfo values to a byte slice.
@@ -462,9 +467,9 @@ func (v EncodingInfo) Bytes() []byte {
 	}
 
 	copy(buf[b:], v.Name[:v.NameSize])
-	b += xgb.Pad(int(v.NameSize))
+	b += int(v.NameSize)
 
-	return buf
+	return buf[:b]
 }
 
 // EncodingInfoListBytes writes a list of EncodingInfo values to a byte slice.
@@ -532,7 +537,7 @@ func (v Format) Bytes() []byte {
 
 	b += 3 // padding
 
-	return buf
+	return buf[:b]
 }
 
 // FormatListBytes writes a list of Format values to a byte slice.
@@ -563,8 +568,9 @@ type Image struct {
 	DataSize  uint32
 	NumPlanes uint32
 	Pitches   []uint32 // size: xgb.Pad((int(NumPlanes) * 4))
-	Offsets   []uint32 // size: xgb.Pad((int(NumPlanes) * 4))
-	Data      []byte   // size: xgb.Pad((int(DataSize) * 1))
+	// alignment gap to multiple of 4
+	Offsets []uint32 // size: xgb.Pad((int(NumPlanes) * 4))
+	Data    []byte   // size: xgb.Pad((int(DataSize) * 1))
 }
 
 // ImageRead reads a byte slice into a Image value.
@@ -591,18 +597,18 @@ func ImageRead(buf []byte, v *Image) int {
 		v.Pitches[i] = xgb.Get32(buf[b:])
 		b += 4
 	}
-	b = xgb.Pad(b)
+
+	b = (b + 3) & ^3 // alignment gap
 
 	v.Offsets = make([]uint32, v.NumPlanes)
 	for i := 0; i < int(v.NumPlanes); i++ {
 		v.Offsets[i] = xgb.Get32(buf[b:])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	v.Data = make([]byte, v.DataSize)
 	copy(v.Data[:v.DataSize], buf[b:])
-	b += xgb.Pad(int(v.DataSize))
+	b += int(v.DataSize)
 
 	return b
 }
@@ -619,7 +625,7 @@ func ImageReadList(buf []byte, dest []Image) int {
 
 // Bytes writes a Image value to a byte slice.
 func (v Image) Bytes() []byte {
-	buf := make([]byte, (((16 + xgb.Pad((int(v.NumPlanes) * 4))) + xgb.Pad((int(v.NumPlanes) * 4))) + xgb.Pad((int(v.DataSize) * 1))))
+	buf := make([]byte, ((((16 + xgb.Pad((int(v.NumPlanes) * 4))) + 4) + xgb.Pad((int(v.NumPlanes) * 4))) + xgb.Pad((int(v.DataSize) * 1))))
 	b := 0
 
 	xgb.Put32(buf[b:], v.Id)
@@ -641,18 +647,18 @@ func (v Image) Bytes() []byte {
 		xgb.Put32(buf[b:], v.Pitches[i])
 		b += 4
 	}
-	b = xgb.Pad(b)
+
+	b = (b + 3) & ^3 // alignment gap
 
 	for i := 0; i < int(v.NumPlanes); i++ {
 		xgb.Put32(buf[b:], v.Offsets[i])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	copy(buf[b:], v.Data[:v.DataSize])
-	b += xgb.Pad(int(v.DataSize))
+	b += int(v.DataSize)
 
-	return buf
+	return buf[:b]
 }
 
 // ImageListBytes writes a list of Image values to a byte slice.
@@ -671,7 +677,7 @@ func ImageListBytes(buf []byte, list []Image) int {
 func ImageListSize(list []Image) int {
 	size := 0
 	for _, item := range list {
-		size += (((16 + xgb.Pad((int(item.NumPlanes) * 4))) + xgb.Pad((int(item.NumPlanes) * 4))) + xgb.Pad((int(item.DataSize) * 1)))
+		size += ((((16 + xgb.Pad((int(item.NumPlanes) * 4))) + 4) + xgb.Pad((int(item.NumPlanes) * 4))) + xgb.Pad((int(item.DataSize) * 1)))
 	}
 	return size
 }
@@ -723,7 +729,7 @@ func ImageFormatInfoRead(buf []byte, v *ImageFormatInfo) int {
 
 	v.Guid = make([]byte, 16)
 	copy(v.Guid[:16], buf[b:])
-	b += xgb.Pad(int(16))
+	b += int(16)
 
 	v.Bpp = buf[b]
 	b += 1
@@ -781,7 +787,7 @@ func ImageFormatInfoRead(buf []byte, v *ImageFormatInfo) int {
 
 	v.VcompOrder = make([]byte, 32)
 	copy(v.VcompOrder[:32], buf[b:])
-	b += xgb.Pad(int(32))
+	b += int(32)
 
 	v.VscanlineOrder = buf[b]
 	b += 1
@@ -818,7 +824,7 @@ func (v ImageFormatInfo) Bytes() []byte {
 	b += 2 // padding
 
 	copy(buf[b:], v.Guid[:16])
-	b += xgb.Pad(int(16))
+	b += int(16)
 
 	buf[b] = v.Bpp
 	b += 1
@@ -875,14 +881,14 @@ func (v ImageFormatInfo) Bytes() []byte {
 	b += 4
 
 	copy(buf[b:], v.VcompOrder[:32])
-	b += xgb.Pad(int(32))
+	b += int(32)
 
 	buf[b] = v.VscanlineOrder
 	b += 1
 
 	b += 11 // padding
 
-	return buf
+	return buf[:b]
 }
 
 // ImageFormatInfoListBytes writes a list of ImageFormatInfo values to a byte slice.
@@ -1052,7 +1058,7 @@ func (v Rational) Bytes() []byte {
 	xgb.Put32(buf[b:], uint32(v.Denominator))
 	b += 4
 
-	return buf
+	return buf[:b]
 }
 
 // RationalListBytes writes a list of Rational values to a byte slice.
@@ -1730,7 +1736,7 @@ func putImageRequest(c *xgb.Conn, Port Port, Drawable xproto.Drawable, Gc xproto
 	b += 2
 
 	copy(buf[b:], Data[:len(Data)])
-	b += xgb.Pad(int(len(Data)))
+	b += int(len(Data))
 
 	return buf
 }
@@ -2335,6 +2341,7 @@ type QueryImageAttributesReply struct {
 	Height    uint16
 	// padding: 12 bytes
 	Pitches []uint32 // size: xgb.Pad((int(NumPlanes) * 4))
+	// alignment gap to multiple of 4
 	Offsets []uint32 // size: xgb.Pad((int(NumPlanes) * 4))
 }
 
@@ -2382,14 +2389,14 @@ func queryImageAttributesReply(buf []byte) *QueryImageAttributesReply {
 		v.Pitches[i] = xgb.Get32(buf[b:])
 		b += 4
 	}
-	b = xgb.Pad(b)
+
+	b = (b + 3) & ^3 // alignment gap
 
 	v.Offsets = make([]uint32, v.NumPlanes)
 	for i := 0; i < int(v.NumPlanes); i++ {
 		v.Offsets[i] = xgb.Get32(buf[b:])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
diff --git a/nexgb/xvmc/xvmc.go b/nexgb/xvmc/xvmc.go
index cd82b33..a574a21 100644
--- a/nexgb/xvmc/xvmc.go
+++ b/nexgb/xvmc/xvmc.go
@@ -156,7 +156,7 @@ func (v SurfaceInfo) Bytes() []byte {
 	xgb.Put32(buf[b:], v.Flags)
 	b += 4
 
-	return buf
+	return buf[:b]
 }
 
 // SurfaceInfoListBytes writes a list of SurfaceInfo values to a byte slice.
@@ -275,7 +275,6 @@ func createContextReply(buf []byte) *CreateContextReply {
 		v.PrivData[i] = xgb.Get32(buf[b:])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -397,7 +396,7 @@ func createSubpictureReply(buf []byte) *CreateSubpictureReply {
 
 	v.ComponentOrder = make([]byte, 4)
 	copy(v.ComponentOrder[:4], buf[b:])
-	b += xgb.Pad(int(4))
+	b += int(4)
 
 	b += 12 // padding
 
@@ -406,7 +405,6 @@ func createSubpictureReply(buf []byte) *CreateSubpictureReply {
 		v.PrivData[i] = xgb.Get32(buf[b:])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
@@ -513,7 +511,6 @@ func createSurfaceReply(buf []byte) *CreateSurfaceReply {
 		v.PrivData[i] = xgb.Get32(buf[b:])
 		b += 4
 	}
-	b = xgb.Pad(b)
 
 	return v
 }
-- 
cgit v1.2.3-70-g09d2