first commit

windows/foundation/typedeventhandler.go

@@ -0,0 +1,208 @@
+// Code generated by winrt-go-gen. DO NOT EDIT.
+
+//go:build windows
+
+//nolint:all
+package foundation
+
+import (
+	"sync"
+	"time"
+	"unsafe"
+
+	"github.com/go-ole/go-ole"
+	"github.com/saltosystems/winrt-go/internal/delegate"
+	"github.com/saltosystems/winrt-go/internal/kernel32"
+)
+
+const GUIDTypedEventHandler string = "9de1c534-6ae1-11e0-84e1-18a905bcc53f"
+const SignatureTypedEventHandler string = "delegate({9de1c534-6ae1-11e0-84e1-18a905bcc53f})"
+
+type TypedEventHandler struct {
+	ole.IUnknown
+	sync.Mutex
+	refs uintptr
+	IID  ole.GUID
+}
+
+type TypedEventHandlerVtbl struct {
+	ole.IUnknownVtbl
+	Invoke uintptr
+}
+
+type TypedEventHandlerCallback func(instance *TypedEventHandler, sender unsafe.Pointer, args unsafe.Pointer)
+
+var callbacksTypedEventHandler = &typedEventHandlerCallbacks{
+	mu:        &sync.Mutex{},
+	callbacks: make(map[unsafe.Pointer]TypedEventHandlerCallback),
+}
+
+var releaseChannelsTypedEventHandler = &typedEventHandlerReleaseChannels{
+	mu:    &sync.Mutex{},
+	chans: make(map[unsafe.Pointer]chan struct{}),
+}
+
+func NewTypedEventHandler(iid *ole.GUID, callback TypedEventHandlerCallback) *TypedEventHandler {
+	// create type instance
+	size := unsafe.Sizeof(*(*TypedEventHandler)(nil))
+	instPtr := kernel32.Malloc(size)
+	inst := (*TypedEventHandler)(instPtr)
+
+	// get the callbacks for the VTable
+	callbacks := delegate.RegisterCallbacks(instPtr, inst)
+
+	// the VTable should also be allocated in the heap
+	sizeVTable := unsafe.Sizeof(*(*TypedEventHandlerVtbl)(nil))
+	vTablePtr := kernel32.Malloc(sizeVTable)
+
+	inst.RawVTable = (*interface{})(vTablePtr)
+
+	vTable := (*TypedEventHandlerVtbl)(vTablePtr)
+	vTable.IUnknownVtbl = ole.IUnknownVtbl{
+		QueryInterface: callbacks.QueryInterface,
+		AddRef:         callbacks.AddRef,
+		Release:        callbacks.Release,
+	}
+	vTable.Invoke = callbacks.Invoke
+
+	// Initialize all properties: the malloc may contain garbage
+	inst.IID = *iid // copy contents
+	inst.Mutex = sync.Mutex{}
+	inst.refs = 0
+
+	callbacksTypedEventHandler.add(unsafe.Pointer(inst), callback)
+
+	// See the docs in the releaseChannelsTypedEventHandler struct
+	releaseChannelsTypedEventHandler.acquire(unsafe.Pointer(inst))
+
+	inst.addRef()
+	return inst
+}
+
+func (r *TypedEventHandler) GetIID() *ole.GUID {
+	return &r.IID
+}
+
+// addRef increments the reference counter by one
+func (r *TypedEventHandler) addRef() uintptr {
+	r.Lock()
+	defer r.Unlock()
+	r.refs++
+	return r.refs
+}
+
+// removeRef decrements the reference counter by one. If it was already zero, it will just return zero.
+func (r *TypedEventHandler) removeRef() uintptr {
+	r.Lock()
+	defer r.Unlock()
+
+	if r.refs > 0 {
+		r.refs--
+	}
+
+	return r.refs
+}
+
+func (instance *TypedEventHandler) Invoke(instancePtr, rawArgs0, rawArgs1, rawArgs2, rawArgs3, rawArgs4, rawArgs5, rawArgs6, rawArgs7, rawArgs8 unsafe.Pointer) uintptr {
+	senderPtr := rawArgs0
+	argsPtr := rawArgs1
+
+	// See the quote above.
+	sender := (unsafe.Pointer)(senderPtr)
+	args := (unsafe.Pointer)(argsPtr)
+	if callback, ok := callbacksTypedEventHandler.get(instancePtr); ok {
+		callback(instance, sender, args)
+	}
+	return ole.S_OK
+}
+
+func (instance *TypedEventHandler) AddRef() uintptr {
+	return instance.addRef()
+}
+
+func (instance *TypedEventHandler) Release() uintptr {
+	rem := instance.removeRef()
+	if rem == 0 {
+		// We're done.
+		instancePtr := unsafe.Pointer(instance)
+		callbacksTypedEventHandler.delete(instancePtr)
+
+		// stop release channels used to avoid
+		// https://github.com/golang/go/issues/55015
+		releaseChannelsTypedEventHandler.release(instancePtr)
+
+		kernel32.Free(unsafe.Pointer(instance.RawVTable))
+		kernel32.Free(instancePtr)
+	}
+	return rem
+}
+
+type typedEventHandlerCallbacks struct {
+	mu        *sync.Mutex
+	callbacks map[unsafe.Pointer]TypedEventHandlerCallback
+}
+
+func (m *typedEventHandlerCallbacks) add(p unsafe.Pointer, v TypedEventHandlerCallback) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	m.callbacks[p] = v
+}
+
+func (m *typedEventHandlerCallbacks) get(p unsafe.Pointer) (TypedEventHandlerCallback, bool) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	v, ok := m.callbacks[p]
+	return v, ok
+}
+
+func (m *typedEventHandlerCallbacks) delete(p unsafe.Pointer) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	delete(m.callbacks, p)
+}
+
+// typedEventHandlerReleaseChannels keeps a map with channels
+// used to keep a goroutine alive during the lifecycle of this object.
+// This is required to avoid causing a deadlock error.
+// See this: https://github.com/golang/go/issues/55015
+type typedEventHandlerReleaseChannels struct {
+	mu    *sync.Mutex
+	chans map[unsafe.Pointer]chan struct{}
+}
+
+func (m *typedEventHandlerReleaseChannels) acquire(p unsafe.Pointer) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	c := make(chan struct{})
+	m.chans[p] = c
+
+	go func() {
+		// we need a timer to trick the go runtime into
+		// thinking there's still something going on here
+		// but we are only really interested in <-c
+		t := time.NewTimer(time.Minute)
+		for {
+			select {
+			case <-t.C:
+				t.Reset(time.Minute)
+			case <-c:
+				t.Stop()
+				return
+			}
+		}
+	}()
+}
+
+func (m *typedEventHandlerReleaseChannels) release(p unsafe.Pointer) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if c, ok := m.chans[p]; ok {
+		close(c)
+		delete(m.chans, p)
+	}
+}