appID := (A_Is64bitOS ? "{6D809377-6AF0-444b-8957-A3773F02200E}"
                      : "{905E63B6-C1BF-494E-B29C-65B732D3D21A}") . "\AutoHotkey\AutoHotkey.exe"

; https://learn.microsoft.com/en-us/uwp/api/windows.ui.notifications.toasttemplatetype
template := toastImageAndText02 := 1

boldText := "Hello, God!"
regularText := "This is a toast in AHK"

imageFile := A_ScriptDir . "\god.png"
if !FileExist(imageFile)
   UrlDownloadToFile, https://i.imgur.com/GM0mf5w.png, % imageFile

F11::
   Toast := new ToastNotification(appID, template, [boldText, regularText], imageFile, Func("OnActivated"))
   /*
   Sleep, 1000
   MsgBox, 4, % " ", Hide notification?
   IfMsgbox, Yes
      Toast.Hide()
   */
Return

OnActivated() {
   MsgBox, activated!
}

class ToastNotification
{
; windows.data.xml.dom.h
; windows.ui.notifications.h
   __New(appID, template, textArr, imageFile := "", userFunc := "") {
      if (A_OSVersion ~= "^\D") {
         MsgBox, 48, Class ToastNotification, This class requires Windows 10 or later!
         Return ""
      }
      ToastNotificationManager := this._CreateToastNotificationManager()
      XmlDocument := ToastNotificationManager.GetTemplateContent(template)
      this._SetText(textArr, XmlDocument)
      (imageFile && this._SetImage(imageFile, XmlDocument))
      WrtStr := new WrtString(appID)
      this.ToastNotifier := ToastNotificationManager.CreateToastNotifierWithId(WrtStr.HSTRING)
      this.ToastNotification := this._CreateToastNotification(XmlDocument)
      if (userFunc && !ToastNotification.ActivationCallbackCreated) {
         CreateNotificationActivationCallback(appID, userFunc)
         ToastNotification.ActivationCallbackCreated := true
      }
      this.ToastNotifier.Show(this.ToastNotification.ptr)
   }
   
   Hide() {
      this.ToastNotifier.Hide(this.ToastNotification.ptr)
   }
   
   _CreateToastNotificationManager() {
      static IID_IToastNotificationManagerStatics := "{50AC103F-D235-4598-BBEF-98FE4D1A3AD4}"
      WrtStr := new WrtString("Windows.UI.Notifications.ToastNotificationManager")
      WrtStr.GetFactory(CLSIDFromString(IID_IToastNotificationManagerStatics, _), pIToastNotificationManagerStatics)
      Return new IToastNotificationManagerStatics(pIToastNotificationManagerStatics)
   }
   
   _SetText(textArr, XmlDocument) {
      static IID_IXmlNodeSerializer := "{5CC5B382-E6DD-4991-ABEF-06D8D2E7BD0C}"
      XmlNodeList := XmlDocument.GetElementsByTagName((new WrtString("text")).HSTRING)
      Loop % XmlNodeList.get_Length() {
         XmlNode := XmlNodeList.Item(A_Index - 1)
         pXmlNodeSerializer := ComObjQuery(XmlNode.ptr, IID_IXmlNodeSerializer)
         XmlNodeSerializer := new IXmlNodeSerializer(pXmlNodeSerializer)
         XmlNodeSerializer.put_InnerText((new WrtString(textArr[A_Index])).HSTRING)
      }
   }
   
   _SetImage(image, XmlDocument) {
      static IID_IXmlElement := "{2DFB8A1F-6B10-4EF8-9F83-EFCCE8FAEC37}"
      XmlNodeList := XmlDocument.GetElementsByTagName((new WrtString("image")).HSTRING)
      XmlNode := XmlNodeList.Item(0)
      pIXmlElement := ComObjQuery(XmlNode.ptr, IID_IXmlElement)
      XmlElement := new IXmlElement(pIXmlElement)
      WrtStr := new WrtString(image)
      XmlElement.SetAttribute((new WrtString("src")).HSTRING, WrtStr.HSTRING)
   }
   
   _CreateToastNotification(XmlDocument) {
      static IID_IToastNotificationFactory := "{04124B20-82C6-4229-B109-FD9ED4662B53}"
      WrtStr := new WrtString("Windows.UI.Notifications.ToastNotification")
      WrtStr.GetFactory(CLSIDFromString(IID_IToastNotificationFactory, _), pIToastNotificationFactory)
      ToastNotificationFactory := new IToastNotificationFactory(pIToastNotificationFactory)
      Return ToastNotificationFactory.CreateToastNotification(XmlDocument.ptr)
   }
}

class IToastNotificationManagerStatics extends InterfaceBase {
   CreateToastNotifierWithId(hString_appID) {
      hr := DllCall(this.VTable(7), "Ptr", this.ptr, "Ptr", hString_appID, "PtrP", pIToastNotifier)
      this.IsError(A_ThisFunc, hr)
      Return new IToastNotifier(pIToastNotifier)
   }
   GetTemplateContent(ToastTemplateType) {
      hr := DllCall(this.VTable(8), "Ptr", this.ptr, "Int", ToastTemplateType, "PtrP", pIXmlDocument)
      this.IsError(A_ThisFunc, hr)
      Return new IXmlDocument(pIXmlDocument)
   }
}

class IXmlDocument extends InterfaceBase {
   GetElementsByTagName(hString_tagName) {
      hr := DllCall(this.VTable(16), "Ptr", this.ptr, "Ptr", hString_tagName, "PtrP", pIXmlNodeList)
      this.IsError(A_ThisFunc, hr)
      Return new IXmlNodeList(pIXmlNodeList)
   }
}

class IXmlNodeList extends InterfaceBase {
   get_Length() {
      hr := DllCall(this.VTable(6), "Ptr", this.ptr, "UIntP", length)
      this.IsError(A_ThisFunc, hr)
      Return length
   }
   Item(index) {
      hr := DllCall(this.VTable(7), "Ptr", this.ptr, "UInt", index, "PtrP", pIXmlNode)
      this.IsError(A_ThisFunc, hr)
      Return new IXmlNode(pIXmlNode)
   }
}

class IXmlNode extends InterfaceBase {
}

class IXmlNodeSerializer extends InterfaceBase {
   put_InnerText(hString_innerText) {
      hr := DllCall(this.VTable(8), "Ptr", this.ptr, "Ptr", hString_innerText)
      this.IsError(A_ThisFunc, hr)
   }
}

class IXmlElement extends InterfaceBase {
   SetAttribute(hString_attributeName, hString_attributeValue) {
      hr := DllCall(this.VTable(8), "Ptr", this.ptr, "Ptr", hString_attributeName, "Ptr", hString_attributeValue)
      this.IsError(A_ThisFunc, hr)
   }
}

class IToastNotifier extends InterfaceBase {
   Show(pIToastNotification) {
      hr := DllCall(this.VTable(6), "Ptr", this.ptr, "Ptr", pIToastNotification)
      this.IsError(A_ThisFunc, hr)
   }
   Hide(pIToastNotification) {
      hr := DllCall(this.VTable(7), "Ptr", this.ptr, "Ptr", pIToastNotification)
      this.IsError(A_ThisFunc, hr)
   }
}

class IToastNotificationFactory extends InterfaceBase {
   CreateToastNotification(pIXmlDocument) {
      hr := DllCall(this.VTable(6), "Ptr", this.ptr, "Ptr", pIXmlDocument, "PtrP", pIToastNotification)
      this.IsError(A_ThisFunc, hr)
      Return new IToastNotification(pIToastNotification)
   }
}

class IToastNotification extends InterfaceBase {
}

class InterfaceBase {
   __New(ptr) {
      this.ptr := ptr
   }
   __Delete() {
      ObjRelease(this.ptr)
   }
   VTable(idx) {
      Return NumGet(NumGet(this.ptr + 0) + A_PtrSize*idx)
   }
   IsError(method, result, exc := true) {
      if (result = 0)
         Return 0
      error := StrReplace(method, ".", "::") . " failed.`nResult: "
                              . ( result = "" ? "No result" : SysError(Format("{:#x}", result & 0xFFFFFFFF)) )
                              . "`nErrorLevel: " . ErrorLevel
      if !exc
         Return error
      throw error
   }
}

class WrtString {
   __New(string, isHandle := false) {
      if isHandle
         this.HSTRING := string
      else {
         DllCall("Combase\WindowsCreateString", "WStr", string, "UInt", StrLen(string), "PtrP", HSTRING)
         this.HSTRING := HSTRING
      }
   }
   __Delete() {
      DllCall("Combase\WindowsDeleteString", "Ptr", this.HSTRING)
   }
   GetText() {
      pBuff := DllCall("Combase\WindowsGetStringRawBuffer", "Ptr", this.HSTRING, "UIntP", len, "Ptr")
      Return StrGet(pBuff, len, "UTF-16")
   }
   GetFactory(riid, ByRef pInterface) {
      hr := DllCall("Combase\RoGetActivationFactory", "Ptr", this.HSTRING, "Ptr", riid, "PtrP", pInterface)
      if (hr != 0)
         throw SysError(hr)
   }
}

class INotificationActivationCallback {
   Implement(UserFunc) {
      static MethodList := [ {name: "QueryInterface", paramCount: 3}
                           , {name: "AddRef"        , paramCount: 1}
                           , {name: "Release"       , paramCount: 1}
                           , {name: "Activate"      , paramCount: 5} ]

      this.SetCapacity("vtable", MethodList.Count()*A_PtrSize)
      pVtable := this.GetAddress("vtable")
      this.SetCapacity("IUnknown", A_PtrSize)
      NumPut(pVtable, this.pIUnknown := this.GetAddress("IUnknown"))
      this.Methods.UserFunc := UserFunc
      this.Callbacks := []
      for k, method in MethodList {
         Callback := new BoundFuncCallback( ObjBindMethod(this.Methods, method.name), method.paramCount, "Fast" )
         NumPut(Callback.addr, pVtable + A_PtrSize*(k - 1))
         this.Callbacks.Push(Callback)
      }
   }
   
   __Delete() {
      this.Delete("Callbacks")
      this.SetCapacity("vtable", 0)
      this.Delete("vtable")
   }
   
   class Methods {
      QueryInterface(pINotificationActivationCallback, riid, ppvObject) {
         static IID_IUnknown                        := "{00000000-0000-0000-C000-000000000046}"
              , IID_IClassFactory                   := "{00000001-0000-0000-C000-000000000046}"
              , IID_INotificationActivationCallback := "{53E31837-6600-4A81-9395-75CFFE746F94}"
              , E_NOINTERFACE := 0x80004002, S_OK := 0, _, __, ___
              , p1 := CLSIDFromString(IID_IUnknown                       ,   _)
              , p2 := CLSIDFromString(IID_INotificationActivationCallback,  __)
              , p3 := CLSIDFromString(IID_IClassFactory                  , ___)
              
         hResult := S_OK 
         if DllCall("Ole32\IsEqualGUID", "Ptr", riid, "Ptr", p1) || DllCall("Ole32\IsEqualGUID", "Ptr", riid, "Ptr", p2)
            NumPut(pINotificationActivationCallback, ppvObject + 0)
         else if DllCall("Ole32\IsEqualGUID", "Ptr", riid, "Ptr", p3)
            NumPut(this.pIClassFactory, ppvObject + 0)
         else
         { ; if riid doesn't match IID_IUnknown nor IID_INotificationActivationCallback nor IID_IClassFactory
            NumPut(0, ppvObject + 0)
            hResult := E_NOINTERFACE
         }
         Return hResult
      }
      
      AddRef(pINotificationActivationCallback) {
         Return E_NOTIMPL := 0x80004001
      }
      
      Release(pINotificationActivationCallback) {
         Return E_NOTIMPL := 0x80004001
      }
   
      Activate(pINotificationActivationCallback, appUserModelId, invokedArgs, pData, count) {
         timer := this.UserFunc
         SetTimer, % timer, -10
      }
   }
}

class IClassFactory
{
   Implement(pUnkOuter) {
      static MethodList := [ {name: "QueryInterface", paramCount: 3}
                           , {name: "AddRef"        , paramCount: 1}
                           , {name: "Release"       , paramCount: 1}
                           , {name: "CreateInstance", paramCount: 4}
                           , {name: "LockServer"    , paramCount: 2} ]

      this.SetCapacity("vtable", MethodList.Count()*A_PtrSize)
      pVtable := this.GetAddress("vtable")
      this.SetCapacity("IUnknown", A_PtrSize)
      NumPut(pVtable, this.pIUnknown := this.GetAddress("IUnknown"))
      
      this.Methods.pUnkOuter := pUnkOuter
      this.Callbacks := []
      for k, method in MethodList {
         Callback := new BoundFuncCallback( ObjBindMethod(this.Methods, method.name), method.paramCount, "Fast" )
         NumPut(Callback.addr, pVtable + A_PtrSize*(k - 1))
         this.Callbacks.Push(Callback)
      }
   }
   
   __Delete() {
      this.Delete("Callbacks")
      this.SetCapacity("vtable", 0)
      this.Delete("vtable")
   }
   
   class Methods {
      QueryInterface(pIClassFactory, riid, ppvObject) {
         Return E_NOTIMPL := 0x80004001
      }
      
      AddRef(pIClassFactory) {
         Return E_NOTIMPL := 0x80004001
      }
      
      Release(pIClassFactory) {
         Return E_NOTIMPL := 0x80004001
      }
   
      CreateInstance(pIClassFactory, pUnkOuter, riid, ppvObject) {
         NumPut(this.pUnkOuter, ppvObject + 0)
         Return S_OK := 0
      }
      
      LockServer(pIClassFactory, fLock) {
         Return E_NOTIMPL := 0x80004001
      }
   }
}

class BoundFuncCallback
{
   __New(BoundFuncObj, paramCount, options := "") {
      this.pInfo := Object( {BoundObj: BoundFuncObj, paramCount: paramCount} )
      this.addr := RegisterCallback(this.__Class . "._Callback", options, paramCount, this.pInfo)
   }
   __Delete() {
      ObjRelease(this.pInfo)
      DllCall("GlobalFree", "Ptr", this.addr, "Ptr")
   }
   _Callback(Params*) {
      Info := Object(A_EventInfo), Args := []
      Loop % Info.paramCount
         Args.Push( NumGet(Params + A_PtrSize*(A_Index - 2)) )
      Return Info.BoundObj.Call(Args*)
   }
}

CreateNotificationActivationCallback(appID, userFunc) {
   static CLSCTX_LOCAL_SERVER := 4, REGCLS_MULTIPLEUSE := 1
        , CustomActivator := "{A5A8F02C-A117-47FF-8A91-2DBEC37A645B}"
        
   regKey := "HKCU\Software\Classes\AppUserModelId\" . appID
   RegRead, guid, % regKey, CustomActivator
   if (guid != CustomActivator)
      RegWrite, REG_SZ, % regKey, CustomActivator, % CustomActivator
   
   INotificationActivationCallback.Implement(userFunc)
   IClassFactory.Implement(INotificationActivationCallback.pIUnknown)
   INotificationActivationCallback.Methods.pIClassFactory := IClassFactory.pIUnknown
   
   DllCall("Ole32\CoRegisterClassObject", "Ptr", CLSIDFromString(CustomActivator, _)
                                        , "Ptr", INotificationActivationCallback.pIUnknown
                                        , "UInt", CLSCTX_LOCAL_SERVER, "UInt", REGCLS_MULTIPLEUSE, "UIntP", Register)
   OnExit(Func("RevokeClassObject").Bind(Register))
}

RevokeClassObject(Register) {
   DllCall("Ole32\CoRevokeClassObject", "UInt", Register)
}

CLSIDFromString(IID, ByRef CLSID) {
   VarSetCapacity(CLSID, 16, 0)
   if res := DllCall("ole32\CLSIDFromString", "WStr", IID, "Ptr", &CLSID, "UInt")
      throw Exception("CLSIDFromString failed. Error: " . Format("{:#x}", res))
   Return &CLSID
}

SysError(errorNum = "") {
   static flags := (FORMAT_MESSAGE_ALLOCATE_BUFFER := 0x100) | (FORMAT_MESSAGE_FROM_SYSTEM := 0x1000)
   (errorNum = "" && errorNum := A_LastError)
   DllCall("FormatMessage", "UInt", flags, "UInt", 0, "UInt", errorNum, "UInt", 0, "PtrP", pBuff, "UInt", 512, "Str", "")
   Return (str := StrGet(pBuff)) ? str : ErrorNum
}

 else if (A_EventInfo = 0)
      hResult := DllCall(NumGet(NumGet(this+A_PtrSize*6)+A_PtrSize), "ptr", NumGet(this+A_PtrSize*6), "ptr", punk, "ptr", riid)