gofmt

8 files changed, 30 insertions, 30 deletions

diff --git a/nexgb/conn.go b/nexgb/conn.go
index bb2f413..7f4cf08 100644
--- a/nexgb/conn.go
+++ b/nexgb/conn.go
@@ -162,7 +162,7 @@ func (c *Conn) dial(display string) error {
 			protocol = "tcp"
 		}
 		c.conn, err = net.Dial(protocol,
-							   c.host+":"+strconv.Itoa(6000+c.DisplayNumber))
+			c.host+":"+strconv.Itoa(6000+c.DisplayNumber))
 	} else {
 		c.conn, err = net.Dial("unix", "/tmp/.X11-unix/X"+c.display)
 	}
diff --git a/nexgb/doc.go b/nexgb/doc.go
index a5bb6fe..64540e9 100644
--- a/nexgb/doc.go
+++ b/nexgb/doc.go
@@ -15,8 +15,8 @@ https://github.com/BurntSushi/xgbutil
 Example
 
 This is an extremely terse example that demonstrates how to connect to X,
-create a window, listen to StructureNotify events and Key{Press,Release} 
-events, map the window, and print out all events received. An example with 
+create a window, listen to StructureNotify events and Key{Press,Release}
+events, map the window, and print out all events received. An example with
 accompanying documentation can be found in examples/create-window.
 
 	package main
@@ -111,11 +111,11 @@ evidence of this claim, please see the benchmarks in xproto/xproto_test.go.
 
 Tests
 
-xproto/xproto_test.go contains a number of contrived tests that stress 
-particular corners of XGB that I presume could be problem areas. Namely: 
-requests with no replies, requests with replies, checked errors, unchecked 
-errors, sequence number wrapping, cookie buffer flushing (i.e., forcing a round 
-trip every N requests made that don't have a reply), getting/setting properties 
+xproto/xproto_test.go contains a number of contrived tests that stress
+particular corners of XGB that I presume could be problem areas. Namely:
+requests with no replies, requests with replies, checked errors, unchecked
+errors, sequence number wrapping, cookie buffer flushing (i.e., forcing a round
+trip every N requests made that don't have a reply), getting/setting properties
 and creating a window and listening to StructureNotify events.
 
 Code Generator
@@ -131,15 +131,15 @@ What works
 
 I am reasonably confident that the core X protocol is in full working form. I've
 also tested the Xinerama and RandR extensions sparingly. Many of the other
-existing extensions have Go source generated (and are compilable) and are 
-included in this package, but I am currently unsure of their status. They 
+existing extensions have Go source generated (and are compilable) and are
+included in this package, but I am currently unsure of their status. They
 *should* work.
 
 What does not work
 
 XKB is the only extension that intentionally does not work, although I suspect
 that GLX also does not work (however, there is Go source code for GLX that
-compiles, unlike XKB). I don't currently have any intention of getting XKB 
+compiles, unlike XKB). I don't currently have any intention of getting XKB
 working, due to its complexity and my current mental incapacity to test it.
 
 */
diff --git a/nexgb/xgb.go b/nexgb/xgb.go
index b123ba1..3078c17 100644
--- a/nexgb/xgb.go
+++ b/nexgb/xgb.go
@@ -29,7 +29,7 @@ const (
 	xidBuffer = 5
 
 	// seqBuffer represents the queue size of the sequence number channel.
-	// I don't think this value matters much, since sequence number generation 
+	// I don't think this value matters much, since sequence number generation
 	// is not that expensive.
 	seqBuffer = 5
 
@@ -132,7 +132,7 @@ var NewEventFuncs = make(map[int]NewEventFun)
 
 // NewExtEventFuncs is a temporary map that stores event constructor functions
 // for each extension. When an extension is initialized, each event for that
-// extension is added to the 'NewEventFuncs' map. It should not be used. It is 
+// extension is added to the 'NewEventFuncs' map. It should not be used. It is
 // exported for use in the extension sub-packages.
 var NewExtEventFuncs = make(map[string]map[int]NewEventFun)
 
@@ -195,11 +195,11 @@ func (conn *Conn) generateXIds() {
 	defer close(conn.xidChan)
 
 	// This requires some explanation. From the horse's mouth:
-	// "The resource-id-mask contains a single contiguous set of bits (at least 
-	// 18).  The client allocates resource IDs for types WINDOW, PIXMAP, 
-	// CURSOR, FONT, GCONTEXT, and COLORMAP by choosing a value with only some 
-	// subset of these bits set and ORing it with resource-id-base. Only values 
-	// constructed in this way can be used to name newly created resources over 
+	// "The resource-id-mask contains a single contiguous set of bits (at least
+	// 18).  The client allocates resource IDs for types WINDOW, PIXMAP,
+	// CURSOR, FONT, GCONTEXT, and COLORMAP by choosing a value with only some
+	// subset of these bits set and ORing it with resource-id-base. Only values
+	// constructed in this way can be used to name newly created resources over
 	// this connection."
 	// So for example (using 8 bit integers), the mask might look like:
 	// 00111000
@@ -240,7 +240,7 @@ func (c *Conn) newSequenceId() uint16 {
 // own goroutine.
 // A sequence id is generated for *every* request. It's the identifier used
 // to match up replies with requests.
-// Since sequence ids can only be 16 bit integers we start over at zero when it 
+// Since sequence ids can only be 16 bit integers we start over at zero when it
 // comes time to wrap.
 // N.B. As long as the cookie buffer is less than 2^16, there are no limitations
 // on the number (or kind) of requests made in sequence.
@@ -266,7 +266,7 @@ type request struct {
 	cookie *Cookie
 }
 
-// NewRequest takes the bytes and a cookie of a particular request, constructs 
+// NewRequest takes the bytes and a cookie of a particular request, constructs
 // a request type, and sends it over the Conn.reqChan channel.
 // Note that the sequence number is added to the cookie after it is sent
 // over the request channel, but before it is sent to X.
@@ -500,9 +500,9 @@ func (c *Conn) WaitForEvent() (Event, Error) {
 	return processEventOrError(<-c.eventChan)
 }
 
-// PollForEvent returns the next event from the server if one is available in 
-// the internal queue without blocking. Note that unlike WaitForEvent, both 
-// Event and Error could be nil. Indeed, they are both nil when the event queue 
+// PollForEvent returns the next event from the server if one is available in
+// the internal queue without blocking. Note that unlike WaitForEvent, both
+// Event and Error could be nil. Indeed, they are both nil when the event queue
 // is empty.
 func (c *Conn) PollForEvent() (Event, Error) {
 	select {
diff --git a/nexgb/xgbgen/expression.go b/nexgb/xgbgen/expression.go
index 2047b5f..f88232c 100644
--- a/nexgb/xgbgen/expression.go
+++ b/nexgb/xgbgen/expression.go
@@ -322,7 +322,7 @@ func (e *FieldRef) Initialize(p *Protocol) {
 }
 
 // EnumRef represents a reference to some enumeration field.
-// EnumKind is the "group" an EnumItem is the name of the specific enumeration 
+// EnumKind is the "group" an EnumItem is the name of the specific enumeration
 // value inside that group.
 type EnumRef struct {
 	EnumKind Type
diff --git a/nexgb/xgbgen/field.go b/nexgb/xgbgen/field.go
index 78475f8..16760d4 100644
--- a/nexgb/xgbgen/field.go
+++ b/nexgb/xgbgen/field.go
@@ -138,7 +138,7 @@ func (f *ListField) Length() Size {
 // Size computes the *size* of a list (in bytes).
 // It it typically a simple matter of multiplying the length of the list by
 // the size of the type of the list.
-// But if it's a list of struct where the struct has a list field, we use a 
+// But if it's a list of struct where the struct has a list field, we use a
 // 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 {
diff --git a/nexgb/xgbgen/go_struct.go b/nexgb/xgbgen/go_struct.go
index cb765a0..984a336 100644
--- a/nexgb/xgbgen/go_struct.go
+++ b/nexgb/xgbgen/go_struct.go
@@ -27,7 +27,7 @@ func (s *Struct) Define(c *Context) {
 	}
 }
 
-// Read for a struct creates a function 'ReadStructName' that takes a source 
+// Read for a struct creates a function 'ReadStructName' that takes a source
 // byte slice (i.e., the buffer) and a destination struct, and returns
 // the number of bytes read off the buffer.
 // 'ReadStructName' should only be used to read raw reply data from the wire.
@@ -49,7 +49,7 @@ func (s *Struct) Read(c *Context) {
 }
 
 // ReadList for a struct creates a function 'ReadStructNameList' that takes
-// a source (i.e., the buffer) byte slice, and a destination slice and returns 
+// a source (i.e., the buffer) byte slice, and a destination slice and returns
 // the number of bytes read from the byte slice.
 func (s *Struct) ReadList(c *Context) {
 	c.Putln("// %sReadList reads a byte slice into a list of %s values.",
diff --git a/nexgb/xgbgen/request_reply.go b/nexgb/xgbgen/request_reply.go
index 637266b..b8afe48 100644
--- a/nexgb/xgbgen/request_reply.go
+++ b/nexgb/xgbgen/request_reply.go
@@ -88,7 +88,7 @@ func (r *Request) Size(c *Context) Size {
 	size := newFixedSize(0)
 
 	// 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 
+	// data (from the fields below) between the opcode and the size of the
 	// request. In an extension request, this byte is always occupied
 	// by the opcode of the request (while the first byte is always occupied
 	// by the opcode of the extension).
diff --git a/nexgb/xproto/xproto_test.go b/nexgb/xproto/xproto_test.go
index 8d0ca88..44d3285 100644
--- a/nexgb/xproto/xproto_test.go
+++ b/nexgb/xproto/xproto_test.go
@@ -88,8 +88,8 @@ func TestCookieBuffer(t *testing.T) {
 	TestProperty(t)
 }
 
-// TestSequenceWrap issues (2^16) + n requests w/ replies to guarantee that the 
-// sequence number (which is a 16 bit integer) will wrap. It then issues one 
+// TestSequenceWrap issues (2^16) + n requests w/ replies to guarantee that the
+// sequence number (which is a 16 bit integer) will wrap. It then issues one
 // final request to ensure things still work properly.
 func TestSequenceWrap(t *testing.T) {
 	n := (1 << 16) + 10