package draw9 import (	"bitbucket.org/mischief/draw9/color9"	"image"	"image/color"	"runtime") type Image struct {	Display  *Display	ID       uint32	Pix      color9.Pix	R, Clipr image.Rectangle	Depth    int	Chan     uint	Repl     bool	Next     *Image	Screen   *Screen} // Free implements the 'f' draw(3) message.func (i *Image) Free() error {	if i == nil {		return nil	}	if i.Display != nil && i == i.Display.ScreenImage {		panic("freeimage of ScreenImage")	}	i.Display.mu.Lock()	defer i.Display.mu.Unlock()	return i.free()} func (i *Image) free() error {	if i == nil || i.Display == nil {		return nil	}	// make sure no refresh events occur on this if we block in the write	d := i.Display	// flush pending data so we don't get error deleting the image	d.flush(false)	a := d.bufimage(1 + 4)	a[0] = 'f'	bplong(a[1:], i.ID)	if i.Screen != nil {		w := d.Windows		if w == i {			d.Windows = i.Next		} else {			for ; w != nil; w = w.Next {				if w.Next == i {					w.Next = i.Next					break				}			}		}	}	i.Display = nil // So a second free (perhaps through a Finalizer) will be OK.	runtime.SetFinalizer(i, nil)	return d.flush(i.Screen != nil)} // ColorModel returns the color model of the Image.func (i *Image) ColorModel() color.Model {	switch i.Pix {	case color9.GREY1:		return color9.Gray1Model	case color9.GREY2:		return color9.Gray2Model	case color9.GREY4:		return color9.Gray4Model	case color9.GREY8:		return color.GrayModel	case color9.CMAP8:		return color9.CMap8Model	case color9.RGB15:		return color9.CRGB15Model	case color9.RGB16:		return color9.CRGB16Model	case color9.RGB24, color9.RGBA32, color9.ARGB32, color9.ABGR32, color9.XRGB32, color9.XBGR32:		return color.RGBAModel	}	panic("unknown image Pix type")} /* * Support for the Image type so it can satisfy the standard Color and Image interfaces. */ // At returns the standard Color value for the pixel at (x, y).// If the location is outside the clipping rectangle, it returns color.Transparent.// This operation does a round trip to the image server and can be expensive.func (i *Image) At(x, y int) color.Color {	if !(image.Point{x, y}.In(i.Clipr)) {		return color.Transparent	}	if i.Repl && !(image.Point{x, y}.In(i.R)) {		// Translate (x, y) to be within i.R.		x = (x-i.R.Min.X)%(i.R.Max.X-i.R.Min.X) + i.R.Min.X		y = (y-i.R.Min.Y)%(i.R.Max.Y-i.R.Min.Y) + i.R.Min.Y	}	var buf [4]byte	_, err := i.Unload(image.Rect(x, y, x+1, y+1), buf[:])	if err != nil {		println("image.At: error in Unload: ", err.Error())		return color.Transparent // As good a value as any.	}	// For multi-byte pixels, the ordering is little-endian.	// For sub-byte pixels, the ordering is big-endian (0x80 is the first bit).	// Three cheers for PCs.	switch i.Pix {	case color9.GREY1:		// CGrey, 1		mask := uint8(1 << uint8(7-x&7))		return color9.Gray1{(buf[0] & mask) != 0}	case color9.GREY2:		// CGrey, 2		shift := uint(x&3) << 1		// Place pixel at top of word.		y := buf[0] << shift		y &= 0xC0		// Replicate throughout.		y |= y >> 2		y |= y >> 4		return color9.Gray2{y}	case color9.GREY4:		// CGrey, 4		shift := uint(x&1) << 2		// Place pixel at top of word.		y := buf[0] << shift		y &= 0xF0		// Replicate throughout.		y |= y >> 4		return color9.Gray4{y}	case color9.GREY8:		// CGrey, 8		return color.Gray{buf[0]}	case color9.CMAP8:		// CMap, 8		return color9.CMap8{buf[0]}	case color9.RGB15:		v := uint16(buf[0]) | uint16(buf[1])<<8		return color9.CRGB15{v}	case color9.RGB16:		v := uint16(buf[0]) | uint16(buf[1])<<8		return color9.CRGB16{v}	case color9.RGB24:		// CRed, 8, CGreen, 8, CBlue, 8		return color.RGBA{buf[2], buf[1], buf[0], 0xFF}	case color9.BGR24:		// CBlue, 8, CGreen, 8, CRed, 8		return color.RGBA{buf[0], buf[1], buf[2], 0xFF}	case color9.RGBA32:		// CRed, 8, CGreen, 8, CBlue, 8, CAlpha, 8		return color.RGBA{buf[3], buf[2], buf[1], buf[0]}	case color9.ARGB32:		// CAlpha, 8, CRed, 8, CGreen, 8, CBlue, 8 // stupid VGAs		return color.RGBA{buf[2], buf[1], buf[0], buf[3]}	case color9.ABGR32:		// CAlpha, 8, CBlue, 8, CGreen, 8, CRed, 8		return color.RGBA{buf[0], buf[1], buf[2], buf[3]}	case color9.XRGB32:		// CIgnore, 8, CRed, 8, CGreen, 8, CBlue, 8		return color.RGBA{buf[2], buf[1], buf[0], 0xFF}	case color9.XBGR32:		// CIgnore, 8, CBlue, 8, CGreen, 8, CRed, 8		return color.RGBA{buf[0], buf[1], buf[2], 0xFF}	default:		panic("unknown color")	}} func (i *Image) Bounds() image.Rectangle {	return i.Clipr} // Set implements the image/draw.Image interface.// It can change a single pixel in an Image.// The coordinates x and y are relative to the Image's upper left pixel.// The color.Color will be converted to the Image's color space.func (i *Image) Set(x, y int, c color.Color) {	pt := image.Pt(x, y) 	model := i.ColorModel() 	convc := model.Convert(c) 	r, g, b, _ := convc.RGBA() 	colr := color9.Color((r << 24) | (g << 16) | (b << 8) | 0xFF) 	img, err := i.Display.AllocImage(image.Rect(0, 0, 1, 1), i.Pix, true, colr) 	if err != nil {		panic(err)	} 	i.Draw(image.Rect(pt.X, pt.Y, pt.X+1, pt.Y+1), img, nil, image.ZP)}