Robotgo

<!-- --> <!-- -->

Golang Desktop Automation. Control the mouse, keyboard, bitmap and image, read the screen, process, Window Handle and global event listener.

RobotGo supports Mac, Windows, and Linux(X11); and robotgo supports arm64 and x86-amd64.

Chinese Simplified

Contents

• Docs
• Binding
• Requirements
• Installation
• Update
• Examples
• Cross-Compiling
• Authors
• Plans
• Donate
• Contributors
• License

Docs

• GoDoc
• API Docs    
• Chinese Docs

Binding:

Robotn, binding JavaScript and other, support more language.

Requirements:

Now, Please make sure

Golang, GCC

ALL:

Golang

GCC

For Mac OS X:

Xcode Command Line Tools

For Windows:

MinGW-w64 (Use recommended) or other GCC

For everything else:

GCC, libpng

X11 with the XTest extension (also known as the Xtst library)
Event:
xcb, xkb, libxkbcommon

Ubuntu:

sudo apt install gcc libc6-dev

sudo apt install libx11-dev xorg-dev libxtst-dev libpng++-dev
sudo apt install xcb libxcb-xkb-dev x11-xkb-utils libx11-xcb-dev libxkbcommon-x11-dev
sudo apt install libxkbcommon-dev
sudo apt install xsel xclip

Fedora:

sudo dnf install libxkbcommon-devel libXtst-devel libxkbcommon-x11-devel xorg-x11-xkb-utils-devel

sudo dnf install libpng-devel
sudo dnf install xsel xclip

Installation:

go get github.com/go-vgo/robotgo

It's that easy!

png.h: No such file or directory? Please see issues/47.

Update:

go get -u github.com/go-vgo/robotgo

Note go1.10.x C file compilation cache problem, golang #24355.

go mod vendor

Examples:

Mouse

package main

import (
  "github.com/go-vgo/robotgo"
)
func main() {
  robotgo.ScrollMouse(10, "up")
  robotgo.Scroll(100, 200)
  robotgo.MilliSleep(100)
  robotgo.ScrollRelative(10, -100)
  robotgo.MouseSleep = 100
  robotgo.Move(10, 20)
  robotgo.MoveRelative(0, -10)
  robotgo.Drag(10, 10)
  robotgo.Click("left", true)
  robotgo.MoveSmooth(100, 200, 1.0, 100.0)
  robotgo.MouseToggle("up")
}

Keyboard

package main

import (
  "fmt"
  "github.com/go-vgo/robotgo"
)
func main() {
  robotgo.TypeStr("Hello World")
  robotgo.TypeStr("だんしゃり", 1.0)
  // robotgo.TypeStr("テストする")
  robotgo.TypeStr("Hi galaxy. こんにちは世界.")
  robotgo.Sleep(1)
  // ustr := uint32(robotgo.CharCodeAt("Test", 0))
  // robotgo.UnicodeType(ustr)
  robotgo.KeySleep = 100
  robotgo.KeyTap("enter")
  // robotgo.TypeStr("en")
  robotgo.KeyTap("i", "alt", "command")
  arr := []string{"alt", "command"}
  robotgo.KeyTap("i", arr)
  robotgo.MilliSleep(100)
  robotgo.KeyToggle("a", "down")
  robotgo.WriteAll("Test")
  text, err := robotgo.ReadAll()
  if err == nil {
    fmt.Println(text)
  }
}

Screen

package main

import (
  "fmt"
  "github.com/go-vgo/robotgo"
  "github.com/vcaesar/imgo"
)
func main() {
  x, y := robotgo.GetMousePos()
  fmt.Println("pos: ", x, y)
  color := robotgo.GetPixelColor(100, 200)
  fmt.Println("color---- ", color)
  sx, sy := robotgo.GetScreenSize()
  fmt.Println("get screen size: ", sx, sy)
  bit := robotgo.CaptureScreen(10, 10, 30, 30)
  defer robotgo.FreeBitmap(bit)
  robotgo.SaveBitmap(bit, "test_1.png")
  img := robotgo.ToImage(bit)
  imgo.Save("test.png", img)
}

Bitmap

package main

import (
  "fmt"
  "github.com/go-vgo/robotgo"
  "github.com/vcaesar/gcv"
)
func main() {
  bitmap := robotgo.CaptureScreen(10, 20, 30, 40)
  // use defer robotgo.FreeBitmap(bit) to free the bitmap
  defer robotgo.FreeBitmap(bitmap)
  fmt.Println("bitmap...", bitmap)
  img := robotgo.ToImage(bitmap)
  robotgo.SavePng(img, "test_1.png")
  bit2 := robotgo.ToCBitmap(robotgo.ImgToBitmap(img))
  fx, fy := robotgo.FindBitmap(bit2)
  fmt.Println("FindBitmap------ ", fx, fy)
  arr := robotgo.FindEveryBitmap(bit2)
  fmt.Println("Find every bitmap: ", arr)
  robotgo.SaveBitmap(bitmap, "test.png")
  fx, fy = robotgo.FindBitmap(bitmap)
  fmt.Println("FindBitmap------ ", fx, fy)
  robotgo.SaveBitmap(bitmap, "test.png")
}
func opencv() {
  name := "test.png"
  name1 := "test_001.png"
  robotgo.SaveCapture(name1, 10, 10, 30, 30)
  robotgo.SaveCapture(name)
  fmt.Print("gcv find image: ")
  fmt.Println(gcv.FindImgFile(name1, name))
  fmt.Println(gcv.FindAllImgFile(name1, name))
  bit := robotgo.OpenBitmap(name1)
  defer robotgo.FindBitmap(bit)
  fmt.Print("find bitmap: ")
  fmt.Println(robotgo.FindBitmap(bit))
  // bit0 := robotgo.CaptureScreen()
  // img := robotgo.ToImage(bit0)
  // bit1 := robotgo.CaptureScreen(10, 10, 30, 30)
  // img1 := robotgo.ToImage(bit1)
  // defer robotgo.FreeBitmapArr(bit0, bit1)
  img := robotgo.CaptureImg()
  img1 := robotgo.CaptureImg(10, 10, 30, 30)
  fmt.Print("gcv find image: ")
  fmt.Println(gcv.FindImg(img1, img))
  fmt.Println(gcv.FindAllImg(img1, img))
}

Event

package main

import (
  "fmt"
  "github.com/go-vgo/robotgo"
  hook "github.com/robotn/gohook"
)
func main() {
  add()
  low()
  event()
}
func add() {
  fmt.Println("--- Please press ctrl + shift + q to stop hook ---")
  robotgo.EventHook(hook.KeyDown, []string{"q", "ctrl", "shift"}, func(e hook.Event) {
    fmt.Println("ctrl-shift-q")
    robotgo.EventEnd()
  })
  fmt.Println("--- Please press w---")
  robotgo.EventHook(hook.KeyDown, []string{"w"}, func(e hook.Event) {
    fmt.Println("w")
  })
  s := robotgo.EventStart()
Window
package main

import (
  "fmt"
  "github.com/go-vgo/robotgo"
)
func main() {
  fpid, err := robotgo.FindIds("Google")
  if err == nil {
    fmt.Println("pids... ", fpid)
if len(fpid) > 0 {
  robotgo.ActivePID(fpid[0])

  robotgo.Kill(fpid[0])
}
  }
  robotgo.ActiveName("chrome")
  isExist, err := robotgo.PidExists(100)
  if err == nil && isExist {
    fmt.Println("pid exists is", isExist)
robotgo.Kill(100)
  }
  abool := robotgo.ShowAlert("test", "robotgo")
  if abool {
      fmt.Println("[email protected]@@ ", "ok")
  }
  title := robotgo.GetTitle()
  fmt.Println("[email protected]@@ ", title)
}

CrossCompiling

Windows64 to windows32
SET CGO_ENABLED=1
SET GOARCH=386
go build main.go

Other to windows

Install Requirements (Ubuntu):
```bash
sudo apt install gcc-multilib
sudo apt install gcc-mingw-w64

fix err: zlib.h: No such file or directory

sudo apt install libz-mingw-w64-dev
```

Build the binary:
Go
GOOS=windows GOARCH=amd64 CGO_ENABLED=1 CC=x86_64-w64-mingw32-gcc CXX=x86_64-w64-mingw32-g++ go build -x ./

// CC=mingw-w64\x86_64-7.2.0-win32-seh-rt_v5-rev1\mingw64\bin\gcc.exe
// CXX=mingw-w64\x86_64-7.2.0-win32-seh-rt_v5-rev1\mingw64\bin\g++.exe

Some discussions and questions, please see issues/228, issues/143.

Authors

• The author is vz
• Maintainers
• Contributors

Plans

• Update Find an image on screen, read pixels from an image
• Update Window Handle
• Try support Android, maybe support IOS

Contributors

• See contributors page for full list of contributors.
• See Contribution Guidelines.

License

Robotgo is primarily distributed under the terms of "both the MIT license and the Apache License (Version 2.0)", with portions covered by various BSD-like licenses.

See LICENSE-APACHE, LICENSE-MIT.