package main

import (
    "fmt"
    "image"
    "image/color"
    "image/draw"
    "time"

    "github.com/BurntSushi/xgbutil"
    "github.com/BurntSushi/xgbutil/xevent"
    "github.com/BurntSushi/xgbutil/xgraphics"
)

func main() {
    const (
        w = 150
        h = 150
    )
    img := image.NewRGBA(image.Rect(0, 0, int(w), int(h)))

    X, err := xgbutil.NewConn()
    fatal(err)

    ximg := xgraphics.New(X, img.Bounds())

    wid := ximg.XShowExtra("foo", true)
    go func() {
        xevent.Main(X)
    }()

    ximg.XDraw()
    ximg.XPaint(wid.Id)
    fmt.Printf("window id: %v\n", wid.Id)

    time.Sleep(2 * time.Second)
    fmt.Printf("drawing white...\n")
    draw.Draw(ximg, ximg.Bounds(), image.NewUniform(color.White), image.Point{0, 0}, draw.Src)
    ximg.XDraw()
    ximg.XPaint(wid.Id)

    time.Sleep(5 * time.Second)
}

func fatal(err error) {
    if err != nil {
        panic(err)
    }
}

        buf := make([]byte, 32)
        err, seq = nil, 0
        if _, err := io.ReadFull(c.conn, buf); err != nil {
            Logger.Printf("A read error is unrecoverable: %s", err)
            fmt.Printf("**** read error: %v\n", err)
            c.eventChan <- err
            c.Close()
            continue
        }
        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()
            fmt.Printf("--- case 0: err=%v seq=%v\nbuf=%v\n", err, seq, buf)
            // 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)
                    fmt.Printf("**** read-error: %v\n", err)
                    c.eventChan <- err
                    c.Close()
                    continue
                }
                replyBytes = biggerBuf
            } else {
                replyBytes = buf
            }
            fmt.Printf("--- case 1: err=%v seq=%v\n", err, seq)

            // 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)
                fmt.Printf("*** could not find event construct[%d]\n", evNum)
                continue
            }
            fmt.Printf("--- case default: err=%v evtnum=%v\n", err, evNum)
            c.eventChan <- newEventFun(buf)
            continue
        }

        fmt.Printf("----> cookies... (seq=%v err=%v)\n", seq, err)
        // 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 {
                        fmt.Printf("**** sync-cookie error: %v\n", err)
                        cookie.errorChan <- err
                    } else { // asynchronous processing
                        fmt.Printf("****cookie err: %v\n", err)
                        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
            }