基于Go编写一个Windows剪贴板监控器

package main

import (
	"bytes"
	"fmt"
	"io"
	"reflect"
	"syscall"
	"unicode/utf16"
	"unsafe"

	"golang.org/x/sys/windows"
	"golang.org/x/text/encoding/simplifiedchinese"
	"golang.org/x/text/transform"
)

// ===== Win32 API Constants =====
const (
	WM_CREATE        = 0x0001
	WM_DESTROY       = 0x0002
	WM_DRAWCLIPBOARD = 0x0308
	WM_CHANGECBCHAIN = 0x030D
	CF_TEXT          = 1
	CF_BITMAP        = 2
	CF_UNICODETEXT   = 13
	CF_HDROP         = 15
)

// ===== Win32 Structures =====
type WNDCLASSEX struct {
	Size       uint32
	Style      uint32
	WndProc    uintptr
	ClsExtra   int32
	WndExtra   int32
	Instance   syscall.Handle
	Icon       syscall.Handle
	Cursor     syscall.Handle
	Background uintptr
	MenuName   *uint16
	ClassName  *uint16
	IconSm     syscall.Handle
}

type MSG struct {
	HWnd    uintptr
	Message uint32
	WParam  uintptr
	LParam  uintptr
	DwTime  uint32
	PtX     int32
	PtY     int32
}

// ===== Win32 API Procs =====
var (
	user32   = windows.NewLazySystemDLL("user32.dll")
	kernel32 = windows.NewLazySystemDLL("kernel32.dll")
	shell32  = windows.NewLazySystemDLL("shell32.dll")

	procRegisterClassEx      = user32.NewProc("RegisterClassExW")
	procCreateWindowEx       = user32.NewProc("CreateWindowExW")
	procDefWindowProc        = user32.NewProc("DefWindowProcW")
	procOpenClipboard        = user32.NewProc("OpenClipboard")
	procCloseClipboard       = user32.NewProc("CloseClipboard")
	procEnumClipboardFormats = user32.NewProc("EnumClipboardFormats")
	procGetClipboardData     = user32.NewProc("GetClipboardData")
	procSetClipboardViewer   = user32.NewProc("SetClipboardViewer")
	procGetMessage           = user32.NewProc("GetMessageW")
	procTranslateMessage     = user32.NewProc("TranslateMessage")
	procDispatchMessage      = user32.NewProc("DispatchMessageW")
	procShowWindow           = user32.NewProc("ShowWindow")
	procGlobalLock           = kernel32.NewProc("GlobalLock")
	procGlobalUnlock         = kernel32.NewProc("GlobalUnlock")
	procDragQueryFile        = shell32.NewProc("DragQueryFileW")
)

// ===== 窗口过程函数 =====
func windowProc(hwnd syscall.Handle, msg uint32, wParam uintptr, lParam uintptr) uintptr {
	switch msg {
	case WM_CREATE:
		_, _, _ = procSetClipboardViewer.Call(uintptr(hwnd))

	case WM_DRAWCLIPBOARD:
		if ret, _, _ := procOpenClipboard.Call(uintptr(hwnd)); ret == 0 {
			fmt.Println("❌ 无法打开剪切板")
			break
		}
		var format uint32 = 0
		var finalText string

		for {
			r1, _, _ := procEnumClipboardFormats.Call(uintptr(format))
			format = uint32(r1)
			if format == 0 {
				break
			}

			hMem, _, _ := procGetClipboardData.Call(uintptr(format))
			if hMem == 0 {
				continue
			}

			switch format {
			case CF_UNICODETEXT:
				text, err := getUnicodeText(hMem)
				if err == nil {
					finalText = text
					goto done
				}
			case CF_TEXT:
				text, err := getAnsiText(hMem)
				if err == nil && finalText == "" {
					finalText = text
				}
			case CF_HDROP:
				finalText = ""
				files, err := getHDropFiles(hMem)
				if err != nil {
					fmt.Println("❌ 文件列表: 读取文件失败:", err)
				} else {
					fmt.Printf("📎 拖放的文件 (%d):\n", len(files))
					for _, f := range files {
						fmt.Println(" -", f)
					}
				}
			default:
				finalText = ""
				fmt.Printf("📎 %s\n", getClipboardFormatName(format))
			}
		}
	done:
		if finalText != "" {
			fmt.Printf("📝 文本内容:\n%s\n", finalText)
		}
		procCloseClipboard.Call()

	case WM_CHANGECBCHAIN:
		fmt.Println("⛓️ 剪切板查看器链已更改")

	default:
		ret, _, _ := procDefWindowProc.Call(uintptr(hwnd), uintptr(msg), wParam, lParam)
		return ret
	}
	return 0
}

// ===== 辅助函数 =====
func getAnsiText(hMem uintptr) (string, error) {
	lpLock, _, _ := procGlobalLock.Call(hMem)
	if lpLock == 0 {
		return "", fmt.Errorf("无法锁定内存")
	}
	defer procGlobalUnlock.Call(hMem)

	var size int
	for {
		b := *(*byte)(unsafe.Pointer(lpLock + uintptr(size)))
		if b == 0 {
			break
		}
		size++
	}

	data := make([]byte, size)
	for i := 0; i < size; i++ {
		data[i] = *(*byte)(unsafe.Pointer(lpLock + uintptr(i)))
	}

	decoder := simplifiedchinese.GBK.NewDecoder()
	reader := transform.NewReader(bytes.NewReader(data), decoder)
	utf8Bytes, err := io.ReadAll(reader)
	if err != nil {
		return "", err
	}
	return string(utf8Bytes), nil
}

func getUnicodeText(hMem uintptr) (string, error) {
	lpLock, _, _ := procGlobalLock.Call(hMem)
	if lpLock == 0 {
		return "", fmt.Errorf("无法锁定内存")
	}
	defer procGlobalUnlock.Call(hMem)

	var length int
	for {
		w := *(*uint16)(unsafe.Pointer(lpLock + uintptr(length*2)))
		if w == 0 {
			break
		}
		length++
	}

	sliceHeader := reflect.SliceHeader{
		Data: lpLock,
		Len:  length,
		Cap:  length,
	}
	utf16Data := *(*[]uint16)(unsafe.Pointer(&sliceHeader))

	runes := utf16.Decode(utf16Data)
	return string(runes), nil
}

func getHDropFiles(hMem uintptr) ([]string, error) {
	lpLock, _, _ := procGlobalLock.Call(hMem)
	if lpLock == 0 {
		return nil, fmt.Errorf("无法锁定HDROP内存")
	}
	defer procGlobalUnlock.Call(hMem)

	count, _, _ := procDragQueryFile.Call(lpLock, 0xFFFFFFFF, 0, 0)
	if count == 0 {
		return nil, fmt.Errorf("HDROP中未找到文件")
	}

	files := make([]string, count)
	for i := uintptr(0); i < count; i++ {
		var buf [260]uint16
		_, _, _ = procDragQueryFile.Call(lpLock, i, uintptr(unsafe.Pointer(&buf[0])), uintptr(len(buf)))
		files[i] = syscall.UTF16ToString(buf[:])
	}
	return files, nil
}

func getClipboardFormatName(format uint32) string {
	if format <= 0xC000 {
		switch format {
		case CF_TEXT:
			return "CF_TEXT (ANSI文本)"
		case CF_UNICODETEXT:
			return "CF_UNICODETEXT"
		case CF_BITMAP:
			return "CF_BITMAP (位图)"
		case CF_HDROP:
			return "CF_HDROP (文件列表)"
		default:
			return "标准格式"
		}
	}
	buf := make([]uint16, 256)
	r1, _, _ := user32.NewProc("GetClipboardFormatNameW").Call(
		uintptr(format),
		uintptr(unsafe.Pointer(&buf[0])),
		uintptr(len(buf)),
	)
	if r1 == 0 {
		return fmt.Sprintf("未知自定义格式 (%d)", format)
	}
	return "自定义格式: " + syscall.UTF16ToString(buf)
}

func init() {
	if err := shell32.Load(); err != nil {
		panic("无法加载shell32.dll: " + err.Error())
	}
}

func main() {
	className := syscall.StringToUTF16Ptr("ClipboardMonitorClass")

	var wc WNDCLASSEX
	wc.Size = uint32(unsafe.Sizeof(wc))
	wc.WndProc = syscall.NewCallback(windowProc)
	wc.Instance = 0
	wc.ClassName = className
	wc.Style = 0x0002 // CS_HREDRAW

	ret, _, err := procRegisterClassEx.Call(uintptr(unsafe.Pointer(&wc)))
	if ret == 0 {
		panic("注册窗口类失败: " + err.Error())
	}

	hwnd, _, err := procCreateWindowEx.Call(
		0,
		uintptr(unsafe.Pointer(className)),
		uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr("剪切板监视器"))),
		0,
		0, 0, 100, 100,
		0, 0, 0, 0,
	)
	if hwnd == 0 {
		panic("创建窗口失败: " + err.Error())
	}

	procShowWindow.Call(hwnd, 0) // 隐藏窗口

	fmt.Println("🚀 剪贴板监视器已启动。现在可以复制内容进行测试！")

	var msg MSG
	for {
		ret, _, _ := procGetMessage.Call(uintptr(unsafe.Pointer(&msg)), 0, 0, 0)
		if ret <= 0 {
			break
		}
		procTranslateMessage.Call(uintptr(unsafe.Pointer(&msg)))
		procDispatchMessage.Call(uintptr(unsafe.Pointer(&msg)))
	}
}

go mod init clipboard-monitor
go get golang.org/x/sys/windows
go get golang.org/x/text/encoding/simplifiedchinese

go run main.go