robotgo Téléchargement - robotgo Code source Télécharger

Robotgo

Golang Desktop Automation. Contrôlez la souris, le clavier, lisez l'écran, le processus, la poignée de fenêtre, l'image et le bitmap et l'écouteur d'événements global.

Robotgo prend en charge Mac, Windows et Linux (X11); et Robotgo prend en charge ARM64 et X86-AMD64.

Contenu

Docs
Obligatoire
Exigences
Installation
Mise à jour
Exemples
Type Conversion et touches
Compilant
Auteurs
Plans
Faire un don
Contributeurs
Licence

Docs

Godoc
API Docs (déprécié, pas mis à jour)

Obligatoire:

ADB, API Android Android Android.

Robotn, Binding JavaScript et autres, prennent en charge plus de langage.

Exigences:

Maintenant, assurez-vous que Golang, GCC est installé correctement avant d'installer Robotgo.

TOUS:

 Golang

GCC

Pour macOS:

Outils de ligne de commande xcode (et paramètre de confidentialité: # 277)

 xcode-select --install

Pour Windows:

MINGW-W64 (utiliser recommandé) ou autres Mingw LLVM-MingW;

Téléchargez le Mingw, puis définissez les variables d'environnement système C:mingw64bin sur le chemin. Définissez les variables d'environnement pour exécuter GCC à partir de la ligne de commande.

Or the other GCC (mais vous devez compiler le "libpng" avec vous-même lorsque vous utilisez le bitmap.)

Pour tout le reste:

 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".)

Ubuntu:

 # 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

Feutre:

 # 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

Installation:

Avec la prise en charge du module GO (Go 1.11+), il suffit d'importer:

 import "github.com/go-vgo/robotgo"

Sinon, pour installer le package robotgo, exécutez la commande:

 go get github.com/go-vgo/robotgo

PNG.H: Pas de fichier ou de répertoire de ce type? Veuillez consulter les problèmes / 47.

Mise à jour:

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

Remarque Go1.10.x Cache de compilation de fichiers C, Golang # 24355. go mod vendor Problem, Golang # 26366.

Exemples:

Souris

 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" )
}

Clavier

 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 )
  }
}

Écran

 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" )
  }
}

Bitmap

 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" )
}

Opencv

 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 )
}

Événement

 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" )
  }
}

Fenêtre

 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 )
}

Auteurs

L'auteur est vz
Maintient
Contributeurs

Plans

Refactor un code C à aller (comme X11, Windows)
Meilleur support multipreen
Support de Wayland
Mettre à jour la poignée de la fenêtre
Essayez de prendre en charge Android et iOS

Contributeurs

Voir la page des contributeurs pour la liste complète des contributeurs.
Voir les directives de contribution.

Licence

Robotgo est principalement distribué en vertu des termes de "à la fois la licence MIT et la licence Apache (version 2.0)", avec des parties couvertes par diverses licences de type BSD.

Voir Licence-APache, Licence-MIT.

Développer