zenity/util_windows.go

363 lines
8.1 KiB
Go
Raw Normal View History

package zenity
import (
2022-05-19 08:47:38 -04:00
"bytes"
2020-01-30 09:14:42 -05:00
"context"
2021-01-05 10:20:42 -05:00
"os"
2021-03-10 09:49:09 -05:00
"reflect"
2021-03-26 08:40:24 -04:00
"runtime"
2021-04-08 20:05:48 -04:00
"strconv"
"sync"
2021-03-26 08:40:24 -04:00
"sync/atomic"
"syscall"
"unsafe"
2021-09-09 20:32:20 -04:00
2022-06-17 22:45:49 -04:00
"github.com/ncruces/zenity/internal/win"
2022-06-21 07:28:21 -04:00
)
const (
_WS_ZEN_DIALOG = win.WS_POPUPWINDOW | win.WS_CLIPSIBLINGS | win.WS_DLGFRAME
_WS_EX_ZEN_DIALOG = win.WS_EX_CONTROLPARENT | win.WS_EX_WINDOWEDGE | win.WS_EX_DLGMODALFRAME
_WS_ZEN_LABEL = win.WS_CHILD | win.WS_VISIBLE | win.WS_GROUP | win.SS_WORDELLIPSIS | win.SS_EDITCONTROL | win.SS_NOPREFIX
_WS_ZEN_CONTROL = win.WS_CHILD | win.WS_VISIBLE | win.WS_GROUP | win.WS_TABSTOP
_WS_ZEN_BUTTON = _WS_ZEN_CONTROL
)
2022-06-21 09:27:19 -04:00
const nullptr win.Pointer = 0
2022-06-20 11:05:11 -04:00
func intptr(i int64) uintptr { return uintptr(i) }
func strptr(s string) *uint16 { return syscall.StringToUTF16Ptr(s) }
2022-06-21 09:27:19 -04:00
func hwnd(v reflect.Value) win.HWND {
return win.HWND(uintptr(v.Uint()))
}
2022-06-18 07:37:39 -04:00
2021-03-26 08:40:24 -04:00
func setup() context.CancelFunc {
2022-06-18 19:48:38 -04:00
var wnd win.HWND
2022-06-19 21:14:08 -04:00
win.EnumWindows(syscall.NewCallback(setupEnumCallback), unsafe.Pointer(&wnd))
if wnd == 0 {
2022-06-18 19:48:38 -04:00
wnd = win.GetConsoleWindow()
2021-01-05 10:20:42 -05:00
}
if wnd != 0 {
2022-06-19 21:14:08 -04:00
win.SetForegroundWindow(wnd)
2021-01-05 10:20:42 -05:00
}
2021-03-26 08:40:24 -04:00
runtime.LockOSThread()
2021-04-27 20:27:28 -04:00
var restore uintptr
cookie := enableVisualStyles()
2022-06-19 21:14:08 -04:00
for dpi := win.DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2; dpi <= win.DPI_AWARENESS_CONTEXT_SYSTEM_AWARE; dpi++ {
var err error
restore, err = win.SetThreadDpiAwarenessContext(dpi)
if restore != 0 || err != nil {
break
2021-03-26 08:40:24 -04:00
}
}
2022-06-17 22:45:49 -04:00
var icc win.INITCOMMONCONTROLSEX
2021-04-27 09:05:04 -04:00
icc.Size = uint32(unsafe.Sizeof(icc))
icc.ICC = 0x00004020 // ICC_STANDARD_CLASSES|ICC_PROGRESS_CLASS
2022-06-17 22:45:49 -04:00
win.InitCommonControlsEx(&icc)
2021-04-27 09:05:04 -04:00
2021-03-26 08:40:24 -04:00
return func() {
2021-04-27 20:27:28 -04:00
if restore != 0 {
2022-06-19 21:14:08 -04:00
win.SetThreadDpiAwarenessContext(restore)
2021-04-27 20:27:28 -04:00
}
if cookie != 0 {
2022-06-20 08:37:28 -04:00
win.DeactivateActCtx(0, cookie)
2021-03-26 08:40:24 -04:00
}
2021-04-09 08:39:15 -04:00
runtime.UnlockOSThread()
2021-03-26 08:40:24 -04:00
}
2021-01-05 10:20:42 -05:00
}
2022-06-18 19:48:38 -04:00
func setupEnumCallback(wnd win.HWND, lparam *win.HWND) uintptr {
var pid uint32
win.GetWindowThreadProcessId(wnd, &pid)
if int(pid) == os.Getpid() {
*lparam = wnd
return 0 // stop enumeration
}
return 1 // continue enumeration
}
2022-06-18 19:48:38 -04:00
func hookDialog(ctx context.Context, icon any, title *string, init func(wnd win.HWND)) (unhook context.CancelFunc, err error) {
2020-01-30 09:14:42 -05:00
if ctx != nil && ctx.Err() != nil {
return nil, ctx.Err()
}
2022-05-19 18:39:21 -04:00
hook, err := newDialogHook(ctx, icon, title, init)
if err != nil {
return nil, err
}
return hook.unhook, nil
}
2020-01-30 09:14:42 -05:00
type dialogHook struct {
2022-05-19 18:39:21 -04:00
ctx context.Context
2022-06-18 19:48:38 -04:00
tid uint32
2022-05-19 18:39:21 -04:00
wnd uintptr
2022-06-21 09:27:19 -04:00
hook win.Handle
2022-05-19 18:39:21 -04:00
done chan struct{}
icon any
title *string
2022-06-18 19:48:38 -04:00
init func(wnd win.HWND)
}
2020-01-30 09:14:42 -05:00
2022-06-18 19:48:38 -04:00
func newDialogHook(ctx context.Context, icon any, title *string, init func(wnd win.HWND)) (*dialogHook, error) {
2022-06-18 19:48:38 -04:00
tid := win.GetCurrentThreadId()
2022-06-21 09:27:19 -04:00
hk, err := win.SetWindowsHookEx(win.WH_CALLWNDPROCRET,
syscall.NewCallback(dialogHookProc), 0, tid)
if hk == 0 {
2020-01-30 09:14:42 -05:00
return nil, err
}
hook := dialogHook{
2022-05-19 18:39:21 -04:00
ctx: ctx,
tid: tid,
hook: hk,
icon: icon,
title: title,
init: init,
}
if ctx != nil {
hook.done = make(chan struct{})
go hook.wait()
2020-01-30 09:14:42 -05:00
}
2022-06-18 19:48:38 -04:00
saveBackRef(uintptr(tid), unsafe.Pointer(&hook))
return &hook, nil
}
2022-06-21 19:58:14 -04:00
func dialogHookProc(code int32, wparam uintptr, lparam *win.CWPRETSTRUCT) uintptr {
2022-06-21 07:28:21 -04:00
if lparam.Message == win.WM_INITDIALOG {
2022-06-18 19:48:38 -04:00
tid := win.GetCurrentThreadId()
hook := (*dialogHook)(loadBackRef(uintptr(tid)))
2022-06-18 19:48:38 -04:00
atomic.StoreUintptr(&hook.wnd, uintptr(lparam.Wnd))
2022-05-09 10:49:32 -04:00
if hook.ctx != nil && hook.ctx.Err() != nil {
2022-06-21 07:28:21 -04:00
win.SendMessage(lparam.Wnd, win.WM_SYSCOMMAND, win.SC_CLOSE, 0)
2022-05-19 18:39:21 -04:00
} else {
if hook.icon != nil {
icon := getIcon(hook.icon)
if icon.handle != 0 {
defer icon.delete()
2022-06-20 08:37:28 -04:00
win.SendMessage(lparam.Wnd, win.WM_SETICON, 0, uintptr(icon.handle))
2022-05-19 18:39:21 -04:00
}
}
if hook.title != nil {
2022-06-20 11:05:11 -04:00
win.SetWindowText(lparam.Wnd, strptr(*hook.title))
2022-05-19 18:39:21 -04:00
}
if hook.init != nil {
2022-05-23 19:12:38 -04:00
hook.init(lparam.Wnd)
2022-05-19 18:39:21 -04:00
}
2022-03-23 09:24:02 -04:00
}
}
2022-06-21 09:27:19 -04:00
return win.CallNextHookEx(0, code, wparam, unsafe.Pointer(lparam))
}
func (h *dialogHook) unhook() {
2022-06-18 19:48:38 -04:00
deleteBackRef(uintptr(h.tid))
if h.done != nil {
close(h.done)
}
2022-06-21 09:27:19 -04:00
win.UnhookWindowsHookEx(h.hook)
}
func (h *dialogHook) wait() {
select {
case <-h.ctx.Done():
if wnd := atomic.LoadUintptr(&h.wnd); wnd != 0 {
2022-06-21 07:28:21 -04:00
win.SendMessage(win.HWND(wnd), win.WM_SYSCOMMAND, win.SC_CLOSE, 0)
2020-01-30 09:14:42 -05:00
}
case <-h.done:
}
}
2022-03-23 09:24:02 -04:00
var backRefs struct {
sync.Mutex
2022-03-23 09:24:02 -04:00
m map[uintptr]unsafe.Pointer
}
2022-03-23 09:24:02 -04:00
func saveBackRef(id uintptr, ptr unsafe.Pointer) {
backRefs.Lock()
defer backRefs.Unlock()
if backRefs.m == nil {
backRefs.m = map[uintptr]unsafe.Pointer{}
2022-05-10 05:30:52 -04:00
} else if _, ok := backRefs.m[id]; ok {
panic("saveBackRef")
}
2022-03-23 09:24:02 -04:00
backRefs.m[id] = ptr
}
2022-03-23 09:24:02 -04:00
func loadBackRef(id uintptr) unsafe.Pointer {
backRefs.Lock()
defer backRefs.Unlock()
return backRefs.m[id]
2020-01-30 09:14:42 -05:00
}
2022-03-23 09:24:02 -04:00
func deleteBackRef(id uintptr) {
backRefs.Lock()
defer backRefs.Unlock()
delete(backRefs.m, id)
2020-01-24 08:59:03 -05:00
}
2022-06-20 08:37:28 -04:00
type dpi int
2021-04-08 19:55:49 -04:00
2022-06-20 11:05:11 -04:00
func getDPI(wnd win.HWND) dpi {
2022-06-20 08:37:28 -04:00
res, _ := win.GetDpiForWindow(wnd)
if res != 0 {
return dpi(res)
}
if dc := win.GetWindowDC(wnd); dc != 0 {
res = win.GetDeviceCaps(dc, win.LOGPIXELSY)
win.ReleaseDC(wnd, dc)
2021-04-08 19:55:49 -04:00
}
if res == 0 {
2022-06-20 08:37:28 -04:00
return win.USER_DEFAULT_SCREEN_DPI
2021-04-08 19:55:49 -04:00
}
return dpi(res)
2021-04-05 12:54:46 -04:00
}
2022-06-20 11:05:11 -04:00
func (d dpi) scale(dim int) int {
2021-04-08 19:55:49 -04:00
if d == 0 {
return dim
}
2022-06-20 11:05:11 -04:00
return dim * int(d) / win.USER_DEFAULT_SCREEN_DPI
2021-04-08 19:55:49 -04:00
}
type font struct {
2022-06-18 07:37:39 -04:00
handle win.Handle
logical win.LOGFONT
2021-04-08 19:55:49 -04:00
}
func getFont() font {
2022-06-21 07:28:21 -04:00
var metrics win.NONCLIENTMETRICS
2021-04-08 19:55:49 -04:00
metrics.Size = uint32(unsafe.Sizeof(metrics))
2022-06-21 07:28:21 -04:00
win.SystemParametersInfo(win.SPI_GETNONCLIENTMETRICS,
unsafe.Sizeof(metrics), unsafe.Pointer(&metrics), 0)
2021-04-08 19:55:49 -04:00
return font{logical: metrics.MessageFont}
}
2022-03-23 09:52:52 -04:00
func (f *font) forDPI(dpi dpi) uintptr {
if h := -int32(dpi.scale(12)); f.handle == 0 || f.logical.Height != h {
f.delete()
2021-04-08 19:55:49 -04:00
f.logical.Height = h
2022-06-18 07:37:39 -04:00
f.handle = win.CreateFontIndirect(&f.logical)
2021-04-08 19:55:49 -04:00
}
2022-06-18 07:37:39 -04:00
return uintptr(f.handle)
2021-04-08 19:55:49 -04:00
}
2022-03-23 09:52:52 -04:00
func (f *font) delete() {
2021-04-08 19:55:49 -04:00
if f.handle != 0 {
2022-06-18 07:37:39 -04:00
win.DeleteObject(f.handle)
2021-04-08 19:55:49 -04:00
f.handle = 0
}
}
2022-05-19 08:47:38 -04:00
type icon struct {
2022-06-20 08:37:28 -04:00
handle win.Handle
2022-05-19 08:47:38 -04:00
destroy bool
}
func getIcon(i any) icon {
var res icon
var resource uintptr
switch i {
case ErrorIcon:
resource = 32513 // IDI_ERROR
case QuestionIcon:
resource = 32514 // IDI_QUESTION
case WarningIcon:
resource = 32515 // IDI_WARNING
case InfoIcon:
resource = 32516 // IDI_INFORMATION
}
if resource != 0 {
2022-06-20 08:37:28 -04:00
res.handle, _ = win.LoadIcon(0, resource)
2022-05-19 08:47:38 -04:00
return res
}
path, ok := i.(string)
if !ok {
return res
}
data, err := os.ReadFile(path)
if err != nil {
return res
}
switch {
case bytes.HasPrefix(data, []byte("\x00\x00\x01\x00")):
2022-06-20 08:37:28 -04:00
res.handle, _ = win.LoadImage(0,
2022-06-20 11:05:11 -04:00
strptr(path),
2022-06-20 08:37:28 -04:00
win.IMAGE_ICON, 0, 0,
win.LR_LOADFROMFILE|win.LR_DEFAULTSIZE|win.LR_SHARED)
2022-05-19 08:47:38 -04:00
case bytes.HasPrefix(data, []byte("\x89PNG\r\n\x1a\n")):
2022-06-20 11:05:11 -04:00
res.handle, err = win.CreateIconFromResource(
data, true, 0x00030000)
2022-05-19 08:47:38 -04:00
res.destroy = true
}
return res
}
func (i *icon) delete() {
if i.handle != 0 {
2022-06-20 08:37:28 -04:00
win.DestroyIcon(i.handle)
2022-05-19 08:47:38 -04:00
i.handle = 0
}
}
2022-06-20 11:05:11 -04:00
func centerWindow(wnd win.HWND) {
var rect win.RECT
win.GetWindowRect(wnd, &rect)
2022-06-21 07:28:21 -04:00
x := win.GetSystemMetrics(win.SM_CXSCREEN) - int(rect.Right-rect.Left)
y := win.GetSystemMetrics(win.SM_CYSCREEN) - int(rect.Bottom-rect.Top)
win.SetWindowPos(wnd, 0, x/2, y/2, 0, 0, win.SWP_NOZORDER|win.SWP_NOSIZE)
2021-04-08 20:05:48 -04:00
}
2022-06-20 11:05:11 -04:00
func getWindowString(wnd win.HWND) string {
len, _ := win.GetWindowTextLength(wnd)
2021-04-08 20:05:48 -04:00
buf := make([]uint16, len+1)
2022-06-20 11:05:11 -04:00
win.GetWindowText(wnd, &buf[0], len+1)
2021-04-08 20:05:48 -04:00
return syscall.UTF16ToString(buf)
}
2022-06-20 11:05:11 -04:00
func registerClass(instance, icon win.Handle, proc uintptr) (*uint16, error) {
2021-04-08 20:05:48 -04:00
name := "WC_" + strconv.FormatUint(uint64(proc), 16)
2022-06-20 08:37:28 -04:00
var wcx win.WNDCLASSEX
2021-04-08 20:05:48 -04:00
wcx.Size = uint32(unsafe.Sizeof(wcx))
wcx.WndProc = proc
2022-05-23 19:12:38 -04:00
wcx.Icon = icon
2021-04-08 20:05:48 -04:00
wcx.Instance = instance
wcx.Background = 5 // COLOR_WINDOW
2022-06-20 11:05:11 -04:00
wcx.ClassName = strptr(name)
2021-04-08 20:05:48 -04:00
2022-06-20 11:05:11 -04:00
if err := win.RegisterClassEx(&wcx); err != nil {
return nil, err
}
return wcx.ClassName, nil
2021-04-08 20:05:48 -04:00
}
2021-04-27 20:27:28 -04:00
// https://stackoverflow.com/questions/4308503/how-to-enable-visual-styles-without-a-manifest
func enableVisualStyles() (cookie uintptr) {
2022-06-18 19:48:38 -04:00
dir, err := win.GetSystemDirectory()
if err != nil {
2021-04-27 20:27:28 -04:00
return
}
2022-06-20 08:37:28 -04:00
var ctx win.ACTCTX
2021-04-27 20:27:28 -04:00
ctx.Size = uint32(unsafe.Sizeof(ctx))
2022-06-20 08:37:28 -04:00
ctx.Flags = win.ACTCTX_FLAG_RESOURCE_NAME_VALID | win.ACTCTX_FLAG_SET_PROCESS_DEFAULT | win.ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID
2022-06-20 11:05:11 -04:00
ctx.Source = strptr("shell32.dll")
ctx.AssemblyDirectory = strptr(dir)
2021-04-27 20:27:28 -04:00
ctx.ResourceName = 124
2022-06-20 08:37:28 -04:00
if hnd, err := win.CreateActCtx(&ctx); err == nil {
win.ActivateActCtx(hnd, &cookie)
win.ReleaseActCtx(hnd)
2021-04-27 20:27:28 -04:00
}
return
}