robotgoダウンロードrobotgoソースコードのダウンロード

Robotgo

Golangデスクトップオートメーション。マウス、キーボードを制御し、画面、プロセス、ウィンドウハンドル、画像、ビットマップ、およびグローバルイベントリスナーを読み取ります。

RobotgoはMac、Windows、およびLinux（x11）をサポートしています。 RobotgoはARM64およびX86-AMD64をサポートしています。

コンテンツ

ドキュメント
バインディング
要件
インストール
アップデート
例
タイプ変換とキー
クロスコンパイル
著者
予定
寄付する
貢献者
ライセンス

ドキュメント

godoc
APIドキュメント（非推奨、更新なし）

バインディング：

ADB、パッケージングAndroid ADB API。

Robotn、バインディングJavaScriptおよびその他は、より多くの言語をサポートします。

要件：

ここで、Robotgoを設置する前に、 Golang, GCCが正しくインストールされていることを確認してください。

全て：

 Golang

GCC

macosの場合：

Xcodeコマンドラインツール（およびプライバシー設定：＃277）

 xcode-select --install

Windowsの場合：

MingW-W64（推奨を使用）またはその他のMingw llvm-mingw;

MINGWをダウンロードしてから、システム環境変数C:mingw64binパスに設定します。環境変数を設定して、コマンドラインからGCCを実行します。

Or the other GCC （ただし、ビットマップを使用するときは「libpng」を自分でコンパイルする必要があります。）

他のすべてのために：

 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

Fedora：

 # 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

インストール：

GOモジュールサポート（GO 1.11+）を使用すると、インポートするだけです。

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

それ以外の場合は、Robotgoパッケージをインストールするには、コマンドを実行します。

 go get github.com/go-vgo/robotgo

PNG.H：そのようなファイルやディレクトリはありませんか？問題/47を参照してください。

アップデート：

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

メモgo1.10.x cファイルコンピレーションキャッシュの問題、Golang＃24355。 GoLang＃26366、 go mod vendor 。

例：

ねずみ

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

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

イベント

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