Esempio n. 1
0
func main() {
	X, err := xgbutil.NewConn()
	if err != nil {
		log.Fatal(err)
	}

	// Use the "NewDrawable" constructor to create an xgraphics.Image value
	// from a drawable. (Usually this is done with pixmaps, but drawables
	// can also be windows.)
	ximg, err := xgraphics.NewDrawable(X, xproto.Drawable(X.RootWin()))
	if err != nil {
		log.Fatal(err)
	}

	// Shows the screenshot in a window.
	ximg.XShowExtra("Screenshot", true)

	// If you'd like to save it as a png, use:
	// err = ximg.SavePng("screenshot.png")
	// if err != nil {
	// log.Fatal(err)
	// }

	xevent.Main(X)
}
Esempio n. 2
0
func (self *SessionModule) WriteWindowImage(window_id string, w io.Writer) error {
	if id, err := self.toX11WindowId(window_id); err == nil {
		drawable := xproto.Drawable(id)

		if image, err := xgraphics.NewDrawable(self.X, drawable); err == nil {
			image.XSurfaceSet(id)
			image.XDraw()

			return image.WritePng(w)
		} else {
			return err
		}
	} else {
		return err
	}
}
Esempio n. 3
0
func icon2md5(xid xproto.Window) []byte {
	pixmap, _ := xproto.NewPixmapId(TrayXU.Conn())
	defer xproto.FreePixmap(TrayXU.Conn(), pixmap)
	if err := composite.NameWindowPixmapChecked(TrayXU.Conn(), xid, pixmap).Check(); err != nil {
		logger.Warning("NameWindowPixmap failed:", err, xid)
		return nil
	}
	im, err := xgraphics.NewDrawable(TrayXU, xproto.Drawable(pixmap))
	if err != nil {
		logger.Warning("Create xgraphics.Image failed:", err, pixmap)
		return nil
	}
	buf := bytes.NewBuffer(nil)
	im.WritePng(buf)
	hasher := md5.New()
	hasher.Write(buf.Bytes())
	return hasher.Sum(nil)
}
Esempio n. 4
0
// Draws a single point on the window in the window (rather then plot)
// coordinate system.
// This routine is slow because it is essentially performing a buffer flip for
// each point.
//
// This routine should be avoided. This is here as an assistance function rather
// then the intended routine to be used for plotting. Prefer the 'Plot' data
// functions over this function in almost all circumstances.
func (plot *PlotWindow) DrawPoint(x, y int, pixelColor color.Color) {
	if plot == nil {
		return
	}
	ximg, err := xgraphics.NewDrawable(system.X, xproto.Drawable(plot.window.Id))
	if err != nil {
		return
	}
	defer ximg.Destroy()

	ximg.Set(x, y, pixelColor)

	ximg.XSurfaceSet(plot.window.Id)

	ximg.XDraw()

	ximg.XPaint(plot.window.Id)

}
Esempio n. 5
0
// Draws a array of points on the window in the window (rather then plot)
// coordinate system.
// This routine is faster then the single point system because it performs only
// one buffer flip per Point array rather then per point.
//
// This routine should be avoided. This is here as an assistance function rather
// then the intended routine to be used for plotting. Prefer the 'Plot' data
// functions over this function in almost all circumstances.
func (plot *PlotWindow) DrawPoints(points []image.Point, pixelColor color.Color) {
	if plot == nil {
		return
	}
	ximg, err := xgraphics.NewDrawable(system.X, xproto.Drawable(plot.window.Id))
	if err != nil {
		return
	}
	defer ximg.Destroy()

	//
	for index, _ := range points {
		ximg.Set(points[index].X, points[index].Y, pixelColor)
	}

	ximg.XSurfaceSet(plot.window.Id)

	ximg.XDraw()

	ximg.XPaint(plot.window.Id)

}
Esempio n. 6
0
func updater() {
	for {
		img, err := xgraphics.NewDrawable(X, xproto.Drawable(HexWindow.Id))
		if err != nil {
			log.Fatal(err)
		}

		if crumbs == nil {
			crumbs = make([][]int, img.Rect.Max.X)
			for i := 0; i < len(crumbs); i++ {
				crumbs[i] = make([]int, img.Rect.Max.Y)
			}
		}

		centerx := img.Rect.Max.X / 2
		centery := img.Rect.Max.Y / 2
		cr, cg, cb, _ := img.At(centerx, centery).RGBA()
		center := int(cr+cg+cb) / 0xFF
		mindiff := 0
		ringy := 0
		for y := centery; y > 0; y-- {
			r, g, b, _ := img.At(centerx, y).RGBA()
			diff := int(r+g+b)/0xFF - center
			if diff < 0 {
				diff = -diff
			}
			if diff > 5 {
				mindiff = diff
				ringy = y
				break
			}
		}
		for i := 0; i < len(img.Pix); i += 4 {
			col := int(img.Pix[i]) + int(img.Pix[i+1]) + int(img.Pix[i+2])
			diff := col - center
			if diff < 0 {
				diff = -diff
			}
			if diff >= mindiff-60 {
				img.Pix[i] = 255
				img.Pix[i+1] = 255
				img.Pix[i+2] = 255
			} else {
				img.Pix[i] = 0
				img.Pix[i+1] = 0
				img.Pix[i+2] = 0
			}
		}

		iteration++
		floodFill(img, centerx, ringy, func(x, y int) bool {
			if (x-centerx)*(x-centerx)+(y-centery)*(y-centery) < 6400 {
				img.Pix[x*4+y*img.Stride] = 0
				img.Pix[x*4+y*img.Stride+1] = 0
				// img.Pix[x*4+y*img.Stride+2] = 0
				return true
			}
			return false
		})

		iteration++
		found := false
		pointerAngle := 0.0
	Search:
		for r := 40.0; r < 100; r += 3 {
			for a := 0.0; a < 256; a++ {
				dx := math.Cos(a * math.Pi / 128)
				dy := math.Sin(a * math.Pi / 128)
				x := centerx + int(dx*r)
				y := centery + int(dy*r)
				if img.Pix[x*4+y*img.Stride] != 0 && crumbs[x][y] != iteration {
					size := 0
					sumx := 0
					sumy := 0
					floodFill(img, x, y, func(x, y int) bool {
						size++
						sumx += x
						sumy += y
						return (x-centerx)*(x-centerx)+(y-centery)*(y-centery) < 10000
					})
					if size <= 200 {
						iteration++
						floodFill(img, x, y, func(x, y int) bool {
							// img.Pix[x*4+y*img.Stride] = 0
							img.Pix[x*4+y*img.Stride+1] = 0
							img.Pix[x*4+y*img.Stride+2] = 0
							return true
						})
						pointerAngle = math.Atan2(float64(sumy)/float64(size)-float64(centery), float64(sumx)/float64(size)-float64(centerx))
						dx = math.Cos(pointerAngle)
						dy = math.Sin(pointerAngle)
						for ; r > 0; r-- {
							x := centerx + int(dx*r)
							y := centery + int(dy*r)
							img.Pix[x*4+y*img.Stride] = 255
						}
						found = true
						break Search
					}
				}
			}
		}
		if !found {
			fmt.Println("missing pointer!", time.Now())
		}

		imageMap := mapImage(img, centerx, centery)
		for r, safe := range imageMap {
			for _, area := range safe {
				a := (area[0] + area[1]) / 2
				dx := math.Cos(float64(a) * math.Pi / 128)
				dy := math.Sin(float64(a) * math.Pi / 128)
				x := centerx + int(dx*float64(50+r*10))
				y := centery + int(dy*float64(50+r*10))
				img.Pix[x*4+y*img.Stride+1] = 255
				// for a := area[0]; a < area[1]; a++ {
				// 	dx := math.Cos(float64(a) * math.Pi / 128)
				// 	dy := math.Sin(float64(a) * math.Pi / 128)
				// 	x := centerx + int(dx*float64(50+r*10))
				// 	y := centery + int(dy*float64(50+r*10))
				// 	if x < 0 || x >= img.Rect.Dx() || y < 0 || y >= img.Rect.Dy() {
				// 		continue
				// 	}
				// 	img.Pix[x*4+y*img.Stride+1] = 255
				// }
			}
			// if len(safe) == 0 {
			// 	for a := 0.0; a < 256; a++ {
			// 		dx := math.Cos(a * math.Pi / 128)
			// 		dy := math.Sin(a * math.Pi / 128)
			// 		x := centerx + int(dx*float64(50+r*10))
			// 		y := centery + int(dy*float64(50+r*10))
			// 		if x < 0 || x >= img.Rect.Dx() || y < 0 || y >= img.Rect.Dy() {
			// 			continue
			// 		}
			// 		img.Pix[x*4+y*img.Stride+1] = 255
			// 	}
			// }
		}
		// for i := 0; i < len(img.Pix); i += 4 {
		// 	if img.Pix[i] != 0 && img.Pix[i+1] != 0 && img.Pix[i+2] != 0 {
		// 		img.Pix[i] = 0
		// 		img.Pix[i+1] = 0
		// 	}
		// 	img.Pix[i+2] = 0
		// }

		err = img.XSurfaceSet(DisplayWindow.Id)
		if err != nil {
			log.Printf("Error while setting window surface to image %d: %s\n", DisplayWindow, err)
		}

		img.XDraw()
		img.XPaint(DisplayWindow.Id)

		img.Destroy()
	}
}
Esempio n. 7
0
func main() {
	x11, err := xgbutil.NewConn() //connect to X
	if err != nil {
		log.Fatal(err)
	}

	var board [4][4]uint16

	img, err := xgraphics.NewDrawable(x11, xproto.Drawable(x11.RootWin())) //get screen
	if err != nil {
		log.Fatal(err)
	}
	imgRect := img.Bounds()

	boardX, boardY := 0, 0

OuterLoop: //search screen for upper left corner of board
	for x := imgRect.Min.X; x < imgRect.Max.X; x++ {
		for y := imgRect.Min.Y; y < imgRect.Max.Y; y++ {
			if img.At(x, y) == bgGrey { //board might be found
				x0, x1, x2, x3, x4, x5 := x, x+1, x+2, x+3, x+4, x+5
				y0, y1, y2, y3, y4, y5 := y-5, y-4, y-3, y-2, y-1, y
				if img.At(x0, y0) == offWhite && //check corner pixel and board pixel colors
					img.At(x0, y1) == offWhite &&
					img.At(x0, y2) == offWhite &&
					img.At(x1, y0) == offWhite &&
					img.At(x2, y0) == offWhite &&
					img.At(x5, y0) == bgGrey &&
					img.At(x5, y1) == bgGrey &&
					img.At(x5, y2) == bgGrey &&
					img.At(x5, y3) == bgGrey &&
					img.At(x5, y4) == bgGrey &&
					img.At(x5, y5) == bgGrey &&
					img.At(x0, y5) == bgGrey &&
					img.At(x1, y5) == bgGrey &&
					img.At(x2, y5) == bgGrey &&
					img.At(x3, y5) == bgGrey &&
					img.At(x4, y5) == bgGrey &&
					img.At(x5, y5) == bgGrey {
					boardX, boardY = x0, y0
					fmt.Println("Board corner at", boardX, ",", boardY)
					break OuterLoop
				}
			}
		}
	}

	tileX, tileY := boardX+63, boardY+39
	lastBoard := board
ImgLoop:
	for i := 0; true; i++ {
		img, err := xgraphics.NewDrawable(x11, xproto.Drawable(x11.RootWin())) //get screen
		if err != nil {
			log.Fatal(err)
		}
		for y := 0; y < 4; y++ {
			for x := 0; x < 4; x++ {
				board[y][x], err = colorNum(img.At(tileX+(121*x), tileY+(121*y)))
				if err != nil {
					fmt.Println(err, " at ", tileX+(121*x), tileY+(121*y))
					time.Sleep(1 * time.Second)
					continue ImgLoop
				}
				//fmt.Print(board[x][y], " ")
			}
			//fmt.Println()
		}
		if lastBoard != board {
			fmt.Println(string(findMove(board)), i)
		}
		lastBoard = board
		time.Sleep(1 * time.Second)
	}
}