How to implement a program in golang that can obtain and display the top-level window of the screen

In the current computer operating system, the top layer of the screen refers to the window or application currently being displayed. In Windows systems, top-level windows can be obtained and managed through the Win32 API. In this article, we will introduce how to use golang to implement a program that can obtain and display the top-level window of the screen.

1. Get the top-level window list

In golang, use the syscall package to call system-level functions. We can use the FindWindowEx function to obtain the handle list of the top-level window. For example:

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

Among them, the meaning of the parameters of the FindWindowEx function is as follows:

• The first parameter is the parent window handle where the search starts. If it is 0, the search starts from the desktop.
• The second parameter is the handle of the previous window. If it is 0, the search starts from the first window.
• The third parameter is the window class name, nil means that the window class name is not restricted.
• The fourth parameter is the window title, nil means not to limit the window title.

The return value is the found window handle. If not found, 0 is returned.

2. Get top-level window information

After obtaining the window handle, we can call the GetWindowRect function to obtain the position and size information of the window. For example:

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

Among them, the parameters of the GetWindowRect function have the following meanings:

• The first parameter is the window handle.
• The second parameter is a pointer to the window position and size information.

3. Display top-level window information

By obtaining the window position and size information, we can use golang's graphics library to display the thumbnail of the window. For example:

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)

Among them, the CaptureWindowRect function implements the window screenshot function through golang's screenshot package. Then use golang's image/png package to read the image data and display it in the window. Finally, the Window structure is defined and the viewer.Show method is used to display window information.

4. Complete code

The complete code is as follows:

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. Summary

This article introduces how to use Golang implements a program to obtain and display the top-level window of the screen. By calling Windows API functions and implementing operations such as window screenshots and image display, we can easily write a simple screenshot tool. At the same time, with the cooperation of golang's graphics library and Windows API, we can write cross-platform applications.

The above is the detailed content of How to implement a program in golang that can obtain and display the top-level window of the screen. For more information, please follow other related articles on the PHP Chinese website!