clipboard.go

package main

import (
	"encoding/binary"
	"fmt"
	"syscall"
	"unicode/utf16"
	"unsafe"
)

// ---------------- Windows 剪贴板（CF_HDROP / CF_UNICODETEXT） ----------------

const (
	cF_HDROP        = 15
	cF_UNICODETEXT  = 13
	gmemMoveable    = 0x0002
	dropeffectCopy  = 1
	dropeffectMove  = 2
	cfstrDropEffect = "Preferred DropEffect"
)

var (
	procOpenClipboard            = user32.NewProc("OpenClipboard")
	procEmptyClipboard           = user32.NewProc("EmptyClipboard")
	procSetClipboardData         = user32.NewProc("SetClipboardData")
	procGetClipboardData         = user32.NewProc("GetClipboardData")
	procCloseClipboard           = user32.NewProc("CloseClipboard")
	procIsClipboardFormatAvail   = user32.NewProc("IsClipboardFormatAvailable")
	procRegisterClipboardFormatW = user32.NewProc("RegisterClipboardFormatW")
	procGlobalAlloc              = kernel32.NewProc("GlobalAlloc")
	procGlobalLock               = kernel32.NewProc("GlobalLock")
	procGlobalUnlock             = kernel32.NewProc("GlobalUnlock")
	procGlobalFree               = kernel32.NewProc("GlobalFree")
)

// DROPFILES 剪贴板文件列表结构（CF_HDROP）
type DROPFILES struct {
	PFiles uint32 // 文件列表相对结构起点的偏移
	Pt     struct{ X, Y int32 }
	FNC    int32 // 非 Unicode
	FWide  int32 // Unicode（1 = UTF-16）
}

var dropEffectFormat uint16 // 懒注册

func dropEffectFmt() uint16 {
	if dropEffectFormat == 0 {
		name, _ := syscall.UTF16PtrFromString(cfstrDropEffect)
		r, _, _ := procRegisterClipboardFormatW.Call(uintptr(unsafe.Pointer(name)))
		dropEffectFormat = uint16(r)
	}
	return dropEffectFormat
}

func globalAlloc(flags uint32, size int) (uintptr, error) {
	r, _, err := procGlobalAlloc.Call(uintptr(flags), uintptr(size))
	if r == 0 {
		return 0, fmt.Errorf("分配内存失败：%v", err)
	}
	return r, nil
}

func globalLockPtr(h uintptr) (unsafe.Pointer, error) {
	r, _, _ := procGlobalLock.Call(h)
	if r == 0 {
		return nil, fmt.Errorf("锁定内存失败")
	}
	// uintptr 是 GlobalLock 返回的真实指针，按位转回 unsafe.Pointer
	p := *(*unsafe.Pointer)(unsafe.Pointer(&r))
	return p, nil
}

// SetClipboardFiles 把文件路径写入剪贴板（cut=true 表示剪切）
func SetClipboardFiles(paths []string, cut bool) error {
	if len(paths) == 0 {
		return fmt.Errorf("没有可复制的文件")
	}
	// 构造 DROPFILES + UTF-16 路径列表（双 null 结尾）
	dfSize := int(unsafe.Sizeof(DROPFILES{}))
	df := DROPFILES{PFiles: uint32(dfSize), FWide: 1}
	buf := make([]byte, 0, dfSize+len(paths)*160)
	dfRaw := unsafe.Slice((*byte)(unsafe.Pointer(&df)), dfSize)
	buf = append(buf, dfRaw...)
	for _, p := range paths {
		for _, c := range utf16.Encode([]rune(p)) {
			var b [2]byte
			binary.LittleEndian.PutUint16(b[:], c)
			buf = append(buf, b[:]...)
		}
		buf = append(buf, 0, 0) // 每个路径后 null
	}
	buf = append(buf, 0, 0) // 列表结尾双 null

	if r, _, _ := procOpenClipboard.Call(0); r == 0 {
		return fmt.Errorf("无法打开剪贴板（可能被其他程序占用）")
	}
	defer procCloseClipboard.Call()
	procEmptyClipboard.Call()

	h, err := globalAlloc(gmemMoveable, len(buf))
	if err != nil {
		return err
	}
	p, err := globalLockPtr(h)
	if err != nil {
		procGlobalFree.Call(h)
		return err
	}
	copy(unsafe.Slice((*byte)(p), len(buf)), buf)
	procGlobalUnlock.Call(h)
	if r, _, _ := procSetClipboardData.Call(cF_HDROP, h); r == 0 {
		procGlobalFree.Call(h)
		return fmt.Errorf("写入剪贴板失败")
	}

	// 写入操作类型（复制=1 / 剪切=2）
	effect := uint32(dropeffectCopy)
	if cut {
		effect = dropeffectMove
	}
	h2, err := globalAlloc(gmemMoveable, 4)
	if err != nil {
		return err
	}
	p2, err := globalLockPtr(h2)
	if err != nil {
		procGlobalFree.Call(h2)
		return err
	}
	*(*uint32)(p2) = effect
	procGlobalUnlock.Call(h2)
	if r, _, _ := procSetClipboardData.Call(uintptr(dropEffectFmt()), h2); r == 0 {
		procGlobalFree.Call(h2)
	}
	return nil
}

// GetClipboardFiles 读取剪贴板中的文件路径及操作类型（cut=true 为剪切）
func GetClipboardFiles() (paths []string, cut bool, err error) {
	if r, _, _ := procOpenClipboard.Call(0); r == 0 {
		return nil, false, fmt.Errorf("无法打开剪贴板")
	}
	defer procCloseClipboard.Call()

	// 操作类型
	if r, _, _ := procIsClipboardFormatAvail.Call(uintptr(dropEffectFmt())); r != 0 {
		if h, _, _ := procGetClipboardData.Call(uintptr(dropEffectFmt())); h != 0 {
			if p, e := globalLockPtr(h); e == nil {
				cut = *(*uint32)(p) == dropeffectMove
				procGlobalUnlock.Call(h)
			}
		}
	}

	if r, _, _ := procIsClipboardFormatAvail.Call(cF_HDROP); r == 0 {
		return nil, false, fmt.Errorf("剪贴板中没有文件")
	}
	h, _, _ := procGetClipboardData.Call(cF_HDROP)
	if h == 0 {
		return nil, false, fmt.Errorf("读取剪贴板失败")
	}
	p, err := globalLockPtr(h)
	if err != nil {
		return nil, false, err
	}
	defer procGlobalUnlock.Call(h)

	df := (*DROPFILES)(p)
	base := unsafe.Add(p, uintptr(df.PFiles))
	offset := uintptr(0)
	for {
		var chars []uint16
		for {
			c := *(*uint16)(unsafe.Add(base, offset))
			offset += 2
			if c == 0 {
				break
			}
			chars = append(chars, c)
		}
		if len(chars) == 0 {
			break // 双 null 结束
		}
		paths = append(paths, string(utf16.Decode(chars)))
	}
	if len(paths) == 0 {
		return nil, false, fmt.Errorf("剪贴板中没有文件")
	}
	return paths, cut, nil
}

// SetClipboardText 复制纯文本（用于"复制为路径"）
func SetClipboardText(text string) error {
	u := utf16.Encode([]rune(text))
	data := make([]uint16, len(u)+1)
	copy(data, u)

	if r, _, _ := procOpenClipboard.Call(0); r == 0 {
		return fmt.Errorf("无法打开剪贴板")
	}
	defer procCloseClipboard.Call()
	procEmptyClipboard.Call()

	h, err := globalAlloc(gmemMoveable, len(data)*2)
	if err != nil {
		return err
	}
	p, err := globalLockPtr(h)
	if err != nil {
		procGlobalFree.Call(h)
		return err
	}
	copy(unsafe.Slice((*uint16)(p), len(data)), data)
	procGlobalUnlock.Call(h)
	if r, _, _ := procSetClipboardData.Call(cF_UNICODETEXT, h); r == 0 {
		procGlobalFree.Call(h)
		return fmt.Errorf("写入剪贴板失败")
	}
	return nil
}

// ---------------- 剪贴板操作（供 Wails 绑定） ----------------