add Win32Window, DialogEx, Monitor, and fix control ID allocation

I refactored some common (but very basic) HWND operations into Win32Window.
One reason I did this was to allow the default WndProc to be overridden.

I added two new types of PreTranslateHandler managed by the Application.
Global PreTranslateHandlers are always run first, regardless of the HWND.
If no global handlers processed the message, we then run HWND-specific
PreTranslateHandlers, which are associated with a specific HWND and may
be added and removed as necessary. If the message is still unprocessed,
we then fall through to the existing implementation. Global handlers
are not used yet (they are needed for WinUI), but since I was already
adding HWND-specific handlers, I put them in anyway.

I added Monitor, an abstraction for various HMONITOR operations.

I decided that some of the walk stuff around dialog management was too
fargone to fix without breaking a lot of existing code. Instead I wrote a
new component called DialogEx. It essentially creates a dialog using the
Win32 dialog manager (via CreateDialogIndirectParam) but is still able to
act as a Form and work with walk's layout code. We use a custom window
class for this stuff essentially to indicate to the system that the dialog
is nonstandard. The point of DialogEx is to leverage the existing dialog
management functionality instead of pushing back on it or trying to
reimplement it. Note that because DialogEx implements a dialog procedure,
we need to override FormBase's default WndProc with a no-op (courtesy of
the Win32Window refactoring).

I changed how keyboard focus is set in Form so that DialogEx can override.

I updated PushButton and ContainerBase such that, when running within a
DialogEx, they skip some of their walk-specific message processing.
This skips a bunch of code that is essentially trying to do a bad job of
reimplementing dialog management.

I updated PushButton to allow reserved control IDs to be explicitly set. We
also update PushButton to allow itself to be declaratively set as the default
pushbutton within a DialogEx.

I removed control ID allocation from ContainerBase. Instead, Widgets request
an IDAllocator from their owning FormBase, ensuring uniqueness across all
Widgets in the Form's widget hierarchy, not just the ones residing within
a specific container.

I also updated go.mod to pick up the latest win.

Fixes #96

Signed-off-by: Aaron Klotz <aaron@tailscale.com>

Author: dblohm7

action.go

@@ -61,11 +61,11 @@ type Action struct {
 
 // aaron: I don't know why Walk uses menu item IDs for IDOK and IDCANCEL, but
 // for now we need to reserve IDs up to and including IDCANCEL (2).
-const maxReservedID = win.IDCANCEL
+const maxReservedActionID = win.IDCANCEL
 
 func makeIDAllocator() idalloc.IDAllocator {
 	alloc := idalloc.New(1 << 16)
-	for i := 0; i <= maxReservedID; i++ {
+	for i := 0; i <= maxReservedActionID; i++ {
 		alloc.Allocate()
 	}
 	return alloc
@@ -80,7 +80,7 @@ func allocActionID() uint16 {
 }
 
 func freeActionID(id uint16) {
-	if id <= maxReservedID {
+	if id <= maxReservedActionID {
 		return
 	}
 	actionIDs.Free(uint32(id))
@@ -137,7 +137,7 @@ func (a *Action) finalize() {
 
 func (a *Action) addRef() {
 	a.refCount++
-	if a.refCount == 1 && a.id > maxReservedID {
+	if a.refCount == 1 && a.id > maxReservedActionID {
 		actionsById[a.id] = a
 		if sc := a.shortcut; sc.Key != 0 {
 			shortcut2Action[sc] = a
@@ -147,7 +147,7 @@ func (a *Action) addRef() {
 
 func (a *Action) release() {
 	a.refCount--
-	if a.refCount == 0 && a.id > maxReservedID {
+	if a.refCount == 0 && a.id > maxReservedActionID {
 		delete(actionsById, a.id)
 		if sc := a.shortcut; sc.Key != 0 && shortcut2Action[sc] == a {
 			delete(shortcut2Action, sc)

application.go

@@ -12,6 +12,7 @@ import (
 	"errors"
 	"fmt"
 	"log"
+	"os"
 	"runtime"
 	"sync"
 	"sync/atomic"
@@ -104,29 +105,31 @@ func (o *onceWithPreInit) doPreInit(f func()) bool {
 // of the application. There is only one singleton instance. Use InitApp to
 // initialize it, and then use App for the duration of the process to access it.
 type Application struct {
-	uiThreadID          uint32
-	ctx                 context.Context
-	ctxCancel           context.CancelFunc
-	walkInit            []func()
-	organizationName    atomic.Pointer[string]
-	productName         atomic.Pointer[string]
-	settings            atomic.Value // of Settings
-	exiting             atomic.Bool
-	panickingPublisher  ErrorEventPublisher
-	nextMsg             uint32
-	syncFuncMsg         uint32
-	syncLayoutMsg       uint32
-	cloakChangeMsg      uint32
-	winEventProc        uintptr
-	winEventHook        win.HWINEVENTHOOK
-	msgWindow           win.HWND
-	syncFuncsMutex      sync.Mutex
-	syncFuncs           []func()
-	syncLayoutMutex     sync.Mutex
-	layoutResultsByForm map[Form]*formLayoutResult // Layout computations queued for application
-	pToolTip            *ToolTip
-	activeMessageLoops  int
-	runMsgFilters       bool
+	uiThreadID                    uint32
+	ctx                           context.Context
+	ctxCancel                     context.CancelFunc
+	walkInit                      []func()
+	organizationName              atomic.Pointer[string]
+	productName                   atomic.Pointer[string]
+	settings                      atomic.Value // of Settings
+	exiting                       atomic.Bool
+	panickingPublisher            ErrorEventPublisher
+	nextMsg                       uint32
+	syncFuncMsg                   uint32
+	syncLayoutMsg                 uint32
+	cloakChangeMsg                uint32
+	winEventProc                  uintptr
+	winEventHook                  win.HWINEVENTHOOK
+	msgWindow                     win.HWND
+	syncFuncsMutex                sync.Mutex
+	syncFuncs                     []func()
+	syncLayoutMutex               sync.Mutex
+	layoutResultsByForm           map[Form]*formLayoutResult // Layout computations queued for application
+	pToolTip                      *ToolTip
+	globalPreTranslateHandlers    []PreTranslateHandler
+	perWindowPreTranslateHandlers map[win.HWND]PreTranslateHandler
+	activeMessageLoops            int
+	runMsgFilters                 bool
 }
 
 // Bare minimum initialization that must happen ASAP. While we typically do
@@ -254,8 +257,8 @@ func (app *Application) Panicking() *ErrorEvent {
 }
 
 // maybePublishPanic is used by walk's top-level WndProcs to recover any
-// panics that occurred further down the call stack, convert them to errors,
-// and publish them as an event.
+// panic that occurred further down the call stack, convert it to an error,
+// and publish it as an event.
 func (app *Application) maybePublishPanic() {
 	if len(app.panickingPublisher.event.handlers) == 0 {
 		return
@@ -353,6 +356,7 @@ func (app *Application) init() (finalInitOutsideOnce func() error, err error) {
 	}
 
 	app.layoutResultsByForm = make(map[Form]*formLayoutResult)
+	app.perWindowPreTranslateHandlers = make(map[win.HWND]PreTranslateHandler)
 	defaultWndProcPtr = windows.NewCallback(defaultWndProc)
 
 	walkInits := app.walkInit
@@ -429,6 +433,21 @@ func (app *Application) runMainMessageLoop() int {
 }
 
 func (app *Application) runPreTranslateHandler(msg *win.MSG) bool {
+	// Order is important here: run the global handlers first...
+	for _, handler := range app.globalPreTranslateHandlers {
+		if handler.OnPreTranslate(msg) {
+			return true
+		}
+	}
+
+	// ...Then the per-window handlers...
+	for _, handler := range app.perWindowPreTranslateHandlers {
+		if handler.OnPreTranslate(msg) {
+			return true
+		}
+	}
+
+	// ...Then, if present, the handler associated with msg's HWND.
 	w := getMsgWindow(msg)
 	if w == nil {
 		return false
@@ -791,3 +810,33 @@ func (app *Application) EnableMessageFilterHooks(enable bool) {
 func (app *Application) Context() context.Context {
 	return app.ctx
 }
+
+// AddGlobalPreTranslateHandler registers handler to be unconditionally run at
+// each iteration of the main event loop. Once added, handler remains registered
+// for the remaining life of the process. This method must be called from the
+// main goroutine.
+func (app *Application) AddGlobalPreTranslateHandler(handler PreTranslateHandler) {
+	app.AssertUIThread()
+	if handler != nil {
+		app.globalPreTranslateHandlers = append(app.globalPreTranslateHandlers, handler)
+	}
+}
+
+// AddPreTranslateHandlerForHWND registers handler keyed by hwnd, to be run
+// at each iteration of the main event loop. This method must be called from
+// the main goroutine.
+func (app *Application) AddPreTranslateHandlerForHWND(hwnd win.HWND, handler PreTranslateHandler) {
+	app.AssertUIThread()
+	if hwnd == 0 || handler == nil {
+		panic(os.ErrInvalid)
+	}
+	app.perWindowPreTranslateHandlers[hwnd] = handler
+}
+
+// DeletePreTranslateHandlerForHWND removes any handler keyed by hwnd that
+// was previously registered by [Application.AddPreTranslateHandlerForHWND]. This method must
+// be called from the main goroutine.
+func (app *Application) DeletePreTranslateHandlerForHWND(hwnd win.HWND) {
+	app.AssertUIThread()
+	delete(app.perWindowPreTranslateHandlers, hwnd)
+}

container.go

@@ -27,11 +27,10 @@ type Container interface {
 
 type ContainerBase struct {
 	WidgetBase
-	layout      Layout
-	children    *WidgetList
-	dataBinder  *DataBinder
-	nextChildID int32
-	persistent  bool
+	layout     Layout
+	children   *WidgetList
+	dataBinder *DataBinder
+	persistent bool
 }
 
 func (cb *ContainerBase) AsWidgetBase() *WidgetBase {
@@ -42,11 +41,6 @@ func (cb *ContainerBase) AsContainerBase() *ContainerBase {
 	return cb
 }
 
-func (cb *ContainerBase) NextChildID() int32 {
-	cb.nextChildID++
-	return cb.nextChildID
-}
-
 func (cb *ContainerBase) applyEnabled(enabled bool) {
 	cb.WidgetBase.applyEnabled(enabled)
 
@@ -301,6 +295,11 @@ func (cb *ContainerBase) WndProc(hwnd win.HWND, msg uint32, wParam, lParam uintp
 		return 0
 
 	case win.WM_COMMAND:
+		if dlgExResolver, ok := ancestor(cb).(DialogExResolver); ok {
+			// Let the DialogEx handle this.
+			dlgExResolver.AsDialogEx().SendMessage(win.WM_COMMAND, wParam, lParam)
+			return 0
+		}
 		if lParam == 0 {
 			switch win.HIWORD(uint32(wParam)) {
 			case 0:

declarative/dialogex.go

@@ -0,0 +1,56 @@
+// Copyright (c) Tailscale Inc & AUTHORS
+// SPDX-License-Identifier: BSD-3-Clause
+
+//go:build windows
+// +build windows
+
+package declarative
+
+import (
+	"github.com/tailscale/walk"
+)
+
+type DialogEx struct {
+	Background Brush
+	Layout     Layout
+	Children   []Widget
+	Icon       Property
+	Title      string
+	Size       Size
+
+	AssignTo **walk.DialogEx
+}
+
+func (d DialogEx) Create(owner walk.Form) error {
+	dlg, err := walk.NewDialogEx(owner, d.Title, d.Size.toW())
+	if err != nil {
+		return err
+	}
+
+	if d.AssignTo != nil {
+		*d.AssignTo = dlg
+	}
+
+	fi := formInfo{
+		// Window
+		Background: d.Background,
+		Enabled:    true,
+
+		// Container
+		Children: d.Children,
+		Layout:   d.Layout,
+
+		// Form
+		Icon:  d.Icon,
+		Title: d.Title,
+	}
+
+	builder := NewBuilder(nil)
+	dlg.SetSuspended(true)
+	builder.Defer(func() error {
+		dlg.SetSuspended(false)
+		return nil
+	})
+
+	return builder.InitWidget(fi, dlg, nil)
+}

declarative/pushbutton.go

@@ -58,16 +58,22 @@ type PushButton struct {
 	// PushButton
 
 	AssignTo       **walk.PushButton
+	PredefinedID   int
 	ImageAboveText bool
+	Default        bool
 }
 
 func (pb PushButton) Create(builder *Builder) (err error) {
-	var w *walk.PushButton
-	if pb.UseLayoutFlags {
-		w, err = walk.NewPushButtonWithLayoutFlags(builder.Parent(), pb.LayoutFlags)
-	} else {
-		w, err = walk.NewPushButton(builder.Parent())
+	opts := walk.PushButtonOptions{
+		LayoutFlags:  pb.LayoutFlags,
+		Default:      pb.Default,
+		PredefinedID: pb.PredefinedID,
 	}
+	if !pb.UseLayoutFlags {
+		opts.LayoutFlags = walk.GrowableHorz
+	}
+
+	w, err := walk.NewPushButtonWithOptions(builder.Parent(), opts)
 	if err != nil {
 		return err
 	}