robotgo
v0.110.5 (v1.0.0-rc4)
Golang Desktop Automation. Controle el mouse, el teclado, lea la pantalla, el proceso, el mango de la ventana, la imagen y el mapa de bits y el oyente de eventos globales.
Robotgo admite Mac, Windows y Linux (x11); y Robotgo admite ARM64 y X86-AMD64.
ADB, empaque API ADB Android.
Robotn, JavaScript vinculante y otros, admiten más lenguaje.
Ahora, asegúrese de que Golang, GCC esté instalado correctamente antes de instalar Robotgo.
Golang
GCC
Herramientas de línea de comandos de Xcode (y configuración de privacidad: #277)
xcode-select --install
MingW-W64 (use recomendado) u otros Mingw LLVM-Mingw;
Descargue el mingw, luego establezca variables de entorno del sistema C:mingw64bin en la ruta. Establezca variables de entorno para ejecutar GCC desde la línea de comando.
Or the other GCC (pero debe compilar el "libpng" consigo mismo cuando use el mapa de bits).
GCC
X11 with the XTest extension (the Xtst library)
"Clipboard": xsel xclip
"Bitmap": libpng (Just used by the "bitmap".)
"Event-Gohook": xcb, xkb, libxkbcommon (Just used by the "hook".)
# gcc
sudo apt install gcc libc6-dev
# x11
sudo apt install libx11-dev xorg-dev libxtst-dev
# Clipboard
sudo apt install xsel xclip
#
# Bitmap
sudo apt install libpng++-dev
# GoHook
sudo apt install xcb libxcb-xkb-dev x11-xkb-utils libx11-xcb-dev libxkbcommon-x11-dev libxkbcommon-dev
# x11
sudo dnf install libXtst-devel
# Clipboard
sudo dnf install xsel xclip
#
# Bitmap
sudo dnf install libpng-devel
# GoHook
sudo dnf install libxkbcommon-devel libxkbcommon-x11-devel xorg-x11-xkb-utils-devel
Con soporte del módulo GO (GO 1.11+), solo importe:
import "github.com/go-vgo/robotgo"De lo contrario, para instalar el paquete Robotgo, ejecute el comando:
go get github.com/go-vgo/robotgo
png.h: ¿No hay dicho archivo o directorio? Consulte los problemas/47.
go get -u github.com/go-vgo/robotgo
NOTA GO1.10.X C COMPILACIÓN DE COMPILACIÓN DE ARCHIVO C, Golang #24355. go mod vendor , Golang #26366.
package main
import (
"github.com/go-vgo/robotgo"
)
func main () {
robotgo . MouseSleep = 100
robotgo . ScrollDir ( 10 , "up" )
robotgo . ScrollDir ( 20 , "right" )
robotgo . Scroll ( 0 , - 10 )
robotgo . Scroll ( 100 , 0 )
robotgo . MilliSleep ( 100 )
robotgo . ScrollSmooth ( - 10 , 6 )
// robotgo.ScrollRelative(10, -100)
robotgo . Move ( 10 , 20 )
robotgo . MoveRelative ( 0 , - 10 )
robotgo . DragSmooth ( 10 , 10 )
robotgo . Click ( "wheelRight" )
robotgo . Click ( "left" , true )
robotgo . MoveSmooth ( 100 , 200 , 1.0 , 10.0 )
robotgo . Toggle ( "left" )
robotgo . Toggle ( "left" , "up" )
} package main
import (
"fmt"
"github.com/go-vgo/robotgo"
)
func main () {
robotgo . TypeStr ( "Hello World" )
robotgo . TypeStr ( "だんしゃり" , 0 , 1 )
// robotgo.TypeStr("テストする")
robotgo . TypeStr ( "Hi, Seattle space needle, Golden gate bridge, One world trade center." )
robotgo . TypeStr ( "Hi galaxy, hi stars, hi MT.Rainier, hi sea. こんにちは世界." )
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" , "cmd" )
arr := [] string { "alt" , "cmd" }
robotgo . KeyTap ( "i" , arr )
robotgo . MilliSleep ( 100 )
robotgo . KeyToggle ( "a" )
robotgo . KeyToggle ( "a" , "up" )
robotgo . WriteAll ( "Test" )
text , err := robotgo . ReadAll ()
if err == nil {
fmt . Println ( text )
}
} package main
import (
"fmt"
"strconv"
"github.com/go-vgo/robotgo"
"github.com/vcaesar/imgo"
)
func main () {
x , y := robotgo . Location ()
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 )
img := robotgo . ToImage ( bit )
imgo . Save ( "test.png" , img )
num := robotgo . DisplaysNum ()
for i := 0 ; i < num ; i ++ {
robotgo . DisplayID = i
img1 , _ := robotgo . CaptureImg ()
path1 := "save_" + strconv . Itoa ( i )
robotgo . Save ( img1 , path1 + ".png" )
robotgo . SaveJpeg ( img1 , path1 + ".jpeg" , 50 )
img2 , _ := robotgo . CaptureImg ( 10 , 10 , 20 , 20 )
robotgo . Save ( img2 , "test_" + strconv . Itoa ( i ) + ".png" )
x , y , w , h := robotgo . GetDisplayBounds ( i )
img3 , err := robotgo . CaptureImg ( x , y , w , h )
fmt . Println ( "Capture error: " , err )
robotgo . Save ( img3 , path1 + "_1.png" )
}
} package main
import (
"fmt"
"github.com/go-vgo/robotgo"
"github.com/vcaesar/bitmap"
)
func main () {
bit := robotgo . CaptureScreen ( 10 , 20 , 30 , 40 )
// use `defer robotgo.FreeBitmap(bit)` to free the bitmap
defer robotgo . FreeBitmap ( bit )
fmt . Println ( "bitmap..." , bit )
img := robotgo . ToImage ( bit )
// robotgo.SavePng(img, "test_1.png")
robotgo . Save ( img , "test_1.png" )
bit2 := robotgo . ToCBitmap ( robotgo . ImgToBitmap ( img ))
fx , fy := bitmap . Find ( bit2 )
fmt . Println ( "FindBitmap------ " , fx , fy )
robotgo . Move ( fx , fy )
arr := bitmap . FindAll ( bit2 )
fmt . Println ( "Find all bitmap: " , arr )
fx , fy = bitmap . Find ( bit )
fmt . Println ( "FindBitmap------ " , fx , fy )
bitmap . Save ( bit , "test.png" )
} package main
import (
"fmt"
"math/rand"
"github.com/go-vgo/robotgo"
"github.com/vcaesar/gcv"
"github.com/vcaesar/bitmap"
)
func main () {
opencv ()
}
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 := bitmap . Open ( name1 )
defer robotgo . FreeBitmap ( bit )
fmt . Print ( "find bitmap: " )
fmt . Println ( bitmap . Find ( 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 ()
res := gcv . FindAllImg ( img1 , img )
fmt . Println ( res [ 0 ]. TopLeft . Y , res [ 0 ]. Rects . TopLeft . X , res )
x , y := res [ 0 ]. TopLeft . X , res [ 0 ]. TopLeft . Y
robotgo . Move ( x , y - rand . Intn ( 5 ))
robotgo . MilliSleep ( 100 )
robotgo . Click ()
res = gcv . FindAll ( img1 , img ) // use find template and sift
fmt . Println ( "find all: " , res )
res1 := gcv . Find ( img1 , img )
fmt . Println ( "find: " , res1 )
img2 , _ , _ := robotgo . DecodeImg ( "test_001.png" )
x , y = gcv . FindX ( img2 , img )
fmt . Println ( x , y )
} 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 ---" )
hook . Register ( hook . KeyDown , [] string { "q" , "ctrl" , "shift" }, func ( e hook. Event ) {
fmt . Println ( "ctrl-shift-q" )
hook . End ()
})
fmt . Println ( "--- Please press w---" )
hook . Register ( hook . KeyDown , [] string { "w" }, func ( e hook. Event ) {
fmt . Println ( "w" )
})
s := hook . Start ()
<- hook . Process ( s )
}
func low () {
evChan := hook . Start ()
defer hook . End ()
for ev := range evChan {
fmt . Println ( "hook: " , ev )
}
}
func event () {
ok := hook . AddEvents ( "q" , "ctrl" , "shift" )
if ok {
fmt . Println ( "add events..." )
}
keve := hook . AddEvent ( "k" )
if keve {
fmt . Println ( "you press... " , "k" )
}
mleft := hook . AddEvent ( "mleft" )
if mleft {
fmt . Println ( "you press... " , "mouse left button" )
}
} 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 . TypeStr ( "Hi galaxy!" , fpid [ 0 ])
robotgo . KeyTap ( "a" , fpid [ 0 ], "cmd" )
robotgo . KeyToggle ( "a" , fpid [ 0 ])
robotgo . KeyToggle ( "a" , fpid [ 0 ], "up" )
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 . Alert ( "test" , "robotgo" )
if abool {
fmt . Println ( "ok@@@ " , "ok" )
}
title := robotgo . GetTitle ()
fmt . Println ( "title@@@ " , title )
}Robotgo se distribuye principalmente bajo los términos de "tanto la licencia MIT como la licencia Apache (versión 2.0)", con porciones cubiertas por varias licencias similares a BSD.
Ver licencia-apache, licencia-mit.
