vendor dependencies, make some changes to how input is done

vendor/github.com/jezek/xgb/.gitignore

@@ -0,0 +1,2 @@
+xgbgen/xgbgen
+.*.swp

vendor/github.com/jezek/xgb/AUTHORS

@@ -0,0 +1,18 @@
+Andrew Gallant is the maintainer of this fork. What follows is the original
+list of authors for the x-go-binding.
+
+# This is the official list of XGB authors for copyright purposes.
+# This file is distinct from the CONTRIBUTORS files.
+# See the latter for an explanation.
+
+# Names should be added to this file as
+#	Name or Organization <email address>
+# The email address is not required for organizations.
+
+# Please keep the list sorted.
+
+Anthony Martin <ality@pbrane.org>
+Firmansyah Adiputra <frm.adiputra@gmail.com>
+Google Inc.
+Scott Lawrence <bytbox@gmail.com>
+Tor Andersson <tor.andersson@gmail.com>

vendor/github.com/jezek/xgb/CONTRIBUTORS

@@ -0,0 +1,39 @@
+Andrew Gallant is the maintainer of this fork. What follows is the original
+list of contributors for the x-go-binding.
+
+# This is the official list of people who can contribute
+# (and typically have contributed) code to the XGB repository.
+# The AUTHORS file lists the copyright holders; this file
+# lists people.  For example, Google employees are listed here
+# but not in AUTHORS, because Google holds the copyright.
+#
+# The submission process automatically checks to make sure
+# that people submitting code are listed in this file (by email address).
+#
+# Names should be added to this file only after verifying that
+# the individual or the individual's organization has agreed to
+# the appropriate Contributor License Agreement, found here:
+#
+#     http://code.google.com/legal/individual-cla-v1.0.html
+#     http://code.google.com/legal/corporate-cla-v1.0.html
+#
+# The agreement for individuals can be filled out on the web.
+#
+# When adding J Random Contributor's name to this file,
+# either J's name or J's organization's name should be
+# added to the AUTHORS file, depending on whether the
+# individual or corporate CLA was used.
+
+# Names should be added to this file like so:
+#     Name <email address>
+
+# Please keep the list sorted.
+
+Anthony Martin <ality@pbrane.org>
+Firmansyah Adiputra <frm.adiputra@gmail.com>
+Ian Lance Taylor <iant@golang.org>
+Nigel Tao <nigeltao@golang.org>
+Robert Griesemer <gri@golang.org>
+Russ Cox <rsc@golang.org>
+Scott Lawrence <bytbox@gmail.com>
+Tor Andersson <tor.andersson@gmail.com>

vendor/github.com/jezek/xgb/LICENSE

@@ -0,0 +1,42 @@
+// Copyright (c) 2009 The XGB Authors. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Subject to the terms and conditions of this License, Google hereby
+// grants to You a perpetual, worldwide, non-exclusive, no-charge,
+// royalty-free, irrevocable (except as stated in this section) patent
+// license to make, have made, use, offer to sell, sell, import, and
+// otherwise transfer this implementation of XGB, where such license
+// applies only to those patent claims licensable by Google that are
+// necessarily infringed by use of this implementation of XGB. If You
+// institute patent litigation against any entity (including a
+// cross-claim or counterclaim in a lawsuit) alleging that this
+// implementation of XGB or a Contribution incorporated within this
+// implementation of XGB constitutes direct or contributory patent
+// infringement, then any patent licenses granted to You under this
+// License for this implementation of XGB shall terminate as of the date
+// such litigation is filed.

vendor/github.com/jezek/xgb/Makefile

@@ -0,0 +1,80 @@
+# This Makefile is used by the developer. It is not needed in any way to build
+# a checkout of the XGB repository.
+# It will be useful, however, if you are hacking at the code generator.
+# i.e., after making a change to the code generator, run 'make' in the
+# xgb directory. This will build xgbgen and regenerate each sub-package.
+# 'make test' will then run any appropriate tests (just tests xproto right now).
+# 'make bench' will test a couple of benchmarks.
+# 'make build-all' will then try to build each extension. This isn't strictly
+# necessary, but it's a good idea to make sure each sub-package is a valid
+# Go package.
+
+# My path to the X protocol XML descriptions.
+ifndef XPROTO
+XPROTO=/usr/share/xcb
+endif
+
+# All of the XML files in my /usr/share/xcb directory EXCEPT XKB. -_-
+# This is intended to build xgbgen and generate Go code for each supported
+# extension.
+all: build-xgbgen \
+		 bigreq.xml composite.xml damage.xml dpms.xml dri2.xml \
+		 ge.xml glx.xml randr.xml record.xml render.xml res.xml \
+		 screensaver.xml shape.xml shm.xml xc_misc.xml \
+		 xevie.xml xf86dri.xml xf86vidmode.xml xfixes.xml xinerama.xml \
+		 xprint.xml xproto.xml xselinux.xml xtest.xml \
+		 xvmc.xml xv.xml
+
+build-xgbgen:
+	(cd xgbgen && go build)
+
+# Builds each individual sub-package to make sure its valid Go code.
+build-all: bigreq.b composite.b damage.b dpms.b dri2.b ge.b glx.b randr.b \
+					 record.b render.b res.b screensaver.b shape.b shm.b xcmisc.b \
+					 xevie.b xf86dri.b xf86vidmode.b xfixes.b xinerama.b \
+					 xprint.b xproto.b xselinux.b xtest.b xv.b xvmc.b
+
+%.b:
+	(cd $* ; go build)
+
+# Installs each individual sub-package.
+install: bigreq.i composite.i damage.i dpms.i dri2.i ge.i glx.i randr.i \
+					 record.i render.i res.i screensaver.i shape.i shm.i xcmisc.i \
+					 xevie.i xf86dri.i xf86vidmode.i xfixes.i xinerama.i \
+					 xprint.i xproto.i xselinux.i xtest.i xv.i xvmc.i
+	go install
+
+%.i:
+	(cd $* ; go install)
+
+# xc_misc is special because it has an underscore.
+# There's probably a way to do this better, but Makefiles aren't my strong suit.
+xc_misc.xml: build-xgbgen
+	mkdir -p xcmisc
+	xgbgen/xgbgen --proto-path $(XPROTO) $(XPROTO)/xc_misc.xml > xcmisc/xcmisc.go
+
+%.xml: build-xgbgen
+	mkdir -p $*
+	xgbgen/xgbgen --proto-path $(XPROTO) $(XPROTO)/$*.xml > $*/$*.go
+
+# Just test the xproto core protocol for now.
+test:
+	(cd xproto ; go test)
+
+# Force all xproto benchmarks to run and no tests.
+bench:
+	(cd xproto ; go test -run 'nomatch' -bench '.*' -cpu 1,2,3,6)
+
+# gofmt all non-auto-generated code.
+# (auto-generated code is already gofmt'd.)
+# Also do a column check (80 cols) after a gofmt.
+# But don't check columns on auto-generated code, since I don't care if they
+# break 80 cols.
+gofmt:
+	gofmt -w *.go xgbgen/*.go examples/*.go examples/*/*.go xproto/xproto_test.go
+	colcheck *.go xgbgen/*.go examples/*.go examples/*/*.go xproto/xproto_test.go
+
+push:
+	git push origin master
+	git push github master
+

vendor/github.com/jezek/xgb/README

@@ -0,0 +1,62 @@
+XGB is the X Go Binding, which is a low-level API to communicate with the
+core X protocol and many of the X extensions. It is closely modeled after
+XCB and xpyb.
+
+It is thread safe and gets immediate improvement from parallelism when
+GOMAXPROCS > 1. (See the benchmarks in xproto/xproto_test.go for evidence.)
+
+Please see doc.go for more info.
+
+Note that unless you know you need XGB, you can probably make your life
+easier by using a slightly higher level library: xgbutil.
+
+This is a fork of github.com/BurntSushi/xgb
+
+Quick Usage
+===========
+go get github.com/jezek/xgb
+go run go/path/src/github.com/jezek/xgb/examples/create-window/main.go
+
+jezek's Fork
+============
+I've forked the XGB repository from BurntSushi's github to apply some
+patches which caused panics and memory leaks upon close and tests were added,
+to test multiple server close scenarios.
+
+BurntSushi's Fork
+=================
+I've forked the XGB repository from Google Code due to inactivty upstream.
+
+Godoc documentation can be found here:
+https://godoc.org/github.com/BurntSushi/xgb
+
+Much of the code has been rewritten in an effort to support thread safety
+and multiple extensions. Namely, go_client.py has been thrown away in favor
+of an xgbgen package.
+
+The biggest parts that *haven't* been rewritten by me are the connection and
+authentication handshakes. They're inherently messy, and there's really no
+reason to re-work them. The rest of XGB has been completely rewritten.
+
+I like to release my code under the WTFPL, but since I'm starting with someone
+else's work, I'm leaving the original license/contributor/author information
+in tact.
+
+I suppose I can legitimately release xgbgen under the WTFPL. To be fair, it is
+at least as complex as XGB itself. *sigh*
+
+What follows is the original README:
+
+XGB README
+==========
+XGB is the X protocol Go language Binding.
+
+It is the Go equivalent of XCB, the X protocol C-language Binding
+(http://xcb.freedesktop.org/).
+
+Unless otherwise noted, the XGB source files are distributed
+under the BSD-style license found in the LICENSE file.
+
+Contributions should follow the same procedure as for the Go project:
+http://golang.org/doc/contribute.html
+

vendor/github.com/jezek/xgb/STYLE

@@ -0,0 +1,29 @@
+I like to keep all my code to 80 columns or less. I have plenty of screen real 
+estate, but enjoy 80 columns so that I can have multiple code windows open side 
+to side and not be plagued by the ugly auto-wrapping of a text editor.
+
+If you don't oblige me, I will fix any patch you submit to abide 80 columns.
+
+Note that this style restriction does not preclude gofmt, but introduces a few
+peculiarities. The first is that gofmt will occasionally add spacing (typically 
+to comments) that ends up going over 80 columns. Either shorten the comment or 
+put it on its own line.
+
+The second and more common hiccup is when a function definition extends beyond 
+80 columns. If one adds line breaks to keep it below 80 columns, gofmt will 
+indent all subsequent lines in a function definition to the same indentation 
+level of the function body. This results in a less-than-ideal separation 
+between function definition and function body. To remedy this, simply add a 
+line break like so:
+
+  func RestackWindowExtra(xu *xgbutil.XUtil, win xproto.Window, stackMode int,
+    sibling xproto.Window, source int) error {
+
+    return ClientEvent(xu, win, "_NET_RESTACK_WINDOW", source, int(sibling),
+      stackMode)
+  }
+
+Something similar should also be applied to long 'if' or 'for' conditionals, 
+although it would probably be preferrable to break up the conditional to 
+smaller chunks with a few helper variables.
+

vendor/github.com/jezek/xgb/auth.go

@@ -0,0 +1,110 @@
+package xgb
+
+/*
+auth.go contains functions to facilitate the parsing of .Xauthority files.
+
+It is largely unmodified from the original XGB package that I forked.
+*/
+
+import (
+	"encoding/binary"
+	"errors"
+	"io"
+	"os"
+)
+
+// readAuthority reads the X authority file for the DISPLAY.
+// If hostname == "" or hostname == "localhost",
+// then use the system's hostname (as returned by os.Hostname) instead.
+func readAuthority(hostname, display string) (
+	name string, data []byte, err error) {
+
+	// b is a scratch buffer to use and should be at least 256 bytes long
+	// (i.e. it should be able to hold a hostname).
+	b := make([]byte, 256)
+
+	// As per /usr/include/X11/Xauth.h.
+	const familyLocal = 256
+	const familyWild = 65535
+
+	if len(hostname) == 0 || hostname == "localhost" {
+		hostname, err = os.Hostname()
+		if err != nil {
+			return "", nil, err
+		}
+	}
+
+	fname := os.Getenv("XAUTHORITY")
+	if len(fname) == 0 {
+		home := os.Getenv("HOME")
+		if len(home) == 0 {
+			err = errors.New("Xauthority not found: $XAUTHORITY, $HOME not set")
+			return "", nil, err
+		}
+		fname = home + "/.Xauthority"
+	}
+
+	r, err := os.Open(fname)
+	if err != nil {
+		return "", nil, err
+	}
+	defer r.Close()
+
+	for {
+		var family uint16
+		if err := binary.Read(r, binary.BigEndian, &family); err != nil {
+			return "", nil, err
+		}
+
+		addr, err := getString(r, b)
+		if err != nil {
+			return "", nil, err
+		}
+
+		disp, err := getString(r, b)
+		if err != nil {
+			return "", nil, err
+		}
+
+		name0, err := getString(r, b)
+		if err != nil {
+			return "", nil, err
+		}
+
+		data0, err := getBytes(r, b)
+		if err != nil {
+			return "", nil, err
+		}
+
+		addrmatch := (family == familyWild) ||
+			(family == familyLocal && addr == hostname)
+		dispmatch := (disp == "") || (disp == display)
+
+		if addrmatch && dispmatch {
+			return name0, data0, nil
+		}
+	}
+	panic("unreachable")
+}
+
+func getBytes(r io.Reader, b []byte) ([]byte, error) {
+	var n uint16
+	if err := binary.Read(r, binary.BigEndian, &n); err != nil {
+		return nil, err
+	} else if n > uint16(len(b)) {
+		return nil, errors.New("bytes too long for buffer")
+	}
+
+	if _, err := io.ReadFull(r, b[0:n]); err != nil {
+		return nil, err
+	}
+	return b[0:n], nil
+}
+
+func getString(r io.Reader, b []byte) (string, error) {
+	b, err := getBytes(r, b)
+	if err != nil {
+		return "", err
+	}
+	return string(b), nil
+}

vendor/github.com/jezek/xgb/conn.go

@@ -0,0 +1,186 @@
+package xgb
+
+/*
+conn.go contains a couple of functions that do some real dirty work related
+to the initial connection handshake with X.
+
+This code is largely unmodified from the original XGB package that I forked.
+*/
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"net"
+	"os"
+	"strconv"
+	"strings"
+)
+
+// connect connects to the X server given in the 'display' string,
+// and does all the necessary setup handshaking.
+// If 'display' is empty it will be taken from os.Getenv("DISPLAY").
+// Note that you should read and understand the "Connection Setup" of the
+// X Protocol Reference Manual before changing this function:
+// http://goo.gl/4zGQg
+func (c *Conn) connect(display string) error {
+	err := c.dial(display)
+	if err != nil {
+		return err
+	}
+
+	return c.postConnect()
+}
+
+// connect init from to the net.Conn,
+func (c *Conn) connectNet(netConn net.Conn) error {
+	c.conn = netConn
+	return c.postConnect()
+}
+
+// do the postConnect action after Conn get it's underly net.Conn
+func (c *Conn) postConnect() error {
+	// Get authentication data
+	authName, authData, err := readAuthority(c.host, c.display)
+	noauth := false
+	if err != nil {
+		Logger.Printf("Could not get authority info: %v", err)
+		Logger.Println("Trying connection without authority info...")
+		authName = ""
+		authData = []byte{}
+		noauth = true
+	}
+
+	// Assume that the authentication protocol is "MIT-MAGIC-COOKIE-1".
+	if !noauth && (authName != "MIT-MAGIC-COOKIE-1" || len(authData) != 16) {
+		return errors.New("unsupported auth protocol " + authName)
+	}
+
+	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)
+	copy(buf[12:], []byte(authName))
+	copy(buf[12+Pad(len(authName)):], authData)
+	if _, err = c.conn.Write(buf); err != nil {
+		return err
+	}
+
+	head := make([]byte, 8)
+	if _, err = io.ReadFull(c.conn, head[0:8]); err != nil {
+		return err
+	}
+	code := head[0]
+	reasonLen := head[1]
+	major := Get16(head[2:])
+	minor := Get16(head[4:])
+	dataLen := Get16(head[6:])
+
+	if major != 11 || minor != 0 {
+		return fmt.Errorf("x protocol version mismatch: %d.%d", major, minor)
+	}
+
+	buf = make([]byte, int(dataLen)*4+8, int(dataLen)*4+8)
+	copy(buf, head)
+	if _, err = io.ReadFull(c.conn, buf[8:]); err != nil {
+		return err
+	}
+
+	if code == 0 {
+		reason := buf[8 : 8+reasonLen]
+		return fmt.Errorf("x protocol authentication refused: %s",
+			string(reason))
+	}
+
+	// Unfortunately, it isn't really feasible to read the setup bytes here,
+	// since the code to do so is in a different package.
+	// Users must call 'xproto.Setup(X)' to get the setup info.
+	c.SetupBytes = buf
+
+	// But also read stuff that we *need* to get started.
+	c.setupResourceIdBase = Get32(buf[12:])
+	c.setupResourceIdMask = Get32(buf[16:])
+
+	return nil
+}
+
+// dial initializes the actual net connection with X.
+func (c *Conn) dial(display string) error {
+	if len(display) == 0 {
+		display = os.Getenv("DISPLAY")
+	}
+
+	display0 := display
+	if len(display) == 0 {
+		return errors.New("empty display string")
+	}
+
+	colonIdx := strings.LastIndex(display, ":")
+	if colonIdx < 0 {
+		return errors.New("bad display string: " + display0)
+	}
+
+	var protocol, socket string
+
+	if display[0] == '/' {
+		socket = display[0:colonIdx]
+	} else {
+		slashIdx := strings.LastIndex(display, "/")
+		if slashIdx >= 0 {
+			protocol = display[0:slashIdx]
+			c.host = display[slashIdx+1 : colonIdx]
+		} else {
+			c.host = display[0:colonIdx]
+		}
+	}
+
+	display = display[colonIdx+1 : len(display)]
+	if len(display) == 0 {
+		return errors.New("bad display string: " + display0)
+	}
+
+	var scr string
+	dotIdx := strings.LastIndex(display, ".")
+	if dotIdx < 0 {
+		c.display = display[0:]
+	} else {
+		c.display = display[0:dotIdx]
+		scr = display[dotIdx+1:]
+	}
+
+	var err error
+	c.DisplayNumber, err = strconv.Atoi(c.display)
+	if err != nil || c.DisplayNumber < 0 {
+		return errors.New("bad display string: " + display0)
+	}
+
+	if len(scr) != 0 {
+		c.DefaultScreen, err = strconv.Atoi(scr)
+		if err != nil {
+			return errors.New("bad display string: " + display0)
+		}
+	}
+
+	// Connect to server
+	if len(socket) != 0 {
+		c.conn, err = net.Dial("unix", socket+":"+c.display)
+	} else if len(c.host) != 0 && c.host != "unix" {
+		if protocol == "" {
+			protocol = "tcp"
+		}
+		c.conn, err = net.Dial(protocol,
+			c.host+":"+strconv.Itoa(6000+c.DisplayNumber))
+	} else {
+		c.host = ""
+		c.conn, err = net.Dial("unix", "/tmp/.X11-unix/X"+c.display)
+	}
+
+	if err != nil {
+		return errors.New("cannot connect to " + display0 + ": " + err.Error())
+	}
+	return nil
+}

vendor/github.com/jezek/xgb/cookie.go

@@ -0,0 +1,178 @@
+package xgb
+
+import (
+	"errors"
+	"io"
+)
+
+// Cookie is the internal representation of a cookie, where one is generated
+// for *every* request sent by XGB.
+// 'cookie' is most frequently used by embedding it into a more specific
+// kind of cookie, i.e., 'GetInputFocusCookie'.
+type Cookie struct {
+	conn      *Conn
+	Sequence  uint16
+	replyChan chan []byte
+	errorChan chan error
+	pingChan  chan bool
+}
+
+// NewCookie creates a new cookie with the correct channels initialized
+// depending upon the values of 'checked' and 'reply'. Together, there are
+// four different kinds of cookies. (See more detailed comments in the
+// function for more info on those.)
+// Note that a sequence number is not set until just before the request
+// corresponding to this cookie is sent over the wire.
+//
+// Unless you're building requests from bytes by hand, this method should
+// not be used.
+func (c *Conn) NewCookie(checked, reply bool) *Cookie {
+	cookie := &Cookie{
+		conn:      c,
+		Sequence:  0, // we add the sequence id just before sending a request
+		replyChan: nil,
+		errorChan: nil,
+		pingChan:  nil,
+	}
+
+	// There are four different kinds of cookies:
+	// Checked requests with replies get a reply channel and an error channel.
+	// Unchecked requests with replies get a reply channel and a ping channel.
+	// Checked requests w/o replies get a ping channel and an error channel.
+	// Unchecked requests w/o replies get no channels.
+	// The reply channel is used to send reply data.
+	// The error channel is used to send error data.
+	// The ping channel is used when one of the 'reply' or 'error' channels
+	// is missing but the other is present. The ping channel is way to force
+	// the blocking to stop and basically say "the error has been received
+	// in the main event loop" (when the ping channel is coupled with a reply
+	// channel) or "the request you made that has no reply was successful"
+	// (when the ping channel is coupled with an error channel).
+	if checked {
+		cookie.errorChan = make(chan error, 1)
+		if !reply {
+			cookie.pingChan = make(chan bool, 1)
+		}
+	}
+	if reply {
+		cookie.replyChan = make(chan []byte, 1)
+		if !checked {
+			cookie.pingChan = make(chan bool, 1)
+		}
+	}
+
+	return cookie
+}
+
+// Reply detects whether this is a checked or unchecked cookie, and calls
+// 'replyChecked' or 'replyUnchecked' appropriately.
+//
+// Unless you're building requests from bytes by hand, this method should
+// not be used.
+func (c Cookie) Reply() ([]byte, error) {
+	// checked
+	if c.errorChan != nil {
+		return c.replyChecked()
+	}
+	return c.replyUnchecked()
+}
+
+// replyChecked waits for a response on either the replyChan or errorChan
+// channels. If the former arrives, the bytes are returned with a nil error.
+// If the latter arrives, no bytes are returned (nil) and the error received
+// is returned.
+// Returns (nil, io.EOF) when the connection is closed.
+//
+// Unless you're building requests from bytes by hand, this method should
+// not be used.
+func (c Cookie) replyChecked() ([]byte, error) {
+	if c.replyChan == nil {
+		return nil, errors.New("Cannot call 'replyChecked' on a cookie that " +
+			"is not expecting a *reply* or an error.")
+	}
+	if c.errorChan == nil {
+		return nil, errors.New("Cannot call 'replyChecked' on a cookie that " +
+			"is not expecting a reply or an *error*.")
+	}
+
+	select {
+	case reply := <-c.replyChan:
+		return reply, nil
+	case err := <-c.errorChan:
+		return nil, err
+	case <-c.conn.doneRead:
+		// c.conn.readResponses is no more, there will be no replys or errors
+		return nil, io.EOF
+	}
+}
+
+// replyUnchecked waits for a response on either the replyChan or pingChan
+// channels. If the former arrives, the bytes are returned with a nil error.
+// If the latter arrives, no bytes are returned (nil) and a nil error
+// is returned. (In the latter case, the corresponding error can be retrieved
+// from (Wait|Poll)ForEvent asynchronously.)
+// Returns (nil, io.EOF) when the connection is closed.
+// In all honesty, you *probably* don't want to use this method.
+//
+// Unless you're building requests from bytes by hand, this method should
+// not be used.
+func (c Cookie) replyUnchecked() ([]byte, error) {
+	if c.replyChan == nil {
+		return nil, errors.New("Cannot call 'replyUnchecked' on a cookie " +
+			"that is not expecting a *reply*.")
+	}
+
+	select {
+	case reply := <-c.replyChan:
+		return reply, nil
+	case <-c.pingChan:
+		return nil, nil
+	case <-c.conn.doneRead:
+		// c.conn.readResponses is no more, there will be no replys or pings
+		return nil, io.EOF
+	}
+}
+
+// Check is used for checked requests that have no replies. It is a mechanism
+// by which to report "success" or "error" in a synchronous fashion. (Therefore,
+// unchecked requests without replies cannot use this method.)
+// If the request causes an error, it is sent to this cookie's errorChan.
+// If the request was successful, there is no response from the server.
+// Thus, pingChan is sent a value when the *next* reply is read.
+// If no more replies are being processed, we force a round trip request with
+// GetInputFocus.
+// Returns io.EOF error when the connection is closed.
+//
+// Unless you're building requests from bytes by hand, this method should
+// not be used.
+func (c Cookie) Check() error {
+	if c.replyChan != nil {
+		return errors.New("Cannot call 'Check' on a cookie that is " +
+			"expecting a *reply*. Use 'Reply' instead.")
+	}
+	if c.errorChan == nil {
+		return errors.New("Cannot call 'Check' on a cookie that is " +
+			"not expecting a possible *error*.")
+	}
+
+	// First do a quick non-blocking check to see if we've been pinged.
+	select {
+	case err := <-c.errorChan:
+		return err
+	case <-c.pingChan:
+		return nil
+	default:
+	}
+
+	// Now force a round trip and try again, but block this time.
+	c.conn.Sync()
+	select {
+	case err := <-c.errorChan:
+		return err
+	case <-c.pingChan:
+		return nil
+	case <-c.conn.doneRead:
+		// c.conn.readResponses is no more, there will be no errors or pings
+		return io.EOF
+	}
+}

vendor/github.com/jezek/xgb/doc.go

@@ -0,0 +1,146 @@
+/*
+Package XGB provides the X Go Binding, which is a low-level API to communicate
+with the core X protocol and many of the X extensions.
+
+It is *very* closely modeled on XCB, so that experience with XCB (or xpyb) is
+easily translatable to XGB. That is, it uses the same cookie/reply model
+and is thread safe. There are otherwise no major differences (in the API).
+
+Most uses of XGB typically fall under the realm of window manager and GUI kit
+development, but other applications (like pagers, panels, tilers, etc.) may
+also require XGB. Moreover, it is a near certainty that if you need to work
+with X, xgbutil will be of great use to you as well:
+https://github.com/jezek/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
+accompanying documentation can be found in examples/create-window.
+
+	package main
+
+	import (
+		"fmt"
+		"github.com/jezek/xgb"
+		"github.com/jezek/xgb/xproto"
+	)
+
+	func main() {
+		X, err := xgb.NewConn()
+		if err != nil {
+			fmt.Println(err)
+			return
+		}
+
+		wid, _ := xproto.NewWindowId(X)
+		screen := xproto.Setup(X).DefaultScreen(X)
+		xproto.CreateWindow(X, screen.RootDepth, wid, screen.Root,
+			0, 0, 500, 500, 0,
+			xproto.WindowClassInputOutput, screen.RootVisual,
+			xproto.CwBackPixel | xproto.CwEventMask,
+			[]uint32{ // values must be in the order defined by the protocol
+				0xffffffff,
+				xproto.EventMaskStructureNotify |
+				xproto.EventMaskKeyPress |
+				xproto.EventMaskKeyRelease})
+
+		xproto.MapWindow(X, wid)
+		for {
+			ev, xerr := X.WaitForEvent()
+			if ev == nil && xerr == nil {
+				fmt.Println("Both event and error are nil. Exiting...")
+				return
+			}
+
+			if ev != nil {
+				fmt.Printf("Event: %s\n", ev)
+			}
+			if xerr != nil {
+				fmt.Printf("Error: %s\n", xerr)
+			}
+		}
+	}
+
+Xinerama Example
+
+This is another small example that shows how to query Xinerama for geometry
+information of each active head. Accompanying documentation for this example
+can be found in examples/xinerama.
+
+	package main
+
+	import (
+		"fmt"
+		"log"
+		"github.com/jezek/xgb"
+		"github.com/jezek/xgb/xinerama"
+	)
+
+	func main() {
+		X, err := xgb.NewConn()
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		// Initialize the Xinerama extension.
+		// The appropriate 'Init' function must be run for *every*
+		// extension before any of its requests can be used.
+		err = xinerama.Init(X)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		reply, err := xinerama.QueryScreens(X).Reply()
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		fmt.Printf("Number of heads: %d\n", reply.Number)
+		for i, screen := range reply.ScreenInfo {
+			fmt.Printf("%d :: X: %d, Y: %d, Width: %d, Height: %d\n",
+				i, screen.XOrg, screen.YOrg, screen.Width, screen.Height)
+		}
+	}
+
+Parallelism
+
+XGB can benefit greatly from parallelism due to its concurrent design. For
+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
+and creating a window and listening to StructureNotify events.
+
+Code Generator
+
+Both XCB and xpyb use the same Python module (xcbgen) for a code generator. XGB
+(before this fork) used the same code generator as well, but in my attempt to
+add support for more extensions, I found the code generator extremely difficult
+to work with. Therefore, I re-wrote the code generator in Go. It can be found
+in its own sub-package, xgbgen, of xgb. My design of xgbgen includes a rough
+consideration that it could be used for other languages.
+
+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
+*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
+working, due to its complexity and my current mental incapacity to test it.
+
+*/
+package xgb

vendor/github.com/jezek/xgb/help.go

@@ -0,0 +1,105 @@
+package xgb
+
+/*
+help.go is meant to contain a rough hodge podge of functions that are mainly
+used in the auto generated code. Indeed, several functions here are simple
+wrappers so that the sub-packages don't need to be smart about which stdlib
+packages to import.
+
+Also, the 'Get..' and 'Put..' functions are used through the core xgb package
+too. (xgbutil uses them too.)
+*/
+
+import (
+	"fmt"
+	"strings"
+)
+
+// 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)
+}
+
+// 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...)
+}
+
+// Errorf is just a wrapper for fmt.Errorf. Exists for the same reason
+// that 'stringsJoin' and 'sprintf' exists.
+func Errorf(format string, v ...interface{}) error {
+	return fmt.Errorf(format, v...)
+}
+
+// Pad a length to align on 4 bytes.
+func Pad(n int) int {
+	return (n + 3) & ^3
+}
+
+// PopCount counts the number of bits set in a value list mask.
+func PopCount(mask0 int) int {
+	mask := uint32(mask0)
+	n := 0
+	for i := uint32(0); i < 32; i++ {
+		if mask&(1<<i) != 0 {
+			n++
+		}
+	}
+	return n
+}
+
+// Put16 takes a 16 bit integer and copies it into a byte slice.
+func Put16(buf []byte, v uint16) {
+	buf[0] = byte(v)
+	buf[1] = byte(v >> 8)
+}
+
+// Put32 takes a 32 bit integer and copies it into a byte slice.
+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)
+}
+
+// Put64 takes a 64 bit integer and copies it into a byte slice.
+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)
+}
+
+// Get16 constructs a 16 bit integer from the beginning of a byte slice.
+func Get16(buf []byte) uint16 {
+	v := uint16(buf[0])
+	v |= uint16(buf[1]) << 8
+	return v
+}
+
+// Get32 constructs a 32 bit integer from the beginning of a byte slice.
+func Get32(buf []byte) uint32 {
+	v := uint32(buf[0])
+	v |= uint32(buf[1]) << 8
+	v |= uint32(buf[2]) << 16
+	v |= uint32(buf[3]) << 24
+	return v
+}
+
+// Get64 constructs a 64 bit integer from the beginning of a byte slice.
+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
+}

vendor/github.com/jezek/xgb/sync.go

@@ -0,0 +1,29 @@
+package xgb
+
+// Sync sends a round trip request and waits for the response.
+// This forces all pending cookies to be dealt with.
+// You actually shouldn't need to use this like you might with Xlib. Namely,
+// buffers are automatically flushed using Go's channels and round trip requests
+// are forced where appropriate automatically.
+func (c *Conn) Sync() {
+	cookie := c.NewCookie(true, true)
+	c.NewRequest(c.getInputFocusRequest(), cookie)
+	cookie.Reply() // wait for the buffer to clear
+}
+
+// getInputFocusRequest writes the raw bytes to a buffer.
+// It is duplicated from xproto/xproto.go.
+func (c *Conn) getInputFocusRequest() []byte {
+	size := 4
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = 43 // request opcode
+	b += 1
+
+	b += 1                         // padding
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	return buf
+}

vendor/github.com/jezek/xgb/testingTools.go

@@ -0,0 +1,426 @@
+package xgb
+
+import (
+	"bytes"
+	"errors"
+	"io"
+	"net"
+	"regexp"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+)
+
+// Leaks monitor
+
+type goroutine struct {
+	id    int
+	name  string
+	stack []byte
+}
+
+type leaks struct {
+	name       string
+	goroutines map[int]goroutine
+	report     []*leaks
+}
+
+func leaksMonitor(name string, monitors ...*leaks) *leaks {
+	return &leaks{
+		name,
+		leaks{}.collectGoroutines(),
+		monitors,
+	}
+}
+
+// ispired by https://golang.org/src/runtime/debug/stack.go?s=587:606#L21
+// stack returns a formatted stack trace of all goroutines.
+// It calls runtime.Stack with a large enough buffer to capture the entire trace.
+func (_ leaks) stack() []byte {
+	buf := make([]byte, 1024)
+	for {
+		n := runtime.Stack(buf, true)
+		if n < len(buf) {
+			return buf[:n]
+		}
+		buf = make([]byte, 2*len(buf))
+	}
+}
+
+func (l leaks) collectGoroutines() map[int]goroutine {
+	res := make(map[int]goroutine)
+	stacks := bytes.Split(l.stack(), []byte{'\n', '\n'})
+
+	regexpId := regexp.MustCompile(`^\s*goroutine\s*(\d+)`)
+	for _, st := range stacks {
+		lines := bytes.Split(st, []byte{'\n'})
+		if len(lines) < 2 {
+			panic("routine stach has less tnan two lines: " + string(st))
+		}
+
+		idMatches := regexpId.FindSubmatch(lines[0])
+		if len(idMatches) < 2 {
+			panic("no id found in goroutine stack's first line: " + string(lines[0]))
+		}
+		id, err := strconv.Atoi(string(idMatches[1]))
+		if err != nil {
+			panic("converting goroutine id to number error: " + err.Error())
+		}
+		if _, ok := res[id]; ok {
+			panic("2 goroutines with same id: " + strconv.Itoa(id))
+		}
+		name := strings.TrimSpace(string(lines[1]))
+
+		//filter out our stack routine
+		if strings.Contains(name, "xgb.leaks.stack") {
+			continue
+		}
+
+		res[id] = goroutine{id, name, st}
+	}
+	return res
+}
+
+func (l leaks) leakingGoroutines() []goroutine {
+	goroutines := l.collectGoroutines()
+	res := []goroutine{}
+	for id, gr := range goroutines {
+		if _, ok := l.goroutines[id]; ok {
+			continue
+		}
+		res = append(res, gr)
+	}
+	return res
+}
+func (l leaks) checkTesting(t *testing.T) {
+	if len(l.leakingGoroutines()) == 0 {
+		return
+	}
+	leakTimeout := 10 * time.Millisecond
+	time.Sleep(leakTimeout)
+	//t.Logf("possible goroutine leakage, waiting %v", leakTimeout)
+	grs := l.leakingGoroutines()
+	for _, gr := range grs {
+		t.Errorf("%s: %s is leaking", l.name, gr.name)
+		//t.Errorf("%s: %s is leaking\n%v", l.name, gr.name, string(gr.stack))
+	}
+	for _, rl := range l.report {
+		rl.ignoreLeak(grs...)
+	}
+}
+func (l *leaks) ignoreLeak(grs ...goroutine) {
+	for _, gr := range grs {
+		l.goroutines[gr.id] = gr
+	}
+}
+
+// dummy net.Conn
+
+type dAddr struct {
+	s string
+}
+
+func (_ dAddr) Network() string { return "dummy" }
+func (a dAddr) String() string  { return a.s }
+
+var (
+	dNCErrNotImplemented = errors.New("command not implemented")
+	dNCErrClosed         = errors.New("server closed")
+	dNCErrWrite          = errors.New("server write failed")
+	dNCErrRead           = errors.New("server read failed")
+	dNCErrResponse       = errors.New("server response error")
+)
+
+type dNCIoResult struct {
+	n   int
+	err error
+}
+type dNCIo struct {
+	b      []byte
+	result chan dNCIoResult
+}
+
+type dNCCWriteLock struct{}
+type dNCCWriteUnlock struct{}
+type dNCCWriteError struct{}
+type dNCCWriteSuccess struct{}
+type dNCCReadLock struct{}
+type dNCCReadUnlock struct{}
+type dNCCReadError struct{}
+type dNCCReadSuccess struct{}
+
+// dummy net.Conn interface. Needs to be constructed via newDummyNetConn([...]) function.
+type dNC struct {
+	reply   func([]byte) []byte
+	addr    dAddr
+	in, out chan dNCIo
+	control chan interface{}
+	done    chan struct{}
+}
+
+// Results running dummy server, satisfying net.Conn interface for test purposes.
+// 'name' parameter will be returned via (*dNC).Local/RemoteAddr().String()
+// 'reply' parameter function will be runned only on successful (*dNC).Write(b) with 'b' as parameter to 'reply'. The result will be stored in internal buffer and can be retrieved later via (*dNC).Read([...]) method.
+// It is users responsibility to stop and clean up resources with (*dNC).Close, if not needed anymore.
+// By default, the (*dNC).Write([...]) and (*dNC).Read([...]) methods are unlocked and will not result in error.
+//TODO make (*dNC).SetDeadline, (*dNC).SetReadDeadline, (*dNC).SetWriteDeadline work proprely.
+func newDummyNetConn(name string, reply func([]byte) []byte) *dNC {
+
+	s := &dNC{
+		reply,
+		dAddr{name},
+		make(chan dNCIo), make(chan dNCIo),
+		make(chan interface{}),
+		make(chan struct{}),
+	}
+
+	in, out := s.in, chan dNCIo(nil)
+	buf := &bytes.Buffer{}
+	errorRead, errorWrite := false, false
+	lockRead := false
+
+	go func() {
+		defer close(s.done)
+		for {
+			select {
+			case dxsio := <-in:
+				if errorWrite {
+					dxsio.result <- dNCIoResult{0, dNCErrWrite}
+					break
+				}
+
+				response := s.reply(dxsio.b)
+
+				buf.Write(response)
+				dxsio.result <- dNCIoResult{len(dxsio.b), nil}
+
+				if !lockRead && buf.Len() > 0 && out == nil {
+					out = s.out
+				}
+			case dxsio := <-out:
+				if errorRead {
+					dxsio.result <- dNCIoResult{0, dNCErrRead}
+					break
+				}
+
+				n, err := buf.Read(dxsio.b)
+				dxsio.result <- dNCIoResult{n, err}
+
+				if buf.Len() == 0 {
+					out = nil
+				}
+			case ci := <-s.control:
+				if ci == nil {
+					return
+				}
+				switch ci.(type) {
+				case dNCCWriteLock:
+					in = nil
+				case dNCCWriteUnlock:
+					in = s.in
+				case dNCCWriteError:
+					errorWrite = true
+				case dNCCWriteSuccess:
+					errorWrite = false
+				case dNCCReadLock:
+					out = nil
+					lockRead = true
+				case dNCCReadUnlock:
+					lockRead = false
+					if buf.Len() > 0 && out == nil {
+						out = s.out
+					}
+				case dNCCReadError:
+					errorRead = true
+				case dNCCReadSuccess:
+					errorRead = false
+				default:
+				}
+			}
+		}
+	}()
+	return s
+}
+
+// Shuts down dummy net.Conn server. Every blocking or future method calls will do nothing and result in error.
+// Result will be dNCErrClosed if server was allready closed.
+// Server can not be unclosed.
+func (s *dNC) Close() error {
+	select {
+	case s.control <- nil:
+		<-s.done
+		return nil
+	case <-s.done:
+	}
+	return dNCErrClosed
+}
+
+// Performs a write action to server.
+// If not locked by (*dNC).WriteLock, it results in error or success. If locked, this method will block until unlocked, or closed.
+//
+// This method can be set to result in error or success, via (*dNC).WriteError() or (*dNC).WriteSuccess() methods.
+//
+// If setted to result in error, the 'reply' function will NOT be called and internal buffer will NOT increasethe.
+// Result will be (0, dNCErrWrite).
+//
+// If setted to result in success, the 'reply' function will be called and its result will be writen to internal buffer.
+// If there is something in the internal buffer, the (*dNC).Read([...]) will be unblocked (if not previously locked with (*dNC).ReadLock).
+// Result will be (len(b), nil)
+//
+// If server was closed previously, result will be (0, dNCErrClosed).
+func (s *dNC) Write(b []byte) (int, error) {
+	resChan := make(chan dNCIoResult)
+	select {
+	case s.in <- dNCIo{b, resChan}:
+		res := <-resChan
+		return res.n, res.err
+	case <-s.done:
+	}
+	return 0, dNCErrClosed
+}
+
+// Performs a read action from server.
+// If locked by (*dNC).ReadLock(), this method will block until unlocked with (*dNC).ReadUnlock(), or server closes.
+//
+// If not locked, this method can be setted to result imidiatly in error, will block if internal buffer is empty or will perform an read operation from internal buffer.
+//
+// If setted to result in error via (*dNC).ReadError(), the result will be (0, dNCErrWrite).
+//
+// If not locked and not setted to result in error via (*dNC).ReadSuccess(), this method will block until internall buffer is not empty, than it returns the result of the buffer read operation via (*bytes.Buffer).Read([...]).
+// If the internal buffer is empty after this method, all follwing (*dNC).Read([...]), requests will block until internall buffer is filled after successful write requests.
+//
+// If server was closed previously, result will be (0, io.EOF).
+func (s *dNC) Read(b []byte) (int, error) {
+	resChan := make(chan dNCIoResult)
+	select {
+	case s.out <- dNCIo{b, resChan}:
+		res := <-resChan
+		return res.n, res.err
+	case <-s.done:
+	}
+	return 0, io.EOF
+}
+func (s *dNC) LocalAddr() net.Addr                { return s.addr }
+func (s *dNC) RemoteAddr() net.Addr               { return s.addr }
+func (s *dNC) SetDeadline(t time.Time) error      { return dNCErrNotImplemented }
+func (s *dNC) SetReadDeadline(t time.Time) error  { return dNCErrNotImplemented }
+func (s *dNC) SetWriteDeadline(t time.Time) error { return dNCErrNotImplemented }
+
+func (s *dNC) Control(i interface{}) error {
+	select {
+	case s.control <- i:
+		return nil
+	case <-s.done:
+	}
+	return dNCErrClosed
+}
+
+// Locks writing. All write requests will be blocked until write is unlocked with (*dNC).WriteUnlock, or server closes.
+func (s *dNC) WriteLock() error {
+	return s.Control(dNCCWriteLock{})
+}
+
+// Unlocks writing. All blocked write requests until now will be accepted.
+func (s *dNC) WriteUnlock() error {
+	return s.Control(dNCCWriteUnlock{})
+}
+
+// Unlocks writing and makes (*dNC).Write to result (0, dNCErrWrite).
+func (s *dNC) WriteError() error {
+	if err := s.WriteUnlock(); err != nil {
+		return err
+	}
+	return s.Control(dNCCWriteError{})
+}
+
+// Unlocks writing and makes (*dNC).Write([...]) not result in error. See (*dNC).Write for details.
+func (s *dNC) WriteSuccess() error {
+	if err := s.WriteUnlock(); err != nil {
+		return err
+	}
+	return s.Control(dNCCWriteSuccess{})
+}
+
+// Locks reading. All read requests will be blocked until read is unlocked with (*dNC).ReadUnlock, or server closes.
+// (*dNC).Read([...]) wil block even after successful write.
+func (s *dNC) ReadLock() error {
+	return s.Control(dNCCReadLock{})
+}
+
+// Unlocks reading. If the internall buffer is not empty, next read will not block.
+func (s *dNC) ReadUnlock() error {
+	return s.Control(dNCCReadUnlock{})
+}
+
+// Unlocks read and makes every blocked and following (*dNC).Read([...]) imidiatly result in error. See (*dNC).Read for details.
+func (s *dNC) ReadError() error {
+	if err := s.ReadUnlock(); err != nil {
+		return err
+	}
+	return s.Control(dNCCReadError{})
+}
+
+// Unlocks read and makes every blocked and following (*dNC).Read([...]) requests be handled, if according to internal buffer. See (*dNC).Read for details.
+func (s *dNC) ReadSuccess() error {
+	if err := s.ReadUnlock(); err != nil {
+		return err
+	}
+	return s.Control(dNCCReadSuccess{})
+}
+
+// dummy X server replier for dummy net.Conn
+
+type dXSEvent struct{}
+
+func (_ dXSEvent) Bytes() []byte  { return nil }
+func (_ dXSEvent) String() string { return "dummy X server event" }
+
+type dXSError struct {
+	seqId uint16
+}
+
+func (e dXSError) SequenceId() uint16 { return e.seqId }
+func (_ dXSError) BadId() uint32      { return 0 }
+func (_ dXSError) Error() string      { return "dummy X server error reply" }
+
+func newDummyXServerReplier() func([]byte) []byte {
+	// register xgb error & event replies
+	NewErrorFuncs[255] = func(buf []byte) Error {
+		return dXSError{Get16(buf[2:])}
+	}
+	NewEventFuncs[128&127] = func(buf []byte) Event {
+		return dXSEvent{}
+	}
+
+	// sequence number generator
+	seqId := uint16(1)
+	incrementSequenceId := func() {
+		// this has to be the same algorithm as in (*Conn).generateSeqIds
+		if seqId == uint16((1<<16)-1) {
+			seqId = 0
+		} else {
+			seqId++
+		}
+	}
+	return func(request []byte) []byte {
+		res := make([]byte, 32)
+		switch string(request) {
+		case "event":
+			res[0] = 128
+			return res
+		case "error":
+			res[0] = 0   // error
+			res[1] = 255 // error function
+		default:
+			res[0] = 1 // reply
+		}
+		Put16(res[2:], seqId) // sequence number
+		incrementSequenceId()
+		if string(request) == "noreply" {
+			return nil
+		}
+		return res
+	}
+}

vendor/github.com/jezek/xgb/xgb.go

@@ -0,0 +1,608 @@
+package xgb
+
+import (
+	"errors"
+	"io"
+	"log"
+	"net"
+	"os"
+	"sync"
+)
+
+var (
+	// Where to log error-messages. Defaults to stderr.
+	// To disable logging, just set this to log.New(ioutil.Discard, "", 0)
+	Logger = log.New(os.Stderr, "XGB: ", log.Lshortfile)
+)
+
+const (
+	// cookieBuffer represents the queue size of cookies existing at any
+	// point in time. The size of the buffer is really only important when
+	// there are many requests without replies made in sequence. Once the
+	// buffer fills, a round trip request is made to clear the buffer.
+	cookieBuffer = 1000
+
+	// xidBuffer represents the queue size of the xid channel.
+	// I don't think this value matters much, since xid generation is not
+	// that expensive.
+	xidBuffer = 5
+
+	// seqBuffer represents the queue size of the sequence number channel.
+	// I don't think this value matters much, since sequence number generation
+	// is not that expensive.
+	seqBuffer = 5
+
+	// reqBuffer represents the queue size of the number of requests that
+	// can be made until new ones block. This value seems OK.
+	reqBuffer = 100
+
+	// eventBuffer represents the queue size of the number of events or errors
+	// that can be loaded off the wire and not grabbed with WaitForEvent
+	// until reading an event blocks. This value should be big enough to handle
+	// bursts of events.
+	eventBuffer = 5000
+)
+
+// A Conn represents a connection to an X server.
+type Conn struct {
+	host          string
+	conn          net.Conn
+	display       string
+	DisplayNumber int
+	DefaultScreen int
+	SetupBytes    []byte
+
+	setupResourceIdBase uint32
+	setupResourceIdMask uint32
+
+	eventChan  chan eventOrError
+	cookieChan chan *Cookie
+	xidChan    chan xid
+	seqChan    chan uint16
+	reqChan    chan *request
+	doneSend   chan struct{}
+	doneRead   chan struct{}
+
+	// ExtLock is a lock used whenever new extensions are initialized.
+	// It should not be used. It is exported for use in the extension
+	// sub-packages.
+	ExtLock sync.RWMutex
+
+	// Extensions is a map from extension name to major opcode. It should
+	// not be used. It is exported for use in the extension sub-packages.
+	Extensions map[string]byte
+}
+
+// NewConn creates a new connection instance. It initializes locks, data
+// structures, and performs the initial handshake. (The code for the handshake
+// has been relegated to conn.go.)
+// It is up to user to close connection with Close() method to finish all unfinished requests and clean up spawned goroutines.
+// If the connection unexpectedly closes itself and WaitForEvent() returns "nil, nil", everything is cleaned by that moment, but nothing bad happens if you call Close() after.
+func NewConn() (*Conn, error) {
+	return NewConnDisplay("")
+}
+
+// NewConnDisplay is just like NewConn (see closing instructions), but allows a specific DISPLAY
+// string to be used.
+// If 'display' is empty it will be taken from os.Getenv("DISPLAY").
+//
+// Examples:
+//	NewConn(":1") -> net.Dial("unix", "", "/tmp/.X11-unix/X1")
+//	NewConn("/tmp/launch-12/:0") -> net.Dial("unix", "", "/tmp/launch-12/:0")
+//	NewConn("hostname:2.1") -> net.Dial("tcp", "", "hostname:6002")
+//	NewConn("tcp/hostname:1.0") -> net.Dial("tcp", "", "hostname:6001")
+func NewConnDisplay(display string) (*Conn, error) {
+	c := &Conn{}
+
+	// First connect. This reads authority, checks DISPLAY environment
+	// variable, and loads the initial Setup info.
+	err := c.connect(display)
+	if err != nil {
+		return nil, err
+	}
+
+	return postNewConn(c)
+}
+
+// NewConnNet is just like NewConn (see closing instructions), but allows a specific net.Conn
+// to be used.
+func NewConnNet(netConn net.Conn) (*Conn, error) {
+	c := &Conn{}
+
+	// First connect. This reads authority, checks DISPLAY environment
+	// variable, and loads the initial Setup info.
+	err := c.connectNet(netConn)
+
+	if err != nil {
+		return nil, err
+	}
+
+	return postNewConn(c)
+}
+
+func postNewConn(c *Conn) (*Conn, error) {
+	c.Extensions = make(map[string]byte)
+
+	c.cookieChan = make(chan *Cookie, cookieBuffer)
+	c.xidChan = make(chan xid, xidBuffer)
+	c.seqChan = make(chan uint16, seqBuffer)
+	c.reqChan = make(chan *request, reqBuffer)
+	c.eventChan = make(chan eventOrError, eventBuffer)
+	c.doneSend = make(chan struct{})
+	c.doneRead = make(chan struct{})
+
+	go c.generateXIds()
+	go c.generateSeqIds()
+	go c.sendRequests()
+	go c.readResponses()
+
+	return c, nil
+}
+
+// Close gracefully closes the connection to the X server.
+// When everything is cleaned up, the WaitForEvent method will return (nil, nil)
+func (c *Conn) Close() {
+	select {
+	case c.reqChan <- nil:
+	case <-c.doneSend:
+	}
+}
+
+// Event is an interface that can contain any of the events returned by the
+// server. Use a type assertion switch to extract the Event structs.
+type Event interface {
+	Bytes() []byte
+	String() string
+}
+
+// NewEventFun is the type of function use to construct events from raw bytes.
+// It should not be used. It is exported for use in the extension sub-packages.
+type NewEventFun func(buf []byte) Event
+
+// NewEventFuncs is a map from event numbers to functions that create
+// the corresponding event. It should not be used. It is exported for use
+// in the extension sub-packages.
+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
+// exported for use in the extension sub-packages.
+var NewExtEventFuncs = make(map[string]map[int]NewEventFun)
+
+// 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 Error interface {
+	SequenceId() uint16
+	BadId() uint32
+	Error() string
+}
+
+// NewErrorFun is the type of function use to construct errors from raw bytes.
+// It should not be used. It is exported for use in the extension sub-packages.
+type NewErrorFun func(buf []byte) Error
+
+// NewErrorFuncs is a map from error numbers to functions that create
+// the corresponding error. It should not be used. It is exported for use in
+// the extension sub-packages.
+var NewErrorFuncs = make(map[int]NewErrorFun)
+
+// NewExtErrorFuncs is a temporary map that stores error constructor functions
+// for each extension. When an extension is initialized, each error for that
+// extension is added to the 'NewErrorFuncs' map. It should not be used. It is
+// exported for use in the extension sub-packages.
+var NewExtErrorFuncs = make(map[string]map[int]NewErrorFun)
+
+// eventOrError corresponds to values that can be either an event or an
+// error.
+type eventOrError interface{}
+
+// NewId generates a new unused ID for use with requests like CreateWindow.
+// If no new ids can be generated, the id returned is 0 and error is non-nil.
+// This shouldn't be used directly, and is exported for use in the extension
+// sub-packages.
+// If you need identifiers, use the appropriate constructor.
+// e.g., For a window id, use xproto.NewWindowId. For
+// a new pixmap id, use xproto.NewPixmapId. And so on.
+// Returns (0, io.EOF) when the connection is closed.
+func (c *Conn) NewId() (uint32, error) {
+	xid, ok := <-c.xidChan
+	if !ok {
+		return 0, io.EOF
+	}
+	if xid.err != nil {
+		return 0, xid.err
+	}
+	return xid.id, nil
+}
+
+// xid encapsulates a resource identifier being sent over the Conn.xidChan
+// channel. If no new resource id can be generated, id is set to 0 and a
+// non-nil error is set in xid.err.
+type xid struct {
+	id  uint32
+	err error
+}
+
+// generateXids sends new Ids down the channel for NewId to use.
+// generateXids should be run in its own goroutine.
+// This needs to be updated to use the XC Misc extension once we run out of
+// new ids.
+// Thanks to libxcb/src/xcb_xid.c. This code is greatly inspired by it.
+func (c *Conn) generateXIds() {
+	defer close(c.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
+	// this connection."
+	// So for example (using 8 bit integers), the mask might look like:
+	// 00111000
+	// So that valid values would be 00101000, 00110000, 00001000, and so on.
+	// Thus, the idea is to increment it by the place of the last least
+	// significant '1'. In this case, that value would be 00001000. To get
+	// that value, we can AND the original mask with its two's complement:
+	// 00111000 & 11001000 = 00001000.
+	// And we use that value to increment the last resource id to get a new one.
+	// (And then, of course, we OR it with resource-id-base.)
+	inc := c.setupResourceIdMask & -c.setupResourceIdMask
+	max := c.setupResourceIdMask
+	last := uint32(0)
+	for {
+		id := xid{}
+		if last > 0 && last >= max-inc+1 {
+			// TODO: Use the XC Misc extension to look for released ids.
+			id = xid{
+				id:  0,
+				err: errors.New("There are no more available resource identifiers."),
+			}
+		} else {
+			last += inc
+			id = xid{
+				id:  last | c.setupResourceIdBase,
+				err: nil,
+			}
+		}
+
+		select {
+		case c.xidChan <- id:
+		case <-c.doneSend:
+			// c.sendRequests is down and since this id is used by requests, we don't need this goroutine running anymore.
+			return
+		}
+	}
+}
+
+// newSeqId fetches the next sequence id from the Conn.seqChan channel.
+func (c *Conn) newSequenceId() uint16 {
+	return <-c.seqChan
+}
+
+// generateSeqIds returns new sequence ids. It is meant to be run in its
+// 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
+// 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.
+func (c *Conn) generateSeqIds() {
+	defer close(c.seqChan)
+
+	seqid := uint16(1)
+	for {
+		select {
+		case c.seqChan <- seqid:
+			if seqid == uint16((1<<16)-1) {
+				seqid = 0
+			} else {
+				seqid++
+			}
+		case <-c.doneSend:
+			// c.sendRequests is down and since only that function uses sequence ids (via newSequenceId method), we don't need this goroutine running anymore.
+			return
+		}
+	}
+}
+
+// request encapsulates a buffer of raw bytes (containing the request data)
+// and a cookie, which when combined represents a single request.
+// The cookie is used to match up the reply/error.
+type request struct {
+	buf    []byte
+	cookie *Cookie
+
+	// seq is closed when the request (cookie) has been sequenced by the Conn.
+	seq chan struct{}
+}
+
+// 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.
+//
+// Note that you may safely use NewRequest to send arbitrary byte requests
+// to X. The resulting cookie can be used just like any normal cookie and
+// abides by the same rules, except that for replies, you'll get back the
+// raw byte data. This may be useful for performance critical sections where
+// every allocation counts, since all X requests in XGB allocate a new byte
+// slice. In contrast, NewRequest allocates one small request struct and
+// nothing else. (Except when the cookie buffer is full and has to be flushed.)
+//
+// If you're using NewRequest manually, you'll need to use NewCookie to create
+// a new cookie.
+//
+// In all likelihood, you should be able to copy and paste with some minor
+// edits the generated code for the request you want to issue.
+func (c *Conn) NewRequest(buf []byte, cookie *Cookie) {
+	seq := make(chan struct{})
+	select {
+	case c.reqChan <- &request{buf: buf, cookie: cookie, seq: seq}:
+		// request is in buffer
+		// wait until request is processed or connection is closed
+		select {
+		case <-seq:
+			// request was successfully sent to X server
+		case <-c.doneSend:
+			// c.sendRequests is down, your request was not handled
+		}
+	case <-c.doneSend:
+		// c.sendRequests is down, nobody is listening to your requests
+	}
+}
+
+// sendRequests is run as a single goroutine that takes requests and writes
+// the bytes to the wire and adds the cookie to the cookie queue.
+// It is meant to be run as its own goroutine.
+func (c *Conn) sendRequests() {
+	defer close(c.cookieChan)
+	defer c.conn.Close()
+	defer close(c.doneSend)
+
+	for {
+		select {
+		case req := <-c.reqChan:
+			if req == nil {
+				// a request by c.Close() to gracefully exit
+				// Flush the response reading goroutine.
+				if err := c.noop(); err != nil {
+					c.conn.Close()
+					<-c.doneRead
+				}
+				return
+			}
+			// ho there! if the cookie channel is nearly full, force a round
+			// trip to clear out the cookie buffer.
+			// Note that we circumvent the request channel, because we're *in*
+			// the request channel.
+			if len(c.cookieChan) == cookieBuffer-1 {
+				if err := c.noop(); err != nil {
+					// Shut everything down.
+					c.conn.Close()
+					<-c.doneRead
+					return
+				}
+			}
+			req.cookie.Sequence = c.newSequenceId()
+			c.cookieChan <- req.cookie
+			if err := c.writeBuffer(req.buf); err != nil {
+				c.conn.Close()
+				<-c.doneRead
+				return
+			}
+			close(req.seq)
+		case <-c.doneRead:
+			return
+		}
+	}
+}
+
+// noop circumvents the usual request sending goroutines and forces a round
+// trip request manually.
+func (c *Conn) noop() error {
+	cookie := c.NewCookie(true, true)
+	cookie.Sequence = c.newSequenceId()
+	c.cookieChan <- cookie
+	if err := c.writeBuffer(c.getInputFocusRequest()); err != nil {
+		return err
+	}
+	cookie.Reply() // wait for the buffer to clear
+	return nil
+}
+
+// writeBuffer is a convenience function for writing a byte slice to the wire.
+func (c *Conn) writeBuffer(buf []byte) error {
+	if _, err := c.conn.Write(buf); err != nil {
+		Logger.Printf("A write error is unrecoverable: %s", err)
+		return err
+	}
+	return nil
+}
+
+// readResponses is a goroutine that reads events, errors and
+// replies off the wire.
+// When an event is read, it is always added to the event channel.
+// When an error is read, if it corresponds to an existing checked cookie,
+// it is sent to that cookie's error channel. Otherwise it is added to the
+// event channel.
+// When a reply is read, it is added to the corresponding cookie's reply
+// channel. (It is an error if no such cookie exists in this case.)
+// Finally, cookies that came "before" this reply are always cleaned up.
+func (c *Conn) readResponses() {
+	defer close(c.eventChan)
+	defer c.conn.Close()
+	defer close(c.doneRead)
+
+	var (
+		err        Error
+		seq        uint16
+		replyBytes []byte
+	)
+
+	for {
+		buf := make([]byte, 32)
+		err, seq = nil, 0
+		if _, err := io.ReadFull(c.conn, buf); err != nil {
+			select {
+			case <-c.doneSend:
+				// gracefully closing
+				return
+			default:
+			}
+			Logger.Printf("A read error is unrecoverable: %s", err)
+			c.eventChan <- err
+			return
+		}
+		switch buf[0] {
+		case 0: // This is an error
+			// Use the constructor function for this error (that is auto
+			// generated) by looking it up by the error number.
+			newErrFun, ok := NewErrorFuncs[int(buf[1])]
+			if !ok {
+				Logger.Printf("BUG: Could not find error constructor function "+
+					"for error with number %d.", buf[1])
+				continue
+			}
+			err = newErrFun(buf)
+			seq = err.SequenceId()
+
+			// This error is either sent to the event channel or a specific
+			// cookie's error channel below.
+		case 1: // This is a reply
+			seq = Get16(buf[2:])
+
+			// check to see if this reply has more bytes to be read
+			size := Get32(buf[4:])
+			if size > 0 {
+				byteCount := 32 + size*4
+				biggerBuf := make([]byte, byteCount)
+				copy(biggerBuf[:32], buf)
+				if _, err := io.ReadFull(c.conn, biggerBuf[32:]); err != nil {
+					Logger.Printf("A read error is unrecoverable: %s", err)
+					c.eventChan <- err
+					return
+				}
+				replyBytes = biggerBuf
+			} else {
+				replyBytes = buf
+			}
+
+			// This reply is sent to its corresponding cookie below.
+		default: // This is an event
+			// Use the constructor function for this event (like for errors,
+			// and is also auto generated) by looking it up by the event number.
+			// Note that we AND the event number with 127 so that we ignore
+			// the most significant bit (which is set when it was sent from
+			// a SendEvent request).
+			evNum := int(buf[0] & 127)
+			newEventFun, ok := NewEventFuncs[evNum]
+			if !ok {
+				Logger.Printf("BUG: Could not find event construct function "+
+					"for event with number %d.", evNum)
+				continue
+			}
+			c.eventChan <- newEventFun(buf)
+			continue
+		}
+
+		// At this point, we have a sequence number and we're either
+		// processing an error or a reply, which are both responses to
+		// requests. So all we have to do is find the cookie corresponding
+		// to this error/reply, and send the appropriate data to it.
+		// In doing so, we make sure that any cookies that came before it
+		// are marked as successful if they are void and checked.
+		// If there's a cookie that requires a reply that is before this
+		// reply, then something is wrong.
+		for cookie := range c.cookieChan {
+			// This is the cookie we're looking for. Process and break.
+			if cookie.Sequence == seq {
+				if err != nil { // this is an error to a request
+					// synchronous processing
+					if cookie.errorChan != nil {
+						cookie.errorChan <- err
+					} else { // asynchronous processing
+						c.eventChan <- err
+						// if this is an unchecked reply, ping the cookie too
+						if cookie.pingChan != nil {
+							cookie.pingChan <- true
+						}
+					}
+				} else { // this is a reply
+					if cookie.replyChan == nil {
+						Logger.Printf("Reply with sequence id %d does not "+
+							"have a cookie with a valid reply channel.", seq)
+						continue
+					} else {
+						cookie.replyChan <- replyBytes
+					}
+				}
+				break
+			}
+
+			switch {
+			// Checked requests with replies
+			case cookie.replyChan != nil && cookie.errorChan != nil:
+				Logger.Printf("Found cookie with sequence id %d that is "+
+					"expecting a reply but will never get it. Currently "+
+					"on sequence number %d", cookie.Sequence, seq)
+			// Unchecked requests with replies
+			case cookie.replyChan != nil && cookie.pingChan != nil:
+				Logger.Printf("Found cookie with sequence id %d that is "+
+					"expecting a reply (and not an error) but will never "+
+					"get it. Currently on sequence number %d",
+					cookie.Sequence, seq)
+			// Checked requests without replies
+			case cookie.pingChan != nil && cookie.errorChan != nil:
+				cookie.pingChan <- true
+				// Unchecked requests without replies don't have any channels,
+				// so we can't do anything with them except let them pass by.
+			}
+		}
+	}
+}
+
+// processEventOrError takes an eventOrError, type switches on it,
+// and returns it in Go idiomatic style.
+func processEventOrError(everr eventOrError) (Event, Error) {
+	switch ee := everr.(type) {
+	case Event:
+		return ee, nil
+	case Error:
+		return nil, ee
+	case error:
+		// c.conn read error
+	case nil:
+		// c.eventChan is closed
+	default:
+		Logger.Printf("Invalid event/error type: %T", everr)
+	}
+	return nil, nil
+}
+
+// WaitForEvent returns the next event from the server.
+// It will block until an event is available.
+// WaitForEvent returns either an Event or an Error. (Returning both
+// is a bug.) Note than an Error here is an X error and not an XGB error. That
+// is, X errors are sometimes completely expected (and you may want to ignore
+// them in some cases).
+//
+// If both the event and error are nil, then the connection has been closed.
+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
+// is empty.
+func (c *Conn) PollForEvent() (Event, Error) {
+	select {
+	case everr := <-c.eventChan:
+		return processEventOrError(everr)
+	default:
+		return nil, nil
+	}
+}