Screenshot der Golang-Implementierung

Da die Menschen in den letzten Jahren immer abhängiger vom Internet geworden sind, hat in vielen Branchen begonnen, sich in Richtung Digitalisierung zu wandeln. Unter ihnen wächst die Nachfrage nach Netzwerkkommunikation und Fernarbeit von Tag zu Tag, und es sind auch verschiedene Tools für Online-Konferenzen und Fernarbeit entstanden. Für diese Anwendungsszenarien ist die Screenshot-Funktion zu einer unverzichtbaren Funktion geworden. In diesem Artikel stellen wir vor, wie Sie Golang, eine leistungsstarke Programmiersprache, zum Implementieren der Screenshot-Funktion verwenden.

Golang-Einführung
Golang, auch bekannt als Go-Sprache, ist eine aufstrebende Programmiersprache. Ihr Designziel besteht darin, einfach zu erlernen, effizient und schnell zu sein und gleichzeitig die Sicherheit und Zuverlässigkeit zu gewährleisten Code. Golang verfügt über einen Garbage-Collection-Mechanismus und gleichzeitige Programmierprimitive, die sich sehr gut für die Entwicklung von Internetanwendungen eignen.

Golangs Screenshot-Implementierung
In Golang ist die Implementierung der Screenshot-Funktion hauptsächlich in die folgenden Schritte unterteilt:

1. Zunächst müssen Sie sie vorstellen einige notwendige Pakete, wie Image und Syscall usw.

import (

"image"
"os"
"syscall"

)

2. Als nächstes müssen Sie die Systemfunktion verwenden, um die aktuell laufende Datei abzurufen Fensterinformationen: Ruft das Fensterhandle des Betriebssystems ab, das dann in Golang in ein Bildobjekt konvertiert werden kann.

func getScreenShot() Fehler {

hwnd := syscall.GetForegroundWindow()
if hwnd == 0 {
    return fmt.Errorf("could not find foreground window")
}
dc := syscall.GetDC(hwnd)
defer syscall.ReleaseDC(hwnd, dc)
rect := &syscall.Rect{}
if !syscall.GetWindowRect(hwnd, rect) {
    return fmt.Errorf("could not get window rect")
}
width := rect.Right - rect.Left
height := rect.Bottom - rect.Top
img, err := image.NewRGBA(image.Rect(0, 0, width, height))
if err != nil {
    return err
}
return nil

}

3. Dann müssen die Bilddaten abgerufen werden Speichern Sie den Gerätekontext in einem Bildobjekt in Golang.

pixels := make([]uint8, widthheight4)
_, _, err = syscall.BitBlt(0, 0 , width, height, dc, 0, 0, syscall.SRCCOPY)
if err != nil {

return err

}
bi := &syscall.Bitmapinfo{}#🎜🎜 #bi.BmiHeader.BiSize = uint32(unsafe.Sizeof(bi.BmiHeader))
bi.BmiHeader.BiWidth = width;
bi.BmiHeader.BiHeight = -height;
bi.BmiHeader .BiPlanes = 1
bi.BmiHeader.BiBitCount = 32
bi.BmiHeader.BiCompression = syscall.BI_RGB
bi.BmiHeader.BiSizeImage = uint32(len(pixels))
if _, _, err = syscall.GetDIBits(dc, syscall.HBITMAP(syscall.GetStockObject(syscall.BLACK_BRUSH)), 0, uint32(height), &pixels[0], bi, 0); err != nil {#🎜 🎜#

return err

}

für y := y < y++ {

for x := 0; x < width; x++ {
    i := (y*width + x) * 4
    R := pixels[i+2]
    G := pixels[i+1]
    B := pixels[i]
    img.Set(x, y, color.RGBA{R, G, B, 255})
}

}

Endlich Bild Objekte in Golang werden als Dateien gespeichert.

4. file, err := os.Create("screenshot.png")
if err != nil {

return err

}#🎜🎜 #defer file.Close()
if err = png.Encode(file, img); err != nil {

return err

}

Vollständige Code-Implementierung:

Pakethauptteil

import (

"fmt"
"image"
"image/color"
"image/png"
"os"
"syscall"
"unsafe"

)

func getScreenShot() Fehler {

hwnd := syscall.GetForegroundWindow()
if hwnd == 0 {
    return fmt.Errorf("could not find foreground window")
}
dc := syscall.GetDC(hwnd)
defer syscall.ReleaseDC(hwnd, dc)
rect := &syscall.Rect{}
if !syscall.GetWindowRect(hwnd, rect) {
    return fmt.Errorf("could not get window rect")
}
width := rect.Right - rect.Left
height := rect.Bottom - rect.Top
img, err := image.NewRGBA(image.Rect(0, 0, width, height))
if err != nil {
    return err
}

defer func() {
    if panicErr := recover(); panicErr != nil {
        err = fmt.Errorf("%v", panicErr)
    }
}()

pixels := make([]uint8, width*height*4)
_, _, err = syscall.BitBlt(0, 0, width, height, dc, 0, 0, syscall.SRCCOPY)
if err != nil {
    return err
}
bi := &syscall.Bitmapinfo{}
bi.BmiHeader.BiSize = uint32(unsafe.Sizeof(bi.BmiHeader))
bi.BmiHeader.BiWidth = width;
bi.BmiHeader.BiHeight = -height;
bi.BmiHeader.BiPlanes = 1
bi.BmiHeader.BiBitCount = 32
bi.BmiHeader.BiCompression = syscall.BI_RGB
bi.BmiHeader.BiSizeImage = uint32(len(pixels))

if _, _, err = syscall.GetDIBits(dc, syscall.HBITMAP(syscall.GetStockObject(syscall.BLACK_BRUSH)), 0, uint32(height), &pixels[0], bi, 0); err != nil {
    return err
}

for y := 0; y < height; y++ {
    for x := 0; x < width; x++ {
        i := (y*width + x) * 4
        R := pixels[i+2]
        G := pixels[i+1]
        B := pixels[i]
        img.Set(x, y, color.RGBA{R, G, B, 255})
    }
}

file, err := os.Create("screenshot.png")
if err != nil {
    return err
}
defer file.Close()
if err = png.Encode(file, img); err != nil {
    return err
}

return nil

# 🎜🎜#}

func main() {

err := getScreenShot()
if err != nil {
    fmt.Println(err)
}

}

Fazit

Dieser Artikel beschreibt, wie man Golang zur Implementierung verwendet Screenshot-Funktion. Golang ist eine effiziente, einfache und sichere Programmiersprache mit guter Parallelitätsleistung und eignet sich für verschiedene Anwendungsszenarien. Ich glaube, dass die Leser durch die Einführung dieses Artikels die Fähigkeiten zur Verwendung von Golang zur Implementierung der Screenshot-Funktion beherrschen. Ich hoffe, dass dieser Artikel für alle hilfreich sein wird.

Das obige ist der detaillierte Inhalt vonScreenshot der Golang-Implementierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!