/**
* MIT License
*
* Copyright (C) 2016-2025 W
inToast v1.3.2 - Mohammed Boujemaoui <mohabouje@gmail.com>
*
* Permission is hereby granted, free of charge, to any person obta
ining a copy of
* this software and associated
documentation files (the "Software"), to deal
in
* the Software without restriction,
includ
ing without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
* the Software, and to permit persons to whom the Software is furnished to do so,
* subject to the follow
ing conditions
:
*
* The above copyright
notice and this permission
notice shall be
included
in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY K
IND, EXPRESS OR
* IMPLIED,
INCLUD
ING BUT
NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
*
FOR A PARTICULAR PURPOSE AND
NON
INFR
INGEMENT.
IN NO EVENT SHALL THE AUTHORS OR
* COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
*
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARIS
ING FROM, OUT OF OR
IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEAL
INGS
IN THE SOFTWARE.
*/
#include "w
intoastlib.h"
#include <memory>
#include <assert.h>
#include <u
nordered_map>
#include <array>
#include <functional>
#pragma comment(lib, "shlwapi")
#pragma comment(lib, "user32")
#def
ine DEFAULT_SHELL_L
INKS_PATH L"\\Microsoft\\W
indows\\Start Menu\\Programs\\"
#def
ine DEFAULT_L
INK_
FORMAT L".lnk"
#def
ine STATUS_SUCCESS (0x00000000)
#ifdef NDEBUG
static bool DebugOutputEnabled = false;
#else
static bool DebugOutputEnabled = true;
#endif
#def
ine DEBUG_MSG(str) \
do { \
if (DebugOutputEnabled) { \
std
::wcout << str << std
::endl; \
} \
} while (false)
// Quickstart
: Handl
ing toast activations from W
in32 apps
in W
indows 10
// https
://blogs.msdn.microsoft.com/tiles_and_toasts/2015/10/16/quickstart-handl
ing-toast-activations-from-w
in32-apps-
in-w
indows-10/
us
ing
namespace W
inToastLib;
void W
inToastLib
::setDebugOutputEnabled(bool enabled) {
DebugOutputEnabled = enabled;
}
namespace DllImporter {
// Function load a function from library
template <typename Function>
HRESULT loadFunctionFromLibrary(H
INSTANCE library, LPCSTR name, Function& func) {
if (!library) {
return E_
INVALIDARG;
}
func = re
interpret_cast<Function>(GetProcAddress(library, name));
return (func != nullptr) ? S_OK
: E_FAIL;
}
typedef HRESULT(FAR STDAPICALLTYPE* f_SetCurrentProcessExplicitAppUserModelID)(__
in PCWSTR AppID);
typedef HRESULT(FAR STDAPICALLTYPE* f_PropVariantTo
String)(_
In_ REFPROPVARIANT propvar, _Out_writes_(cch) PWSTR psz, _
In_ U
INT cch);
typedef HRESULT(FAR STDAPICALLTYPE* f_RoGetActivationFactory)(_
In_ H
STRING activatableClassId, _
In_ REFIID iid,
_COM_Outptr_ void** factory);
typedef HRESULT(FAR STDAPICALLTYPE* f_W
indowsCreate
StringReference)(_
In_reads_opt_(length + 1) PCWSTR source
String, U
INT32 length,
_Out_ H
STRING_HEADER* h
stringHeader,
_Outptr_result_maybenull_ _Result_nullonfailure_ H
STRING*
string);
typedef PCWSTR(FAR STDAPICALLTYPE* f_W
indowsGet
StringRawBuffer)(_
In_ H
STRING string, _Out_opt_ U
INT32* length);
typedef HRESULT(FAR STDAPICALLTYPE* f_W
indowsDelete
String)(_
In_opt_ H
STRING string);
static f_SetCurrentProcessExplicitAppUserModelID SetCurrentProcessExplicitAppUserModelID;
static f_PropVariantTo
String PropVariantTo
String;
static f_RoGetActivationFactory RoGetActivationFactory;
static f_W
indowsCreate
StringReference W
indowsCreate
StringReference;
static f_W
indowsGet
StringRawBuffer W
indowsGet
StringRawBuffer;
static f_W
indowsDelete
String W
indowsDelete
String;
template <class T>
__
inl
ine _Check_return_ HRESULT _1_GetActivationFactory(_
In_ H
STRING activatableClassId, _COM_Outptr_ T** factory) {
return RoGetActivationFactory(activatableClassId, IID_
INS_ARGS(factory));
}
template <typename T>
inl
ine HRESULT Wrap_GetActivationFactory(_
In_ H
STRING activatableClassId, _
Inout_ Details
::ComPtrRef<T> factory)
noexcept {
return _1_GetActivationFactory(activatableClassId, factory.ReleaseAndGetAddressOf());
}
inl
ine HRESULT
initialize() {
H
INSTANCE LibShell32 = LoadLibraryW(L"SHELL32.DLL");
HRESULT hr =
loadFunctionFromLibrary(LibShell32, "SetCurrentProcessExplicitAppUserModelID", SetCurrentProcessExplicitAppUserModelID);
if (SUCCEEDED(hr)) {
H
INSTANCE LibPropSys = LoadLibraryW(L"PROPSYS.DLL");
hr = loadFunctionFromLibrary(LibPropSys, "PropVariantTo
String", PropVariantTo
String);
if (SUCCEEDED(hr)) {
H
INSTANCE LibComBase = LoadLibraryW(L"COMBASE.DLL");
bool const succeded =
SUCCEEDED(loadFunctionFromLibrary(LibComBase, "RoGetActivationFactory", RoGetActivationFactory)) &&
SUCCEEDED(loadFunctionFromLibrary(LibComBase, "W
indowsCreate
StringReference", W
indowsCreate
StringReference)) &&
SUCCEEDED(loadFunctionFromLibrary(LibComBase, "W
indowsGet
StringRawBuffer", W
indowsGet
StringRawBuffer)) &&
SUCCEEDED(loadFunctionFromLibrary(LibComBase, "W
indowsDelete
String", W
indowsDelete
String));
return succeded ? S_OK
: E_FAIL;
}
}
return hr;
}
} //
namespace DllImporter
class W
inToast
StringWrapper {
public
:
W
inToast
StringWrapper(_
In_reads_(length) PCWSTR
stringRef, _
In_ U
INT32 length) {
HRESULT hr = DllImporter
::W
indowsCreate
StringReference(
stringRef, length, &_header, &_h
string);
if (!SUCCEEDED(hr)) {
RaiseException(static_cast<DWORD>(STATUS_
INVALID_PARAMETER), 0, 0, nullptr);
}
}
W
inToast
StringWrapper(_
In_ std
::w
string const&
stringRef) {
HRESULT hr =
DllImporter
::W
indowsCreate
StringReference(
stringRef.c_str(), static_cast<U
INT32>(
stringRef.length()), &_header, &_h
string);
if (FAILED(hr)) {
RaiseException(static_cast<DWORD>(STATUS_
INVALID_PARAMETER), 0, 0, nullptr);
}
}
~W
inToast
StringWrapper() {
DllImporter
::W
indowsDelete
String(_h
string);
}
inl
ine H
STRING Get() const
noexcept {
return _h
string;
}
private
:
H
STRING _h
string;
H
STRING_HEADER _header;
};
class
InternalDateTime
: public IReference<DateTime> {
public
:
static
INT64
Now() {
FILETIME
now;
GetSystemTimeAsFileTime(&
now);
return ((((
INT64)
now.dwHighDateTime) << 32) |
now.dwLowDateTime);
}
InternalDateTime(DateTime dateTime)
: _dateTime(dateTime) {}
InternalDateTime(
INT64 millisecondsFrom
Now) {
_dateTime.UniversalTime =
Now() + millisecondsFrom
Now * 10000;
}
virtual ~
InternalDateTime() = default;
operator
INT64() {
return _dateTime.UniversalTime;
}
HRESULT STDMETHODCALLTYPE get_Value(DateTime* dateTime) {
*dateTime = _dateTime;
return S_OK;
}
HRESULT STDMETHODCALLTYPE Query
Interface(const IID& riid, void** ppvObject) {
if (!ppvObject) {
return E_PO
INTER;
}
if (riid == __uuidof(IUnk
nown) || riid == __uuidof(IReference<DateTime>)) {
*ppvObject = static_cast<IUnk
nown*>(static_cast<IReference<DateTime>*>(this));
return S_OK;
}
return E_
NOINTERFACE;
}
ULONG STDMETHODCALLTYPE Release() {
return 1;
}
ULONG STDMETHODCALLTYPE AddRef() {
return 2;
}
HRESULT STDMETHODCALLTYPE GetIids(ULONG*, IID**) {
return E_
NOTIMPL;
}
HRESULT STDMETHODCALLTYPE GetRuntimeClassName(H
STRING*) {
return E_
NOTIMPL;
}
HRESULT STDMETHODCALLTYPE GetTrustLevel(TrustLevel*) {
return E_
NOTIMPL;
}
protected
:
DateTime _dateTime;
};
namespace Util {
typedef LONG NTSTATUS, *PNTSTATUS;
typedef NTSTATUS(W
INAPI* RtlGetVersionPtr)(PRTL_OSVERSION
INFOW);
inl
ine RTL_OSVERSION
INFOW getRealOSVersion() {
HMODULE hMod =
::GetModuleHandleW(L"ntdll.dll");
if (hMod) {
RtlGetVersionPtr fxPtr = (RtlGetVersionPtr)
::GetProcAddress(hMod, "RtlGetVersion");
if (fxPtr != nullptr) {
RTL_OSVERSION
INFOW rovi = {0};
rovi.dwOSVersion
InfoSize = sizeof(rovi);
if (STATUS_SUCCESS == fxPtr(&rovi)) {
return rovi;
}
}
}
RTL_OSVERSION
INFOW rovi = {0};
return rovi;
}
inl
ine HRESULT defaultExecutablePath(_
In_ WCHAR* path, _
In_ DWORD nSize = MAX_PATH) {
DWORD written = GetModuleFileNameExW(GetCurrentProcess(), nullptr, path, nSize);
DEBUG_MSG("Default executable path
: " << path);
return (written > 0) ? S_OK
: E_FAIL;
}
inl
ine HRESULT defaultShellL
inksDirectory(_
In_ WCHAR* path, _
In_ DWORD nSize = MAX_PATH) {
DWORD written = GetEnvironmentVariableW(L"APPDATA", path, nSize);
HRESULT hr = written > 0 ? S_OK
: E_
INVALIDARG;
if (SUCCEEDED(hr)) {
err
no_t result = wcscat_s(path, nSize, DEFAULT_SHELL_L
INKS_PATH);
hr = (result == 0) ? S_OK
: E_
INVALIDARG;
DEBUG_MSG("Default shell l
ink path
: " << path);
}
return hr;
}
inl
ine HRESULT defaultShellL
inkPath(_
In_ std
::w
string const& appname, _
In_ WCHAR* path, _
In_ DWORD nSize = MAX_PATH) {
HRESULT hr = defaultShellL
inksDirectory(path, nSize);
if (SUCCEEDED(hr)) {
std
::w
string const appL
ink(appname + DEFAULT_L
INK_
FORMAT);
err
no_t result = wcscat_s(path, nSize, appL
ink.c_str());
hr = (result == 0) ? S_OK
: E_
INVALIDARG;
DEBUG_MSG("Default shell l
ink file path
: " << path);
}
return hr;
}
inl
ine std
::w
string parentDirectory(WCHAR* path, DWORD size) {
size_t lastSeparator = 0;
for (size_t i = 0; i < size; i++) {
if (path[i] == L&
#39;\\&
#39; || path[i] == L&
#39;/&
#39;) {
lastSeparator = i;
}
}
return {path, lastSeparator};
}
inl
ine PCWSTR As
String(_
In_ ComPtr<IXml
Document>& xml
Document) {
H
STRING xml;
ComPtr<IXml
NodeSerializer> ser;
HRESULT hr = xml
Document.As<IXml
NodeSerializer>(&ser);
hr = ser->GetXml(&xml);
if (SUCCEEDED(hr)) {
return DllImporter
::W
indowsGet
StringRawBuffer(xml, nullptr);
}
return nullptr;
}
inl
ine PCWSTR As
String(_
In_ H
STRING h
string) {
return DllImporter
::W
indowsGet
StringRawBuffer(h
string, nullptr);
}
inl
ine HRESULT set
Node
StringValue(_
In_ std
::w
string const&
string, _Out_opt_ IXml
Node*
node, _Out_ IXml
Document* xml) {
ComPtr<IXmlText> text
Node;
HRESULT hr = xml->CreateText
Node(W
inToast
StringWrapper(
string).Get(), &text
Node);
if (SUCCEEDED(hr)) {
ComPtr<IXml
Node>
stringNode;
hr = text
Node.As(&
stringNode);
if (SUCCEEDED(hr)) {
ComPtr<IXml
Node> appendedChild;
hr =
node->AppendChild(
stringNode.Get(), &appendedChild);
}
}
return hr;
}
template <typename FunctorT>
inl
ine HRESULT setEventHandlers(_
In_ IToast
Notification*
notification, _
In_ std
::shared_ptr<IW
inToastHandler> eventHandler,
_
In_
INT64 expirationTime, _Out_ EventRegistrationToken& activatedToken,
_Out_ EventRegistrationToken& dismissedToken, _Out_ EventRegistrationToken& failedToken,
_
In_ FunctorT&& markAsReady
ForDeletionFunc) {
HRESULT hr =
notification->add_Activated(
Callback<Implements<RuntimeClassFlags<ClassicCom>, ITypedEventHandler<Toast
Notification*, I
Inspectable*>>>(
[eventHandler, markAsReady
ForDeletionFunc](IToast
Notification*
notify, I
Inspectable*
inspectable) {
ComPtr<IToastActivatedEventArgs> activatedEventArgs;
HRESULT hr =
inspectable->Query
Interface(activatedEventArgs.GetAddressOf());
if (SUCCEEDED(hr)) {
H
STRING argumentsHandle;
hr = activatedEventArgs->get_Arguments(&argumentsHandle);
if (SUCCEEDED(hr)) {
PCWSTR arguments = Util
::As
String(argumentsHandle);
if (wcscmp(arguments, L"action=reply") == 0) {
ComPtr<IToastActivatedEventArgs2>
inputBoxActivatedEventArgs;
HRESULT hr2 =
inspectable->Query
Interface(
inputBoxActivatedEventArgs.GetAddressOf());
if (SUCCEEDED(hr2)) {
ComPtr<Collections
::IPropertySet> replyHandle;
inputBoxActivatedEventArgs->get_User
Input(&replyHandle);
ComPtr<__FIMap_2_H
STRING_I
Inspectable> replyMap;
hr = replyHandle.As(&replyMap);
if (SUCCEEDED(hr)) {
I
Inspectable* propertySet;
hr = replyMap.Get()->Lookup(W
inToast
StringWrapper(L"textBox").Get(), &propertySet);
if (SUCCEEDED(hr)) {
ComPtr<IPropertyValue> propertyValue;
hr = propertySet->Query
Interface(IID_PPV_ARGS(&propertyValue));
if (SUCCEEDED(hr)) {
// Successfully queried IPropertyValue,
now extract the value
H
STRING user
Input;
hr = propertyValue->Get
String(&user
Input);
if (SUCCEEDED(hr)) {
// Convert the H
STRING to a wide
string
PCWSTR strValue = Util
::As
String(user
Input);
eventHandler->toastActivated(std
::w
string(strValue));
DllImporter
::W
indowsDelete
String(user
Input);
return S_OK;
}
if (user
Input != nullptr) {
DllImporter
::W
indowsDelete
String(user
Input);
}
}
}
}
}
}
if (arguments && *arguments) {
eventHandler->toastActivated(static_cast<long>(wcstol(arguments, nullptr, 10)));
DllImporter
::W
indowsDelete
String(argumentsHandle);
markAsReady
ForDeletionFunc();
return S_OK;
}
DllImporter
::W
indowsDelete
String(argumentsHandle);
}
}
eventHandler->toastActivated();
markAsReady
ForDeletionFunc();
return S_OK;
})
.Get(),
&activatedToken);
if (SUCCEEDED(hr)) {
hr =
notification->add_Dismissed(
Callback<Implements<RuntimeClassFlags<ClassicCom>, ITypedEventHandler<Toast
Notification*, ToastDismissedEventArgs*>>>(
[eventHandler, expirationTime, markAsReady
ForDeletionFunc](IToast
Notification*
notify, IToastDismissedEventArgs* e) {
ToastDismissalReason reason;
if (SUCCEEDED(e->get_Reason(&reason))) {
if (reason == ToastDismissalReason_UserCanceled && expirationTime &&
InternalDateTime
::Now() >= expirationTime) {
reason = ToastDismissalReason_TimedOut;
}
eventHandler->toastDismissed(static_cast<IW
inToastHandler
::W
inToastDismissalReason>(reason));
}
markAsReady
ForDeletionFunc();
return S_OK;
})
.Get(),
&dismissedToken);
if (SUCCEEDED(hr)) {
hr =
notification->add_Failed(
Callback<Implements<RuntimeClassFlags<ClassicCom>, ITypedEventHandler<Toast
Notification*, ToastFailedEventArgs*>>>(
[eventHandler, markAsReady
ForDeletionFunc](IToast
Notification*
notify, IToastFailedEventArgs* e) {
eventHandler->toastFailed();
markAsReady
ForDeletionFunc();
return S_OK;
})
.Get(),
&failedToken);
}
}
return hr;
}
inl
ine HRESULT addAttribute(_
In_ IXml
Document* xml, std
::w
string const& name, IXmlNamed
NodeMap* attributeMap) {
ComPtr<ABI
::W
indows
::Data
::Xml
::Dom
::IXmlAttribute> srcAttribute;
HRESULT hr = xml->CreateAttribute(W
inToast
StringWrapper(name).Get(), &srcAttribute);
if (SUCCEEDED(hr)) {
ComPtr<IXml
Node>
node;
hr = srcAttribute.As(&
node);
if (SUCCEEDED(hr)) {
ComPtr<IXml
Node> p
Node;
hr = attributeMap->SetNamedItem(
node.Get(), &p
Node);
}
}
return hr;
}
inl
ine HRESULT createElement(_
In_ IXml
Document* xml, _
In_ std
::w
string const& root_
node, _
In_ std
::w
string const& element_name,
_
In_ std
::vector<std
::w
string> const& attribute_
names) {
ComPtr<IXml
NodeList> rootList;
HRESULT hr = xml->GetElementsByTagName(W
inToast
StringWrapper(root_
node).Get(), &rootList);
if (SUCCEEDED(hr)) {
ComPtr<IXml
Node> root;
hr = rootList->Item(0, &root);
if (SUCCEEDED(hr)) {
ComPtr<ABI
::W
indows
::Data
::Xml
::Dom
::IXmlElement> audioElement;
hr = xml->CreateElement(W
inToast
StringWrapper(element_name).Get(), &audioElement);
if (SUCCEEDED(hr)) {
ComPtr<IXml
Node> audio
NodeTmp;
hr = audioElement.As(&audio
NodeTmp);
if (SUCCEEDED(hr)) {
ComPtr<IXml
Node> audio
Node;
hr = root->AppendChild(audio
NodeTmp.Get(), &audio
Node);
if (SUCCEEDED(hr)) {
ComPtr<IXmlNamed
NodeMap> attributes;
hr = audio
Node->get_Attributes(&attributes);
if (SUCCEEDED(hr)) {
for (auto const& it
: attribute_
names) {
hr = addAttribute(xml, it, attributes.Get());
}
}
}
}
}
}
}
return hr;
}
} //
namespace Util
W
inToast* W
inToast
::instance() {
thread_local static W
inToast
instance;
return &
instance;
}
W
inToast
::W
inToast()
: _is
Initialized(false), _hasCo
Initialized(false) {
if (!isCompatible()) {
DEBUG_MSG(L"
Warning: Your system is
not compatible with this library ");
}
}
W
inToast
::~W
inToast() {
clear();
if (_hasCo
Initialized) {
CoUn
initialize();
}
}
void W
inToast
::setAppName(_
In_ std
::w
string const& appName) {
_appName = appName;
}
void W
inToast
::setAppUserModelId(_
In_ std
::w
string const& aumi) {
_aumi = aumi;
DEBUG_MSG(L"Default App User Model Id
: " << _aumi.c_str());
}
void W
inToast
::setShortcutPolicy(_
In_ ShortcutPolicy shortcutPolicy) {
_shortcutPolicy = shortcutPolicy;
}
bool W
inToast
::isCompatible() {
DllImporter
::initialize();
return !((DllImporter
::SetCurrentProcessExplicitAppUserModelID == nullptr) || (DllImporter
::PropVariantTo
String == nullptr) ||
(DllImporter
::RoGetActivationFactory == nullptr) || (DllImporter
::W
indowsCreate
StringReference == nullptr) ||
(DllImporter
::W
indowsDelete
String == nullptr));
}
bool W
inToastLib
::W
inToast
::isSupport
ingModernFeatures() {
constexpr auto M
inimumSupportedVersion = 6;
return Util
::getRealOSVersion().dwMajorVersion > M
inimumSupportedVersion;
}
bool W
inToastLib
::W
inToast
::isW
in10AnniversaryOrHigher() {
return Util
::getRealOSVersion().dwBuildNumber >= 14393;
}
std
::w
string W
inToast
::configureAUMI(_
In_ std
::w
string const& companyName, _
In_ std
::w
string const& productName,
_
In_ std
::w
string const& subProduct, _
In_ std
::w
string const& version
Information) {
std
::w
string aumi = companyName;
aumi += L"." + productName;
if (subProduct.length() > 0) {
aumi += L"." + subProduct;
if (version
Information.length() > 0) {
aumi += L"." + version
Information;
}
}
if (aumi.length() > SCHAR_MAX) {
DEBUG_MSG("Error
: max size allowed
for AUMI
: 128 characters.");
}
return aumi;
}
std
::w
string const& W
inToast
::strerror(W
inToastError error) {
static std
::u
nordered_map<W
inToastError, std
::w
string> const Labels = {
{W
inToastError
::NoError, L"
No error. The process was executed correctly" },
{W
inToastError
::Not
Initialized, L"The library has
not been
initialized" },
{W
inToastError
::System
NotSupported, L"The OS does
not support W
inToast" },
{W
inToastError
::ShellL
ink
NotCreated, L"The library was
not able to create a Shell L
ink
for the app" },
{W
inToastError
::InvalidAppUserModelID, L"The AUMI is
not a valid one" },
{W
inToastError
::InvalidParameters, L"
Invalid parameters, please double-check the AUMI or App Name" },
{W
inToastError
::NotDisplayed, L"The toast was created correctly but W
inToast was
not able to display the toast"},
{W
inToastError
::Unk
nownError, L"Unk
nown error" }
};
auto const iter = Labels.f
ind(error);
assert(iter != Labels.end());
return iter->second;
}
enum W
inToast
::ShortcutResult W
inToast
::createShortcut() {
if (_aumi.empty() || _appName.empty()) {
DEBUG_MSG(L"Error
: App User Model Id or Appname is empty!");
return SHORTCUT_MISS
ING_PARAMETERS;
}
if (!isCompatible()) {
DEBUG_MSG(L"Your OS is
not compatible with this library! =(");
return SHORTCUT_
INCOMPATIBLE_OS;
}
if (!_hasCo
Initialized) {
HRESULT
initHr = Co
InitializeEx(nullptr, CO
INIT
::CO
INIT_MULTITHREADED);
if (
initHr != RPC_E_CHANGED_MODE) {
if (FAILED(
initHr) &&
initHr != S_FALSE) {
DEBUG_MSG(L"Error on COM library
initialization!");
return SHORTCUT_COM_
INIT_FAILURE;
} else {
_hasCo
Initialized = true;
}
}
}
bool wasChanged;
HRESULT hr = validateShellL
inkHelper(wasChanged);
if (SUCCEEDED(hr)) {
return wasChanged ? SHORTCUT_WAS_CHANGED
: SHORTCUT_UNCHANGED;
}
hr = createShellL
inkHelper();
return SUCCEEDED(hr) ? SHORTCUT_WAS_CREATED
: SHORTCUT_CREATE_FAILED;
}
bool W
inToast
::initialize(_Out_opt_ W
inToastError* error) {
_is
Initialized = false;
setError(error, W
inToastError
::NoError);
if (!isCompatible()) {
setError(error, W
inToastError
::System
NotSupported);
DEBUG_MSG(L"Error
: system
not supported.");
return false;
}
if (_aumi.empty() || _appName.empty()) {
setError(error, W
inToastError
::InvalidParameters);
DEBUG_MSG(L"Error while
initializ
ing, did you set up a valid AUMI and App name?");
return false;
}
if (_shortcutPolicy != SHORTCUT_POLICY_IG
NORE) {
if (createShortcut() < 0) {
setError(error, W
inToastError
::ShellL
ink
NotCreated);
DEBUG_MSG(L"Error while attach
ing the AUMI to the current proccess =(");
return false;
}
}
if (FAILED(DllImporter
::SetCurrentProcessExplicitAppUserModelID(_aumi.c_str()))) {
setError(error, W
inToastError
::InvalidAppUserModelID);
DEBUG_MSG(L"Error while attach
ing the AUMI to the current proccess =(");
return false;
}
_is
Initialized = true;
return _is
Initialized;
}
bool W
inToast
::is
Initialized() const {
return _is
Initialized;
}
std
::w
string const& W
inToast
::appName() const {
return _appName;
}
std
::w
string const& W
inToast
::appUserModelId() const {
return _aumi;
}
HRESULT W
inToast
::validateShellL
inkHelper(_Out_ bool& wasChanged) {
WCHAR path[MAX_PATH] = {L&
#39;\0&
#39;};
Util
::defaultShellL
inkPath(_appName, path);
// Check if the file exist
DWORD attr = GetFileAttributesW(path);
if (attr >= 0xFFFFFFF) {
DEBUG_MSG("Error, shell l
ink
not found. Try to create a new one
in: " << path);
return E_FAIL;
}
// Let&
#39;s load the file as shell l
ink to validate.
// - Create a shell l
ink
// - Create a persistant file
// - Load the path as data
for the persistant file
// - Read the property AUMI and validate with the current
// - Review if AUMI is equal.
ComPtr<IShellL
ink> shellL
ink;
HRESULT hr = CoCreate
Instance(CLSID_ShellL
ink, nullptr, CLSCTX_
INPROC_SERVER, IID_PPV_ARGS(&shellL
ink));
if (SUCCEEDED(hr)) {
ComPtr<IPersistFile> persistFile;
hr = shellL
ink.As(&persistFile);
if (SUCCEEDED(hr)) {
hr = persistFile->Load(path, STGM_READWRITE);
if (SUCCEEDED(hr)) {
ComPtr<IPropertyStore> propertyStore;
hr = shellL
ink.As(&propertyStore);
if (SUCCEEDED(hr)) {
PROPVARIANT appIdPropVar;
hr = propertyStore->GetValue(PKEY_AppUserModel_ID, &appIdPropVar);
if (SUCCEEDED(hr)) {
WCHAR AUMI[MAX_PATH];
hr = DllImporter
::PropVariantTo
String(appIdPropVar, AUMI, MAX_PATH);
wasChanged = false;
if (FAILED(hr) || _aumi != AUMI) {
if (_shortcutPolicy == SHORTCUT_POLICY_REQUIRE_CREATE) {
// AUMI Changed
for the same app, let&
#39;s update the current value! =)
wasChanged = true;
PropVariantClear(&appIdPropVar);
hr =
InitPropVariantFrom
String(_aumi.c_str(), &appIdPropVar);
if (SUCCEEDED(hr)) {
hr = propertyStore->SetValue(PKEY_AppUserModel_ID, appIdPropVar);
if (SUCCEEDED(hr)) {
hr = propertyStore->Commit();
if (SUCCEEDED(hr) && SUCCEEDED(persistFile->IsDirty())) {
hr = persistFile->Save(path, TRUE);
}
}
}
} else {
//
Not allowed to touch the shortcut to fix the AUMI
hr = E_FAIL;
}
}
PropVariantClear(&appIdPropVar);
}
}
}
}
}
return hr;
}
HRESULT W
inToast
::createShellL
inkHelper() {
if (_shortcutPolicy != SHORTCUT_POLICY_REQUIRE_CREATE) {
return E_FAIL;
}
WCHAR exePath[MAX_PATH]{L&
#39;\0&
#39;};
WCHAR slPath[MAX_PATH]{L&
#39;\0&
#39;};
Util
::defaultShellL
inkPath(_appName, slPath);
Util
::defaultExecutablePath(exePath);
std
::w
string exeDir = Util
::parentDirectory(exePath, sizeof(exePath) / sizeof(exePath[0]));
ComPtr<IShellL
inkW> shellL
ink;
HRESULT hr = CoCreate
Instance(CLSID_ShellL
ink, nullptr, CLSCTX_
INPROC_SERVER, IID_PPV_ARGS(&shellL
ink));
if (SUCCEEDED(hr)) {
hr = shellL
ink->SetPath(exePath);
if (SUCCEEDED(hr)) {
hr = shellL
ink->SetArguments(L"");
if (SUCCEEDED(hr)) {
hr = shellL
ink->SetWork
ingDirectory(exeDir.c_str());
if (SUCCEEDED(hr)) {
ComPtr<IPropertyStore> propertyStore;
hr = shellL
ink.As(&propertyStore);
if (SUCCEEDED(hr)) {
PROPVARIANT appIdPropVar;
hr =
InitPropVariantFrom
String(_aumi.c_str(), &appIdPropVar);
if (SUCCEEDED(hr)) {
hr = propertyStore->SetValue(PKEY_AppUserModel_ID, appIdPropVar);
if (SUCCEEDED(hr)) {
hr = propertyStore->Commit();
if (SUCCEEDED(hr)) {
ComPtr<IPersistFile> persistFile;
hr = shellL
ink.As(&persistFile);
if (SUCCEEDED(hr)) {
hr = persistFile->Save(slPath, TRUE);
}
}
}
PropVariantClear(&appIdPropVar);
}
}
}
}
}
}
return hr;
}
INT64 W
inToast
::showToast(_
In_ W
inToast
Template const& toast, _
In_ IW
inToastHandler* eventHandler, _Out_ W
inToastError* error) {
std
::shared_ptr<IW
inToastHandler> handler(eventHandler);
setError(error, W
inToastError
::NoError);
INT64 id = -1;
if (!is
Initialized()) {
setError(error, W
inToastError
::Not
Initialized);
DEBUG_MSG("Error when launch
ing the toast. W
inToast is
not
initialized.");
return id;
}
if (!handler) {
setError(error, W
inToastError
::InvalidHandler);
DEBUG_MSG("Error when launch
ing the toast. Handler can
not be nullptr.");
return id;
}
ComPtr<IToast
NotificationManagerStatics>
notificationManager;
HRESULT hr = DllImporter
::Wrap_GetActivationFactory(
W
inToast
StringWrapper(RuntimeClass_W
indows_UI_
Notifications_Toast
NotificationManager).Get(), &
notificationManager);
if (SUCCEEDED(hr)) {
ComPtr<IToast
Notifier>
notifier;
hr =
notificationManager->CreateToast
NotifierWithId(W
inToast
StringWrapper(_aumi).Get(), &
notifier);
if (SUCCEEDED(hr)) {
ComPtr<IToast
NotificationFactory>
notificationFactory;
hr = DllImporter
::Wrap_GetActivationFactory(
W
inToast
StringWrapper(RuntimeClass_W
indows_UI_
Notifications_Toast
Notification).Get(), &
notificationFactory);
if (SUCCEEDED(hr)) {
ComPtr<IXml
Document> xml
Document;
hr =
notificationManager->Get
TemplateContent(Toast
TemplateType(toast.type()), &xml
Document);
if (SUCCEEDED(hr) && toast.isToastGeneric()) {
hr = setB
indToastGenericHelper(xml
Document.Get());
}
if (SUCCEEDED(hr)) {
for (U
INT32 i = 0, fieldsCount = static_cast<U
INT32>(toast.textFieldsCount()); i < fieldsCount && SUCCEEDED(hr); i++) {
hr = setTextFieldHelper(xml
Document.Get(), toast.textField(W
inToast
Template::TextField(i)), i);
}
// Modern feature are supported W
indows > W
indows 10
if (SUCCEEDED(hr) && isSupport
ingModernFeatures()) {
//
Note that we do this *after* us
ing toast.textFieldsCount() to
// iterate/fill the
template&
#39;s text fields, s
ince we&
#39;re add
ing yet a
nother text field.
if (SUCCEEDED(hr) && !toast.attributionText().empty()) {
hr = setAttributionTextFieldHelper(xml
Document.Get(), toast.attributionText());
}
std
::array<WCHAR, 12> buf;
for (std
::size_t i = 0, actionsCount = toast.actionsCount(); i < actionsCount && SUCCEEDED(hr); i++) {
_snwpr
intf_s(buf.data(), buf.size(), _TRUNCATE, L"%zd", i);
hr = addActionHelper(xml
Document.Get(), toast.actionLabel(i), buf.data());
}
if (SUCCEEDED(hr)) {
hr = (toast.audioPath().empty() && toast.audioOption() == W
inToast
Template::AudioOption
::Default)
? hr
: setAudioFieldHelper(xml
Document.Get(), toast.audioPath(), toast.audioOption());
}
if (SUCCEEDED(hr) && toast.duration() != W
inToast
Template::Duration
::System) {
hr = addDurationHelper(xml
Document.Get(),
(toast.duration() == W
inToast
Template::Duration
::Short) ? L"short"
: L"long");
}
if (SUCCEEDED(hr) && toast.is
Input()) {
hr = add
InputHelper(xml
Document.Get());
}
if (SUCCEEDED(hr)) {
hr = addScenarioHelper(xml
Document.Get(), toast.scenario());
}
} else {
DEBUG_MSG("Modern features (Actions/Sounds/Attributes)
not supported
in this os version");
}
if (SUCCEEDED(hr)) {
bool isW
in10AnniversaryOrAbove = W
inToast
::isW
in10AnniversaryOrHigher();
bool isCircleCropH
int = isW
in10AnniversaryOrAbove ? toast.isCropH
intCircle()
: false;
hr = toast.hasImage()
? setImageFieldHelper(xml
Document.Get(), toast.imagePath(), toast.isToastGeneric(), isCircleCropH
int)
: hr;
if (SUCCEEDED(hr) && isW
in10AnniversaryOrAbove && toast.hasHeroImage()) {
hr = setHeroImageHelper(xml
Document.Get(), toast.heroImagePath(), toast.is
Inl
ineHeroImage());
}
if (SUCCEEDED(hr)) {
ComPtr<IToast
Notification>
notification;
hr =
notificationFactory->CreateToast
Notification(xml
Document.Get(), &
notification);
if (SUCCEEDED(hr)) {
INT64 expiration = 0, relativeExpiration = toast.expiration();
if (relativeExpiration > 0) {
InternalDateTime expirationDateTime(relativeExpiration);
expiration = expirationDateTime;
hr =
notification->put_ExpirationTime(&expirationDateTime);
}
EventRegistrationToken activatedToken, dismissedToken, failedToken;
GUID guid;
HRESULT hrGuid = CoCreateGuid(&guid);
id = guid.Data1;
if (SUCCEEDED(hr) && SUCCEEDED(hrGuid)) {
hr = Util
::setEventHandlers(
notification.Get(), handler, expiration, activatedToken, dismissedToken,
failedToken, [this, id]() { markAsReady
ForDeletion(id); });
if (FAILED(hr)) {
setError(error, W
inToastError
::InvalidHandler);
}
}
if (SUCCEEDED(hr)) {
if (SUCCEEDED(hr)) {
std
::lock_guard<std
::mutex> lock(m_mutex);
_buffer.emplace(id,
NotifyData(
notification, activatedToken, dismissedToken, failedToken));
DEBUG_MSG("xml
: " << Util
::As
String(xml
Document));
hr =
notifier->Show(
notification.Get());
if (FAILED(hr)) {
setError(error, W
inToastError
::NotDisplayed);
}
}
}
}
}
}
}
}
}
}
return FAILED(hr) ? -1
: id;
}
ComPtr<IToast
Notifier> W
inToast
::notifier(_
In_ bool* succeded) const {
ComPtr<IToast
NotificationManagerStatics>
notificationManager;
ComPtr<IToast
Notifier>
notifier;
HRESULT hr = DllImporter
::Wrap_GetActivationFactory(
W
inToast
StringWrapper(RuntimeClass_W
indows_UI_
Notifications_Toast
NotificationManager).Get(), &
notificationManager);
if (SUCCEEDED(hr)) {
hr =
notificationManager->CreateToast
NotifierWithId(W
inToast
StringWrapper(_aumi).Get(), &
notifier);
}
*succeded = SUCCEEDED(hr);
return
notifier;
}
void W
inToast
::markAsReady
ForDeletion(_
In_
INT64 id) {
std
::lock_guard<std
::mutex> lock(m_mutex);
// Flush the buffer by remov
ing all the toasts that are ready
for deletion
for (auto it = _buffer.beg
in(); it != _buffer.end();) {
if (it->second.isReady
ForDeletion()) {
it->second.RemoveTokens();
it = _buffer.erase(it);
} else {
++it;
}
}
// Mark the toast as ready
for deletion (if it exists) so that it will be removed from the buffer
in the next iteration
auto const iter = _buffer.f
ind(id);
if (iter != _buffer.end()) {
_buffer[id].markAsReady
ForDeletion();
}
}
bool W
inToast
::hideToast(_
In_
INT64 id) {
std
::lock_guard<std
::mutex> lock(m_mutex);
if (!is
Initialized()) {
DEBUG_MSG("Error when hid
ing the toast. W
inToast is
not
initialized.");
return false;
}
auto iter = _buffer.f
ind(id);
if (iter == _buffer.end()) {
return false;
}
auto succeded = false;
auto
notify =
notifier(&succeded);
if (!succeded) {
return false;
}
auto&
notifyData = iter->second;
auto result =
notify->Hide(
notifyData.
notification());
if (FAILED(result)) {
DEBUG_MSG("Error when hid
ing the toast. Error code
: " << result);
return false;
}
notifyData.RemoveTokens();
_buffer.erase(iter);
return SUCCEEDED(result);
}
void W
inToast
::clear() {
auto succeded = false;
auto
notify =
notifier(&succeded);
if (!succeded) {
return;
}
std
::lock_guard<std
::mutex> lock(m_mutex);
auto safeCopy = _buffer;
for (auto& data
: safeCopy) {
auto&
notifyData = data.second;
notify->Hide(
notifyData.
notification());
notifyData.RemoveTokens();
}
_buffer.clear();
}
//
// Available as of W
indows 10 Anniversary Update
// Ref
: https
://docs.microsoft.com/en-us/w
indows/uwp/design/shell/tiles-and-
notifications/adaptive-
interactive-toasts
//
//
NOTE
: This will add a new text field, so be aware when iterat
ing over
// the toast&
#39;s text fields or gett
ing a count of them.
//
HRESULT W
inToast
::setAttributionTextFieldHelper(_
In_ IXml
Document* xml, _
In_ std
::w
string const& text) {
Util
::createElement(xml, L"b
ind
ing", L"text", {L"placement"});
ComPtr<IXml
NodeList>
nodeList;
HRESULT hr = xml->GetElementsByTagName(W
inToast
StringWrapper(L"text").Get(), &
nodeList);
if (SUCCEEDED(hr)) {
U
INT32
nodeListLength;
hr =
nodeList->get_Length(&
nodeListLength);
if (SUCCEEDED(hr)) {
for (U
INT32 i = 0; i <
nodeListLength; i++) {
ComPtr<IXml
Node> text
Node;
hr =
nodeList->Item(i, &text
Node);
if (SUCCEEDED(hr)) {
ComPtr<IXmlNamed
NodeMap> attributes;
hr = text
Node->get_Attributes(&attributes);
if (SUCCEEDED(hr)) {
ComPtr<IXml
Node> edited
Node;
if (SUCCEEDED(hr)) {
hr = attributes->GetNamedItem(W
inToast
StringWrapper(L"placement").Get(), &edited
Node);
if (FAILED(hr) || !edited
Node) {
cont
inue;
}
hr = Util
::set
Node
StringValue(L"attribution", edited
Node.Get(), xml);
if (SUCCEEDED(hr)) {
return setTextFieldHelper(xml, text, i);
}
}
}
}
}
}
}
return hr;
}
HRESULT W
inToast
::addDurationHelper(_
In_ IXml
Document* xml, _
In_ std
::w
string const& duration) {
ComPtr<IXml
NodeList>
nodeList;
HRESULT hr = xml->GetElementsByTagName(W
inToast
StringWrapper(L"toast").Get(), &
nodeList);
if (SUCCEEDED(hr)) {
U
INT32 length;
hr =
nodeList->get_Length(&length);
if (SUCCEEDED(hr)) {
ComPtr<IXml
Node> toast
Node;
hr =
nodeList->Item(0, &toast
Node);
if (SUCCEEDED(hr)) {
ComPtr<IXmlElement> toastElement;
hr = toast
Node.As(&toastElement);
if (SUCCEEDED(hr)) {
hr = toastElement->SetAttribute(W
inToast
StringWrapper(L"duration").Get(), W
inToast
StringWrapper(duration).Get());
}
}
}
}
return hr;
}
HRESULT W
inToast
::addScenarioHelper(_
In_ IXml
Document* xml, _
In_ std
::w
string const& scenario) {
ComPtr<IXml
NodeList>
nodeList;
HRESULT hr = xml->GetElementsByTagName(W
inToast
StringWrapper(L"toast").Get(), &
nodeList);
if (SUCCEEDED(hr)) {
U
INT32 length;
hr =
nodeList->get_Length(&length);
if (SUCCEEDED(hr)) {
ComPtr<IXml
Node> toast
Node;
hr =
nodeList->Item(0, &toast
Node);
if (SUCCEEDED(hr)) {
ComPtr<IXmlElement> toastElement;
hr = toast
Node.As(&toastElement);
if (SUCCEEDED(hr)) {
hr = toastElement->SetAttribute(W
inToast
StringWrapper(L"scenario").Get(), W
inToast
StringWrapper(scenario).Get());
}
}
}
}
return hr;
}
HRESULT W
inToast
::add
InputHelper(_
In_ IXml
Document* xml) {
std
::vector<std
::w
string> attrbs;
attrbs.push_back(L"id");
attrbs.push_back(L"type");
attrbs.push_back(L"placeHolderContent");
std
::vector<std
::w
string> attrbs2;
attrbs2.push_back(L"content");
attrbs2.push_back(L"arguments");
Util
::createElement(xml, L"toast", L"actions", {});
Util
::createElement(xml, L"actions", L"
input", attrbs);
Util
::createElement(xml, L"actions", L"action", attrbs2);
ComPtr<IXml
NodeList>
nodeList;
HRESULT hr = xml->GetElementsByTagName(W
inToast
StringWrapper(L"
input").Get(), &
nodeList);
if (SUCCEEDED(hr)) {
ComPtr<IXml
Node>
input
Node;
hr =
nodeList->Item(0, &
input
Node);
if (SUCCEEDED(hr)) {
ComPtr<IXmlElement> toastElement;
hr =
input
Node.As(&toastElement);
if (SUCCEEDED(hr)) {
toastElement->SetAttribute(W
inToast
StringWrapper(L"id").Get(), W
inToast
StringWrapper(L"textBox").Get());
toastElement->SetAttribute(W
inToast
StringWrapper(L"type").Get(), W
inToast
StringWrapper(L"text").Get());
hr = toastElement->SetAttribute(W
inToast
StringWrapper(L"placeHolderContent").Get(), W
inToast
StringWrapper(L"...").Get());
}
}
}
ComPtr<IXml
NodeList>
nodeList2;
hr = xml->GetElementsByTagName(W
inToast
StringWrapper(L"action").Get(), &
nodeList2);
if (SUCCEEDED(hr)) {
ComPtr<IXml
Node> action
Node;
hr =
nodeList2->Item(0, &action
Node);
if (SUCCEEDED(hr)) {
ComPtr<IXmlElement> actionElement;
hr = action
Node.As(&actionElement);
if (SUCCEEDED(hr)) {
actionElement->SetAttribute(W
inToast
StringWrapper(L"content").Get(), W
inToast
StringWrapper(L"Reply").Get());
actionElement->SetAttribute(W
inToast
StringWrapper(L"arguments").Get(), W
inToast
StringWrapper(L"action=reply").Get());
actionElement->SetAttribute(W
inToast
StringWrapper(L"h
int-
inputId").Get(), W
inToast
StringWrapper(L"textBox").Get());
}
}
}
return hr;
}
HRESULT W
inToast
::setTextFieldHelper(_
In_ IXml
Document* xml, _
In_ std
::w
string const& text, _
In_ U
INT32 pos) {
ComPtr<IXml
NodeList>
nodeList;
HRESULT hr = xml->GetElementsByTagName(W
inToast
StringWrapper(L"text").Get(), &
nodeList);
if (SUCCEEDED(hr)) {
ComPtr<IXml
Node>
node;
hr =
nodeList->Item(pos, &
node);
if (SUCCEEDED(hr)) {
hr = Util
::set
Node
StringValue(text,
node.Get(), xml);
}
}
return hr;
}
HRESULT W
inToast
::setB
indToastGenericHelper(_
In_ IXml
Document* xml) {
ComPtr<IXml
NodeList>
nodeList;
HRESULT hr = xml->GetElementsByTagName(W
inToast
StringWrapper(L"b
ind
ing").Get(), &
nodeList);
if (SUCCEEDED(hr)) {
U
INT32 length;
hr =
nodeList->get_Length(&length);
if (SUCCEEDED(hr)) {
ComPtr<IXml
Node> toast
Node;
hr =
nodeList->Item(0, &toast
Node);
if (SUCCEEDED(hr)) {
ComPtr<IXmlElement> toastElement;
hr = toast
Node.As(&toastElement);
if (SUCCEEDED(hr)) {
hr = toastElement->SetAttribute(W
inToast
StringWrapper(L"
template").Get(), W
inToast
StringWrapper(L"ToastGeneric").Get());
}
}
}
}
return hr;
}
HRESULT W
inToast
::setImageFieldHelper(_
In_ IXml
Document* xml, _
In_ std
::w
string const& path, _
In_ bool isToastGeneric,
_
In_ bool isCropH
intCircle) {
assert(path.size() < MAX_PATH);
wchar_t imagePath[MAX_PATH] = L"file
:///";
HRESULT hr =
StringCchCatW(imagePath, MAX_PATH, path.c_str());
if (SUCCEEDED(hr)) {
ComPtr<IXml
NodeList>
nodeList;
HRESULT hr = xml->GetElementsByTagName(W
inToast
StringWrapper(L"image").Get(), &
nodeList);
if (SUCCEEDED(hr)) {
ComPtr<IXml
Node>
node;
hr =
nodeList->Item(0, &
node);
ComPtr<IXmlElement> imageElement;
HRESULT hrImage =
node.As(&imageElement);
if (SUCCEEDED(hr) && SUCCEEDED(hrImage) && isToastGeneric) {
hr = imageElement->SetAttribute(W
inToast
StringWrapper(L"placement").Get(), W
inToast
StringWrapper(L"appLogoOverride").Get());
if (SUCCEEDED(hr) && isCropH
intCircle) {
hr = imageElement->SetAttribute(W
inToast
StringWrapper(L"h
int-crop").Get(), W
inToast
StringWrapper(L"circle").Get());
}
}
if (SUCCEEDED(hr)) {
ComPtr<IXmlNamed
NodeMap> attributes;
hr =
node->get_Attributes(&attributes);
if (SUCCEEDED(hr)) {
ComPtr<IXml
Node> edited
Node;
hr = attributes->GetNamedItem(W
inToast
StringWrapper(L"src").Get(), &edited
Node);
if (SUCCEEDED(hr)) {
Util
::set
Node
StringValue(imagePath, edited
Node.Get(), xml);
}
}
}
}
}
return hr;
}
HRESULT W
inToast
::setAudioFieldHelper(_
In_ IXml
Document* xml, _
In_ std
::w
string const& path,
_
In_opt_ W
inToast
Template::AudioOption option) {
std
::vector<std
::w
string> attrs;
if (!path.empty()) {
attrs.push_back(L"src");
}
if (option == W
inToast
Template::AudioOption
::Loop) {
attrs.push_back(L"loop");
}
if (option == W
inToast
Template::AudioOption
::Silent) {
attrs.push_back(L"silent");
}
Util
::createElement(xml, L"toast", L"audio", attrs);
ComPtr<IXml
NodeList>
nodeList;
HRESULT hr = xml->GetElementsByTagName(W
inToast
StringWrapper(L"audio").Get(), &
nodeList);
if (SUCCEEDED(hr)) {
ComPtr<IXml
Node>
node;
hr =
nodeList->Item(0, &
node);
if (SUCCEEDED(hr)) {
ComPtr<IXmlNamed
NodeMap> attributes;
hr =
node->get_Attributes(&attributes);
if (SUCCEEDED(hr)) {
ComPtr<IXml
Node> edited
Node;
if (!path.empty()) {
if (SUCCEEDED(hr)) {
hr = attributes->GetNamedItem(W
inToast
StringWrapper(L"src").Get(), &edited
Node);
if (SUCCEEDED(hr)) {
hr = Util
::set
Node
StringValue(path, edited
Node.Get(), xml);
}
}
}
if (SUCCEEDED(hr)) {
switch (option) {
case W
inToast
Template::AudioOption
::Loop
:
hr = attributes->GetNamedItem(W
inToast
StringWrapper(L"loop").Get(), &edited
Node);
if (SUCCEEDED(hr)) {
hr = Util
::set
Node
StringValue(L"true", edited
Node.Get(), xml);
}
break;
case W
inToast
Template::AudioOption
::Silent
:
hr = attributes->GetNamedItem(W
inToast
StringWrapper(L"silent").Get(), &edited
Node);
if (SUCCEEDED(hr)) {
hr = Util
::set
Node
StringValue(L"true", edited
Node.Get(), xml);
}
default
:
break;
}
}
}
}
}
return hr;
}
HRESULT W
inToast
::addActionHelper(_
In_ IXml
Document* xml, _
In_ std
::w
string const& content, _
In_ std
::w
string const& arguments) {
ComPtr<IXml
NodeList>
nodeList;
HRESULT hr = xml->GetElementsByTagName(W
inToast
StringWrapper(L"actions").Get(), &
nodeList);
if (SUCCEEDED(hr)) {
U
INT32 length;
hr =
nodeList->get_Length(&length);
if (SUCCEEDED(hr)) {
ComPtr<IXml
Node> actions
Node;
if (length > 0) {
hr =
nodeList->Item(0, &actions
Node);
} else {
hr = xml->GetElementsByTagName(W
inToast
StringWrapper(L"toast").Get(), &
nodeList);
if (SUCCEEDED(hr)) {
hr =
nodeList->get_Length(&length);
if (SUCCEEDED(hr)) {
ComPtr<IXml
Node> toast
Node;
hr =
nodeList->Item(0, &toast
Node);
if (SUCCEEDED(hr)) {
ComPtr<IXmlElement> toastElement;
hr = toast
Node.As(&toastElement);
if (SUCCEEDED(hr)) {
hr = toastElement->SetAttribute(W
inToast
StringWrapper(L"
template").Get(),
W
inToast
StringWrapper(L"ToastGeneric").Get());
}
if (SUCCEEDED(hr)) {
hr = toastElement->SetAttribute(W
inToast
StringWrapper(L"duration").Get(),
W
inToast
StringWrapper(L"long").Get());
}
if (SUCCEEDED(hr)) {
ComPtr<IXmlElement> actionsElement;
hr = xml->CreateElement(W
inToast
StringWrapper(L"actions").Get(), &actionsElement);
if (SUCCEEDED(hr)) {
hr = actionsElement.As(&actions
Node);
if (SUCCEEDED(hr)) {
ComPtr<IXml
Node> appendedChild;
hr = toast
Node->AppendChild(actions
Node.Get(), &appendedChild);
}
}
}
}
}
}
}
if (SUCCEEDED(hr)) {
ComPtr<IXmlElement> actionElement;
hr = xml->CreateElement(W
inToast
StringWrapper(L"action").Get(), &actionElement);
if (SUCCEEDED(hr)) {
hr = actionElement->SetAttribute(W
inToast
StringWrapper(L"content").Get(), W
inToast
StringWrapper(content).Get());
}
if (SUCCEEDED(hr)) {
hr = actionElement->SetAttribute(W
inToast
StringWrapper(L"arguments").Get(), W
inToast
StringWrapper(arguments).Get());
}
if (SUCCEEDED(hr)) {
ComPtr<IXml
Node> action
Node;
hr = actionElement.As(&action
Node);
if (SUCCEEDED(hr)) {
ComPtr<IXml
Node> appendedChild;
hr = actions
Node->AppendChild(action
Node.Get(), &appendedChild);
}
}
}
}
}
return hr;
}
HRESULT W
inToast
::setHeroImageHelper(_
In_ IXml
Document* xml, _
In_ std
::w
string const& path, _
In_ bool is
Inl
ineImage) {
ComPtr<IXml
NodeList>
nodeList;
HRESULT hr = xml->GetElementsByTagName(W
inToast
StringWrapper(L"b
ind
ing").Get(), &
nodeList);
if (SUCCEEDED(hr)) {
U
INT32 length;
hr =
nodeList->get_Length(&length);
if (SUCCEEDED(hr)) {
ComPtr<IXml
Node> b
ind
ing
Node;
if (length > 0) {
hr =
nodeList->Item(0, &b
ind
ing
Node);
}
if (SUCCEEDED(hr)) {
ComPtr<IXmlElement> imageElement;
hr = xml->CreateElement(W
inToast
StringWrapper(L"image").Get(), &imageElement);
if (SUCCEEDED(hr) && is
Inl
ineImage == false) {
hr = imageElement->SetAttribute(W
inToast
StringWrapper(L"placement").Get(), W
inToast
StringWrapper(L"hero").Get());
}
if (SUCCEEDED(hr)) {
hr = imageElement->SetAttribute(W
inToast
StringWrapper(L"src").Get(), W
inToast
StringWrapper(path).Get());
}
if (SUCCEEDED(hr)) {
ComPtr<IXml
Node> action
Node;
hr = imageElement.As(&action
Node);
if (SUCCEEDED(hr)) {
ComPtr<IXml
Node> appendedChild;
hr = b
ind
ing
Node->AppendChild(action
Node.Get(), &appendedChild);
}
}
}
}
}
return hr;
}
void W
inToast
::setError(_Out_opt_ W
inToastError* error, _
In_ W
inToastError value) {
if (error) {
*error = value;
}
}
W
inToast
Template::W
inToast
Template(_
In_ W
inToast
TemplateType type)
: _type(type) {
constexpr static std
::size_t TextFieldsCount[] = {1, 2, 2, 3, 1, 2, 2, 3};
_textFields = std
::vector<std
::w
string>(TextFieldsCount[type], L"");
}
W
inToast
Template::~W
inToast
Template() {
_textFields.clear();
}
void W
inToast
Template::setTextField(_
In_ std
::w
string const& txt, _
In_ W
inToast
Template::TextField pos) {
auto const position = static_cast<std
::size_t>(pos);
if (position >= _textFields.size()) {
DEBUG_MSG("The selected
template type supports only " << _textFields.size() << " text l
ines");
return;
}
_textFields[position] = txt;
}
void W
inToast
Template::setImagePath(_
In_ std
::w
string const& imgPath, _
In_ CropH
int cropH
int) {
_imagePath = imgPath;
_cropH
int = cropH
int;
}
void W
inToast
Template::setHeroImagePath(_
In_ std
::w
string const& imgPath, _
In_ bool
inl
ineImage) {
_heroImagePath = imgPath;
_
inl
ineHeroImage =
inl
ineImage;
}
void W
inToast
Template::setAudioPath(_
In_ std
::w
string const& audioPath) {
_audioPath = audioPath;
}
void W
inToast
Template::setAudioPath(_
In_ AudioSystemFile file) {
static std
::u
nordered_map<AudioSystemFile, std
::w
string> const Files = {
{AudioSystemFile
::DefaultSound, L"ms-w
insoundevent
:Notification.Default" },
{AudioSystemFile
::IM, L"ms-w
insoundevent
:Notification.IM" },
{AudioSystemFile
::Mail, L"ms-w
insoundevent
:Notification.Mail" },
{AudioSystemFile
::Rem
inder, L"ms-w
insoundevent
:Notification.Rem
inder" },
{AudioSystemFile
::SMS, L"ms-w
insoundevent
:Notification.SMS" },
{AudioSystemFile
::Alarm, L"ms-w
insoundevent
:Notification.Loop
ing.Alarm" },
{AudioSystemFile
::Alarm2, L"ms-w
insoundevent
:Notification.Loop
ing.Alarm2" },
{AudioSystemFile
::Alarm3, L"ms-w
insoundevent
:Notification.Loop
ing.Alarm3" },
{AudioSystemFile
::Alarm4, L"ms-w
insoundevent
:Notification.Loop
ing.Alarm4" },
{AudioSystemFile
::Alarm5, L"ms-w
insoundevent
:Notification.Loop
ing.Alarm5" },
{AudioSystemFile
::Alarm6, L"ms-w
insoundevent
:Notification.Loop
ing.Alarm6" },
{AudioSystemFile
::Alarm7, L"ms-w
insoundevent
:Notification.Loop
ing.Alarm7" },
{AudioSystemFile
::Alarm8, L"ms-w
insoundevent
:Notification.Loop
ing.Alarm8" },
{AudioSystemFile
::Alarm9, L"ms-w
insoundevent
:Notification.Loop
ing.Alarm9" },
{AudioSystemFile
::Alarm10, L"ms-w
insoundevent
:Notification.Loop
ing.Alarm10"},
{AudioSystemFile
::Call, L"ms-w
insoundevent
:Notification.Loop
ing.Call" },
{AudioSystemFile
::Call1, L"ms-w
insoundevent
:Notification.Loop
ing.Call1" },
{AudioSystemFile
::Call2, L"ms-w
insoundevent
:Notification.Loop
ing.Call2" },
{AudioSystemFile
::Call3, L"ms-w
insoundevent
:Notification.Loop
ing.Call3" },
{AudioSystemFile
::Call4, L"ms-w
insoundevent
:Notification.Loop
ing.Call4" },
{AudioSystemFile
::Call5, L"ms-w
insoundevent
:Notification.Loop
ing.Call5" },
{AudioSystemFile
::Call6, L"ms-w
insoundevent
:Notification.Loop
ing.Call6" },
{AudioSystemFile
::Call7, L"ms-w
insoundevent
:Notification.Loop
ing.Call7" },
{AudioSystemFile
::Call8, L"ms-w
insoundevent
:Notification.Loop
ing.Call8" },
{AudioSystemFile
::Call9, L"ms-w
insoundevent
:Notification.Loop
ing.Call9" },
{AudioSystemFile
::Call10, L"ms-w
insoundevent
:Notification.Loop
ing.Call10" },
};
auto const iter = Files.f
ind(file);
assert(iter != Files.end());
_audioPath = iter->second;
}
void W
inToast
Template::setAudioOption(_
In_ W
inToast
Template::AudioOption audioOption) {
_audioOption = audioOption;
}
void W
inToast
Template::setFirstL
ine(_
In_ std
::w
string const& text) {
setTextField(text, W
inToast
Template::FirstL
ine);
}
void W
inToast
Template::setSecondL
ine(_
In_ std
::w
string const& text) {
setTextField(text, W
inToast
Template::SecondL
ine);
}
void W
inToast
Template::setThirdL
ine(_
In_ std
::w
string const& text) {
setTextField(text, W
inToast
Template::ThirdL
ine);
}
void W
inToast
Template::setDuration(_
In_ Duration duration) {
_duration = duration;
}
void W
inToast
Template::setExpiration(_
In_
INT64 millisecondsFrom
Now) {
_expiration = millisecondsFrom
Now;
}
void W
inToastLib
::W
inToast
Template::setScenario(_
In_ Scenario scenario) {
switch (scenario) {
case Scenario
::Default
:
_scenario = L"Default";
break;
case Scenario
::Alarm
:
_scenario = L"Alarm";
break;
case Scenario
::Incom
ingCall
:
_scenario = L"
Incom
ingCall";
break;
case Scenario
::Rem
inder
:
_scenario = L"Rem
inder";
break;
}
}
void W
inToast
Template::setAttributionText(_
In_ std
::w
string const& attributionText) {
_attributionText = attributionText;
}
void W
inToast
Template::addAction(_
In_ std
::w
string const& label) {
_actions.push_back(label);
}
void W
inToast
Template::add
Input() {
_has
Input = true;
}
std
::size_t W
inToast
Template::textFieldsCount() const {
return _textFields.size();
}
std
::size_t W
inToast
Template::actionsCount() const {
return _actions.size();
}
bool W
inToast
Template::hasImage() const {
return _type < W
inToast
TemplateType
::Text01;
}
bool W
inToast
Template::hasHeroImage() const {
return hasImage() && !_heroImagePath.empty();
}
std
::vector<std
::w
string> const& W
inToast
Template::textFields() const {
return _textFields;
}
std
::w
string const& W
inToast
Template::textField(_
In_ TextField pos) const {
auto const position = static_cast<std
::size_t>(pos);
assert(position < _textFields.size());
return _textFields[position];
}
std
::w
string const& W
inToast
Template::actionLabel(_
In_ std
::size_t position) const {
assert(position < _actions.size());
return _actions[position];
}
std
::w
string const& W
inToast
Template::imagePath() const {
return _imagePath;
}
std
::w
string const& W
inToast
Template::heroImagePath() const {
return _heroImagePath;
}
std
::w
string const& W
inToast
Template::audioPath() const {
return _audioPath;
}
std
::w
string const& W
inToast
Template::attributionText() const {
return _attributionText;
}
std
::w
string const& W
inToastLib
::W
inToast
Template::scenario() const {
return _scenario;
}
INT64 W
inToast
Template::expiration() const {
return _expiration;
}
W
inToast
Template::W
inToast
TemplateType W
inToast
Template::type() const {
return _type;
}
W
inToast
Template::AudioOption W
inToast
Template::audioOption() const {
return _audioOption;
}
W
inToast
Template::Duration W
inToast
Template::duration() const {
return _duration;
}
bool W
inToast
Template::isToastGeneric() const {
return hasHeroImage() || _cropH
int == W
inToast
Template::Circle;
}
bool W
inToast
Template::is
Inl
ineHeroImage() const {
return _
inl
ineHeroImage;
}
bool W
inToast
Template::isCropH
intCircle() const {
return _cropH
int == CropH
int
::Circle;
}
bool W
inToast
Template::is
Input() const {
return _has
Input;
}
基于上述源码，新增锁屏时系统弹窗不显示在锁屏之上逻辑
本文详细介绍了如何解决在使用文档模板时出现的错误，即模板名称未在字符串表中添加的问题。通过查看默认模板内容并进行相应修改，可以消除警告并顺利编译。
扫一扫
1168
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
