So implementieren Sie ein Programm in Golang, das das Fenster der obersten Ebene des Bildschirms abrufen und anzeigen kann

In aktuellen Computer-Betriebssystemen bezieht sich die oberste Ebene des Bildschirms auf das aktuell angezeigte Fenster oder die aktuell angezeigte Anwendung. In Windows-Systemen können Fenster der obersten Ebene über die Win32-API abgerufen und verwaltet werden. In diesem Artikel stellen wir vor, wie Sie mit Golang ein Programm implementieren, das das Fenster der obersten Ebene des Bildschirms abrufen und anzeigen kann.

1. Holen Sie sich die Fensterliste der obersten Ebene

Verwenden Sie in Golang das Syscall-Paket, um Funktionen auf Systemebene aufzurufen. Wir können die Funktion FindWindowEx verwenden, um die Handle-Liste des Fensters der obersten Ebene abzurufen. Zum Beispiel:

hwnd := uintptr(0)
var list []uintptr
for {
    hwnd = uintptr(C.FindWindowEx(
        0,
        hwnd,
        nil,
        nil,
    ))
    if hwnd == 0 {
        break
    }
    list = append(list, hwnd)
}

Unter diesen haben die Parameter der FindWindowEx-Funktion folgende Bedeutung:

• Der erste Parameter ist das Handle des übergeordneten Fensters, in dem die Suche beginnt. Wenn es 0 ist, beginnt die Suche auf dem Desktop.
• Der zweite Parameter ist das Handle des vorherigen Fensters. Wenn es 0 ist, beginnt die Suche beim ersten Fenster.
• Der dritte Parameter ist der Fensterklassenname. Null bedeutet, dass es keine Einschränkung für den Fensterklassennamen gibt.
• Der vierte Parameter ist der Fenstertitel. Null bedeutet, dass der Fenstertitel nicht eingeschränkt wird.

Der Rückgabewert ist das gefundene Fensterhandle. Wenn es nicht gefunden wird, wird 0 zurückgegeben.

2. Fensterinformationen der obersten Ebene abrufen

Nachdem wir das Fensterhandle erhalten haben, können wir die GetWindowRect-Funktion aufrufen, um die Positions- und Größeninformationen des Fensters abzurufen. Zum Beispiel:

var rect syscall.Rect
C.GetWindowRect(
    C.HWND(hwnd),
    (*C.RECT)(unsafe.Pointer(&rect)),
)

Unter diesen haben die Parameter der GetWindowRect-Funktion die folgende Bedeutung:

• Der erste Parameter ist das Fensterhandle.
• Der zweite Parameter ist ein Zeiger auf die Informationen zur Fensterposition und -größe.

3. Fensterinformationen der obersten Ebene anzeigen

Durch den Erhalt der Fensterpositions- und -größeninformationen können wir die Grafikbibliothek von Golang verwenden, um die Miniaturansicht des Fensters anzuzeigen. Zum Beispiel:

thumb, err := goscreenshot.CaptureWindowRect(rect)
if err != nil {
    log.Println(err)
    continue
}
screen, err := png.Decode(bytes.NewReader(thumb))
if err != nil {
    log.Println(err)
    continue
}
win := Window{
    Title:   title,
    X:       rect.Left,
    Y:       rect.Top,
    Width:   rect.Right - rect.Left,
    Height:  rect.Bottom - rect.Top,
    Picture: screen,
}
viewer.Show(win)

Unter diesen implementiert die CaptureWindowRect-Funktion die Fenster-Screenshot-Funktion über das Screenshot-Paket von Golang. Verwenden Sie dann das Image/PNG-Paket von Golang, um die Bilddaten zu lesen und im Fenster anzuzeigen. Abschließend wird die Fensterstruktur definiert und die Methode viewer.Show wird zum Anzeigen von Fensterinformationen verwendet.

4. Vollständiger Code

Der vollständige Code lautet wie folgt:

package main

import (
    "bytes"
    "image/png"
    "log"
    "unsafe"

    "github.com/lxn/walk"
    . "github.com/lxn/walk/declarative"
    "golang.org/x/sys/windows"
)

var (
    C = windows.NewLazySystemDLL("user32.dll")
)

// 窗口信息结构
type Window struct {
    Title   string      // 窗口标题
    X       int32       // 窗口左上角X坐标
    Y       int32       // 窗口左上角Y坐标
    Width   int32       // 窗口宽度
    Height  int32       // 窗口高度
    Picture image.Image // 窗口截图
}

func main() {

    // 创建窗口
    var mw *walk.MainWindow
    var tv *walk.TableView
    var viewer *walk.ImageView
    MainWindow{
        Title:   "Screen Viewer",
        MinSize: Size{640, 480},
        Layout:  VBox{},
        Children: []Widget{
            TableView{
                AssignTo:         &tv,
                AlternatingRowBG: true,
                Columns: []TableViewColumn{
                    {Title: "Title"},
                    {Title: "X"},
                    {Title: "Y"},
                    {Title: "Width"},
                    {Title: "Height"},
                },
            },
            ImageView{
                AssignTo: &viewer,
            },
        },
    }.Create(&mw)

    // 获取顶层窗口列表
    hwnd := uintptr(0)
    var list []uintptr
    for {
        hwnd = uintptr(C.FindWindowEx(
            0,
            hwnd,
            nil,
            nil,
        ))
        if hwnd == 0 {
            break
        }
        list = append(list, hwnd)
    }

    // 遍历窗口列表并显示窗口信息
    var data []Window
    for _, hwnd := range list {
        var rect syscall.Rect
        C.GetWindowRect(
            C.HWND(hwnd),
            (*C.RECT)(unsafe.Pointer(&rect)),
        )
        title := getWindowText(hwnd)
        if title == "" {
            continue
        }
        thumb, err := goscreenshot.CaptureWindowRect(rect)
        if err != nil {
            log.Println(err)
            continue
        }
        screen, err := png.Decode(bytes.NewReader(thumb))
        if err != nil {
            log.Println(err)
            continue
        }
        win := Window{
            Title:   title,
            X:       rect.Left,
            Y:       rect.Top,
            Width:   rect.Right - rect.Left,
            Height:  rect.Bottom - rect.Top,
            Picture: screen,
        }
        data = append(data, win)
        tv.PublishRowsReset()
    }

    // 设置模型
    model, _ := NewWindowModel(data)
    tv.SetModel(model)

    // 开始消息循环
    mw.Run()
}

// 获取窗口标题
func getWindowText(hwnd uintptr) string {
    var buf [256]uint16
    C.GetWindowText(
        C.HWND(hwnd),
        (*C.CHAR)(unsafe.Pointer(&buf)),
        256,
    )
    return syscall.UTF16ToString(buf[:])
}

// 窗口模型
type WindowModel struct {
    walk.TableModelBase
    items []Window
}

func NewWindowModel(items []Window) (*WindowModel, error) {
    m := new(WindowModel)

    m.items = items

    return m, nil
}

func (m *WindowModel) RowCount() int {
    return len(m.items)
}

func (m *WindowModel) Value(row, col int) interface{} {
    item := m.items[row]

    switch col {
    case 0:
        return item.Title

    case 1:
        return item.X

    case 2:
        return item.Y

    case 3:
        return item.Width

    case 4:
        return item.Height

    }

    panic("unexpected col")
}

5. Zusammenfassung

In diesem Artikel wird erläutert, wie Sie mit Golang ein Programm implementieren, um das Fenster der obersten Ebene des Bildschirms abzurufen und anzuzeigen. Durch den Aufruf von Windows-API-Funktionen und die Implementierung von Vorgängen wie Fenster-Screenshots und Bildanzeige können wir ganz einfach ein einfaches Screenshot-Tool schreiben. Gleichzeitig können wir durch die Zusammenarbeit mit der Grafikbibliothek von Golang und der Windows-API plattformübergreifende Anwendungen schreiben.

Das obige ist der detaillierte Inhalt vonSo implementieren Sie ein Programm in Golang, das das Fenster der obersten Ebene des Bildschirms abrufen und anzeigen kann. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!