timamsk/App-Installer-For-Windows-8.x-Reset
1
0
Fork 0
mirror of https://github.com/modernw/App-Installer-For-Windows-8.x-Reset.git synced 2026-04-11 17:57:19 +10:00
Code Issues Packages Projects Releases Wiki Activity
Files
87efdc39df071162c7d26c2890baa861e720b30c
App-Installer-For-Windows-8…/notice/notice.cpp
Bruce 87efdc39df Update Shell and Fix Bugs
2025-11-28 16:47:12 +08:00

715 lines
26 KiB
C++
Raw Blame History

// pkgmgr.cpp : 定义 DLL 应用程序的导出函数。
//
#include "stdafx.h"
#include "notice.h"
#include "raii.h"
#include "version.h"
#include "nstring.h"
#ifdef GetFullPathName
#undef GetFullPathName
#endif
#ifdef min
#undef min
#endif
#ifdef max
#undef max
#endif
std::wstring GetFullPathName (const std::wstring &lpFileName)
{
if (lpFileName.empty ()) return L"";
DWORD length = GetFullPathNameW (lpFileName.c_str (), 0, nullptr, nullptr);
if (length == 0) return L"";
std::vector <WCHAR> buffer (length + 1, L'\0');
DWORD result = GetFullPathNameW (lpFileName.c_str (), length, buffer.data (), nullptr);
if (result == 0) return L"";
return std::wstring (buffer.data (), result);
}
LPWSTR AllocWideString (const std::wstring &str)
{
size_t size = (str.length () + 1) * sizeof (WCHAR);
LPWSTR buf = (LPWSTR)CoTaskMemAlloc (size);
if (!buf) return nullptr;
ZeroMemory (buf, size);
wcscpy (buf, str.c_str ());
return buf;
}
// 测试用
LPWSTR AllocWideString (LPCWSTR str)
{
if (!str) return nullptr;
size_t size = (wcslen (str) + 1) * sizeof (WCHAR);
LPWSTR buf = (LPWSTR)CoTaskMemAlloc (size);
if (!buf) return nullptr;
ZeroMemory (buf, size);
wcscpy (buf, str);
return buf;
}
#define _wcsdup AllocWideString
#define free CoTaskMemFree
#define malloc CoTaskMemAlloc
#define realloc CoTaskMemRealloc
#define calloc(_cnt_, _size_) CoTaskMemAlloc (_cnt_ * _size_)
struct destruct
{
std::function <void ()> endtask = nullptr;
destruct (std::function <void ()> pfunc): endtask (pfunc) {}
~destruct () { if (endtask) endtask (); }
};
static std::wstring StringToWString (const std::string &str, UINT codePage = CP_ACP)
{
if (str.empty ()) return std::wstring ();
int len = MultiByteToWideChar (codePage, 0, str.c_str (), -1, nullptr, 0);
if (len == 0) return std::wstring ();
std::wstring wstr (len - 1, L'\0');
MultiByteToWideChar (codePage, 0, str.c_str (), -1, &wstr [0], len);
return wstr;
}
Windows::Data::Xml::Dom::XmlDocument ^TemplateToastNoticeXml (const std::wstring &lpTemplateName)
{
std::wnstring temp = lpTemplateName;
try
{
using toastttype = Windows::UI::Notifications::ToastTemplateType;
auto tttype = Windows::UI::Notifications::ToastTemplateType::ToastImageAndText01;
if (temp.equals (L"ToastText01")) tttype = toastttype::ToastText01;
else if (temp.equals (L"ToastText02")) tttype = toastttype::ToastText02;
else if (temp.equals (L"ToastText03")) tttype = toastttype::ToastText03;
else if (temp.equals (L"ToastText04")) tttype = toastttype::ToastText04;
else if (temp.equals (L"ToastImageAndText01")) tttype = toastttype::ToastImageAndText01;
else if (temp.equals (L"ToastImageAndText02")) tttype = toastttype::ToastImageAndText02;
else if (temp.equals (L"ToastImageAndText03")) tttype = toastttype::ToastImageAndText03;
else if (temp.equals (L"ToastImageAndText04")) tttype = toastttype::ToastImageAndText04;
else tttype = (toastttype)-1;
if ((INT16)tttype > 0)
{
auto tt = Windows::UI::Notifications::ToastNotificationManager::GetTemplateContent (tttype);
if (tt) return tt;
}
}
catch (...) {}
auto xmldoc = ref new Windows::Data::Xml::Dom::XmlDocument ();
auto root = xmldoc->CreateElement ("toast");
xmldoc->AppendChild (root);
auto visual = xmldoc->CreateElement ("visual");
root->AppendChild (visual);
auto binding = xmldoc->CreateElement ("binding");
visual->AppendChild (binding);
if (temp.equals (L"ToastText01"))
{
binding->SetAttribute ("template", "ToastText01");
auto text1 = xmldoc->CreateElement ("text");
text1->SetAttribute ("id", "1");
binding->AppendChild (text1);
}
else if (temp.equals (L"ToastText02"))
{
binding->SetAttribute ("template", "ToastText02");
auto text1 = xmldoc->CreateElement ("text");
text1->SetAttribute ("id", "1");
auto text2 = xmldoc->CreateElement ("text");
text2->SetAttribute ("id", "2");
binding->AppendChild (text1);
binding->AppendChild (text2);
}
else if (temp.equals (L"ToastText03"))
{
binding->SetAttribute ("template", "ToastText03");
auto text1 = xmldoc->CreateElement ("text");
text1->SetAttribute ("id", "1");
auto text2 = xmldoc->CreateElement ("text");
text2->SetAttribute ("id", "2");
binding->AppendChild (text1);
binding->AppendChild (text2);
}
else if (temp.equals (L"ToastText04"))
{
binding->SetAttribute ("template", "ToastText04");
auto text1 = xmldoc->CreateElement ("text");
text1->SetAttribute ("id", "1");
auto text2 = xmldoc->CreateElement ("text");
text2->SetAttribute ("id", "2");
auto text3 = xmldoc->CreateElement ("text");
text3->SetAttribute ("id", "3");
binding->AppendChild (text1);
binding->AppendChild (text2);
binding->AppendChild (text3);
}
else if (temp.equals (L"ToastImageAndText01"))
{
binding->SetAttribute ("template", "ToastImageAndText01");
auto text1 = xmldoc->CreateElement ("text");
text1->SetAttribute ("id", "1");
auto img1 = xmldoc->CreateElement ("image");
img1->SetAttribute ("id", "1");
img1->SetAttribute ("src", "");
img1->SetAttribute ("alt", "");
binding->AppendChild (img1);
binding->AppendChild (text1);
}
else if (temp.equals (L"ToastImageAndText02"))
{
binding->SetAttribute ("template", "ToastImageAndText02");
auto text1 = xmldoc->CreateElement ("text");
text1->SetAttribute ("id", "1");
auto img1 = xmldoc->CreateElement ("image");
img1->SetAttribute ("id", "1");
img1->SetAttribute ("src", "");
img1->SetAttribute ("alt", "");
binding->AppendChild (img1);
binding->AppendChild (text1);
}
else if (temp.equals (L"ToastImageAndText03"))
{
binding->SetAttribute ("template", "ToastImageAndText03");
auto text1 = xmldoc->CreateElement ("text");
text1->SetAttribute ("id", "1");
auto text2 = xmldoc->CreateElement ("text");
text2->SetAttribute ("id", "2");
auto img1 = xmldoc->CreateElement ("image");
img1->SetAttribute ("id", "1");
img1->SetAttribute ("src", "");
img1->SetAttribute ("alt", "");
binding->AppendChild (img1);
binding->AppendChild (text1);
binding->AppendChild (text2);
}
else if (temp.equals (L"ToastImageAndText04"))
{
binding->SetAttribute ("template", "ToastImageAndText04");
auto text1 = xmldoc->CreateElement ("text");
text1->SetAttribute ("id", "1");
auto text2 = xmldoc->CreateElement ("text");
text2->SetAttribute ("id", "2");
auto text3 = xmldoc->CreateElement ("text");
text3->SetAttribute ("id", "3");
auto img1 = xmldoc->CreateElement ("image");
img1->SetAttribute ("id", "1");
img1->SetAttribute ("src", "");
img1->SetAttribute ("alt", "");
binding->AppendChild (img1);
binding->AppendChild (text1);
binding->AppendChild (text2);
binding->AppendChild (text3);
}
else
{
binding->SetAttribute ("template", "ToastImageAndText04");
auto text1 = xmldoc->CreateElement ("text");
binding->AppendChild (text1);
}
return xmldoc;
}
LPWSTR GetToastNoticeXml (LPCWSTR lpTemplateName)
{
auto xmldoc = TemplateToastNoticeXml (lpTemplateName);
return _wcsdup (xmldoc->GetXml ()->Data ());
}
Windows::Data::Xml::Dom::XmlDocument ^SimpleToastNoticeXml (const std::wstring &lpText, const std::wstring &lpImgPath = L"")
{
Windows::Data::Xml::Dom::XmlDocument ^xmldoc = nullptr;
std::wnstring img = lpImgPath;
std::wstring text = std::wnstring::trim (std::wstring (lpText));
{
// std::wstring xmltemplate = L"<toast><visual><binding template='ToastGeneric'><text></text></binding></visual></toast>";
xmldoc = TemplateToastNoticeXml (img.empty () ? L"ToastText01" : L"ToastImageAndText01");
}
Windows::Foundation::Uri ^imguri = nullptr;
try { imguri = ref new Windows::Foundation::Uri (ref new Platform::String (img.c_str ())); }
catch (...)
{
try
{
std::wstring fullpath = GetFullPathName (lpImgPath);
if (fullpath.empty ()) fullpath = lpImgPath;
imguri = ref new Windows::Foundation::Uri (ref new Platform::String (img.c_str ()));
}
catch (...) { imguri = nullptr; }
}
auto toast = xmldoc->FirstChild;
auto visual = toast->FirstChild;
auto binding = visual->FirstChild;
auto binds = binding->ChildNodes;
auto textNodes = binding->SelectNodes (ref new Platform::String (L"text"));
if (textNodes && textNodes->Length > 0)
{
auto node = dynamic_cast <Windows::Data::Xml::Dom::XmlElement ^> (textNodes->Item (0));
if (node) node->InnerText = ref new Platform::String (text.c_str ());
}
auto imageNodes = binding->SelectNodes (ref new Platform::String (L"image"));
if (imageNodes && imageNodes->Length > 0 && !img.empty ())
{
auto node = dynamic_cast <Windows::Data::Xml::Dom::XmlElement ^> (imageNodes->Item (0));
if (node)
{
node->SetAttribute (L"src", ref new Platform::String (imguri && imguri->DisplayUri ? imguri->DisplayUri->Data () : img.c_str ()));
node->SetAttribute (L"alt", ref new Platform::String (L"image"));
}
}
return xmldoc;
}
LPWSTR GenerateSimpleToastNoticeXml (LPCWSTR lpText, LPCWSTR lpImagePath)
{
auto xmldoc = SimpleToastNoticeXml (lpText ? lpText : L"", lpImagePath ? lpImagePath : L"");
return _wcsdup (xmldoc->GetXml ()->Data ());
}
Windows::Data::Xml::Dom::XmlDocument ^SimpleToastNoticeXml2 (const std::wstring &lpTitle, const std::wstring &lpText = L"", const std::wstring &lpImagePath = L"")
{
Windows::Data::Xml::Dom::XmlDocument ^xmldoc = nullptr;
std::wnstring img = lpImagePath;
std::wstring title = std::wnstring (lpTitle).trim ();
std::wstring text = std::wnstring (lpText).trim ();
{
// std::wstring xmltemplate = L"<toast><visual><binding template='ToastGeneric'><text></text></binding></visual></toast>";
std::wstring templatename = L"";
WORD flag = (bool)(!img.empty ()) << 2 | (bool)title.size () << 1 | (bool)text.size ();
switch (flag)
{
case 1: templatename = L"ToastText01"; break; // 仅正文
case 3: templatename = L"ToastText02"; break; // 标题 + 正文
case 6:
case 5: templatename = L"ToastImageAndText01"; break; // 图 + 正文
case 7: templatename = L"ToastImageAndText02"; break; // 图 + 标题 + 正文
default: templatename = L"ToastText01"; break;
}
xmldoc = TemplateToastNoticeXml (templatename);
}
Windows::Foundation::Uri ^imguri = nullptr;
try { imguri = ref new Windows::Foundation::Uri (ref new Platform::String (img.c_str ())); }
catch (...)
{
try
{
std::wstring fullpath = GetFullPathName (lpImagePath);
if (fullpath.empty ()) fullpath = lpImagePath;
imguri = ref new Windows::Foundation::Uri (ref new Platform::String (img.c_str ()));
}
catch (...) { imguri = nullptr; }
}
auto binding = xmldoc->SelectSingleNode (ref new Platform::String (L"/toast/visual/binding"));
auto textNodes = binding->SelectNodes (ref new Platform::String (L"text"));
if (textNodes && textNodes->Length > 0)
{
unsigned int idx = 0;
if (!title.empty ())
{
auto node = dynamic_cast <Windows::Data::Xml::Dom::XmlElement ^> (textNodes->Item (idx++));
if (node) node->InnerText = ref new Platform::String (title.c_str ());
}
if (!text.empty () && idx < textNodes->Length)
{
auto node = dynamic_cast <Windows::Data::Xml::Dom::XmlElement ^> (textNodes->Item (idx));
if (node) node->InnerText = ref new Platform::String (text.c_str ());
}
else if (!text.empty () && title.empty ())
{
auto node = dynamic_cast <Windows::Data::Xml::Dom::XmlElement ^> (textNodes->Item (0));
if (node) node->InnerText = ref new Platform::String (text.c_str ());
}
}
auto imageNodes = binding->SelectNodes (ref new Platform::String (L"image"));
if (imageNodes && imageNodes->Length > 0 && !img.empty ())
{
auto node = dynamic_cast <Windows::Data::Xml::Dom::XmlElement ^> (imageNodes->Item (0));
if (node)
{
node->SetAttribute (L"src", ref new Platform::String (imguri && imguri->DisplayUri ? imguri->DisplayUri->Data () : img.c_str ()));
node->SetAttribute (L"alt", ref new Platform::String (L"image"));
}
}
return xmldoc;
}
LPWSTR GenerateSimpleToastNoticeXml2 (LPCWSTR lpTitle, LPCWSTR lpText, LPCWSTR lpImagePath)
{
auto xmldoc = SimpleToastNoticeXml2 (lpTitle ? lpTitle : L"", lpText ? lpText : L"", lpImagePath ? lpImagePath : L"");
return _wcsdup (xmldoc->GetXml ()->Data ());
}
// 会实时记录 hResult;
HRESULT g_lasthr = S_OK;
// 记录上一次异常（不会根据操作更新）的信息
std::wstring g_lastexc = L"";
#define catch_lasterr(_PHRESULT_Outptr_lphResult_, _HLPWSTR_Outptr_lpExcepMsg_) \
catch (Platform::Exception ^e) \
{ \
g_lastexc = e->ToString ()->Data (); \
if (_HLPWSTR_Outptr_lpExcepMsg_) *(_HLPWSTR_Outptr_lpExcepMsg_) = _wcsdup (g_lastexc.c_str ()); \
g_lasthr = SUCCEEDED ((HRESULT)e->HResult) ? E_FAIL : (HRESULT)e->HResult; \
if (_PHRESULT_Outptr_lphResult_) *(_PHRESULT_Outptr_lphResult_) = g_lasthr; \
} \
catch (const std::exception &e) \
{ \
g_lastexc = StringToWString (e.what () ? e.what () : "Unknown exception."); \
if (_HLPWSTR_Outptr_lpExcepMsg_) *(_HLPWSTR_Outptr_lpExcepMsg_) = _wcsdup (g_lastexc.c_str ()); \
g_lasthr = E_FAIL; \
if (_PHRESULT_Outptr_lphResult_) *(_PHRESULT_Outptr_lphResult_) = g_lasthr; \
} \
catch (...) \
{ \
g_lastexc = L"Unknown exception"; \
if (_HLPWSTR_Outptr_lpExcepMsg_) *(_HLPWSTR_Outptr_lpExcepMsg_) = _wcsdup (g_lastexc.c_str ()); \
g_lasthr = E_FAIL; \
if (_PHRESULT_Outptr_lphResult_) *(_PHRESULT_Outptr_lphResult_) = g_lasthr; \
}
HRESULT CreateToastNoticeFromXml (const std::wstring &lpIdName, Windows::Data::Xml::Dom::XmlDocument ^pIXml, NOTICE_ACTIVECALLBACK pfCallback = nullptr, void *pCustom = nullptr, LPWSTR *lpExceptMsg = nullptr)
{
using XmlDoc = Windows::Data::Xml::Dom::XmlDocument;
using ToastNotification = Windows::UI::Notifications::ToastNotification;
using Toast = ToastNotification;
using ToastMgr = Windows::UI::Notifications::ToastNotificationManager;
using String = Platform::String;
using Object = Platform::Object;
auto &hr = g_lasthr;
if (lpExceptMsg) *lpExceptMsg = nullptr;
try
{
Windows::UI::Notifications::ToastNotifier ^notifier = nullptr;
if (!std::wnstring (lpIdName).empty ()) notifier = ToastMgr::CreateToastNotifier (ref new String (lpIdName.c_str ()));
else notifier = ToastMgr::CreateToastNotifier ();
auto &xmldoc = pIXml;
auto toast = ref new Toast (xmldoc);
//toast->Activated += ref new Windows::Foundation::TypedEventHandler <
// Windows::UI::Notifications::ToastNotification ^,
// Platform::Object ^
//> ([=] (Windows::UI::Notifications::ToastNotification ^sender, Platform::Object ^args) {
// if (pfCallback) pfCallback (pCustom);
//});
notifier->Show (toast);
return hr = S_OK;
}
catch_lasterr (&hr, lpExceptMsg);
return hr;
}
HRESULT CreateToastNoticeFromXml (const std::wstring &lpIdName, const std::wstring &lpXmlString, NOTICE_ACTIVECALLBACK pfCallback = nullptr, void *pCustom = nullptr, LPWSTR *lpExceptMsg = nullptr)
{
using XmlDoc = Windows::Data::Xml::Dom::XmlDocument;
using String = Platform::String;
using Object = Platform::Object;
if (lpExceptMsg) *lpExceptMsg = nullptr;
auto &hr = g_lasthr;
try
{
auto xmldoc = ref new XmlDoc ();
xmldoc->LoadXml (ref new String (lpXmlString.c_str ()));
return hr = CreateToastNoticeFromXml (lpIdName, xmldoc, pfCallback, pCustom, lpExceptMsg);
}
catch_lasterr (&hr, lpExceptMsg);
return hr;
}
HRESULT CreateToastNoticeFromXmlDocument (LPCWSTR lpIdName, LPCWSTR lpXmlString, NOTICE_ACTIVECALLBACK pfCallback, void *pCustom, LPWSTR *lpExceptMsg)
{
return CreateToastNoticeFromXml (lpIdName ? lpIdName : L"", lpXmlString ? lpXmlString : L"", pfCallback, pCustom, lpExceptMsg);
}
HRESULT CreateToastNotice2 (LPCWSTR lpIdName, LPCWSTR lpTitle, LPCWSTR lpText, LPCWSTR lpImgPath, NOTICE_ACTIVECALLBACK pfCallback, void *pCustom, LPWSTR *lpExceptMsg)
{
auto &hr = g_lasthr;
try
{
auto xmldoc = SimpleToastNoticeXml2 (lpTitle ? lpTitle : L"", lpText ? lpText : L"", lpImgPath ? lpImgPath : L"");
return hr = CreateToastNoticeFromXml (lpIdName, xmldoc, pfCallback, pCustom, lpExceptMsg);
}
catch_lasterr (&hr, lpExceptMsg);
return hr;
}
HRESULT CreateToastNotice (LPCWSTR lpIdName, LPCWSTR lpText, LPCWSTR lpImgPath, NOTICE_ACTIVECALLBACK pfCallback, void *pCustom, LPWSTR *lpExceptMsg)
{
return CreateToastNotice2 (lpIdName, lpText, nullptr, lpImgPath, pfCallback, pCustom, lpExceptMsg);
}
std::wstring GetRandomText (size_t length = 16, const std::wstring &charset = L"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ")
{
if (charset.empty ()) return L"";
static bool seeded = false;
if (!seeded)
{
std::srand ((unsigned int)(std::time (nullptr) ^ (uintptr_t)&seeded));
seeded = true;
}
std::wstring ret;
ret.reserve (length);
for (size_t i = 0; i < length; ++i)
{
size_t index = (size_t)(std::rand () % charset.size ());
ret.push_back (charset [index]);
}
return ret;
}
std::wstring CombinePath (const std::wstring &left, const std::wstring &right)
{
std::vector <WCHAR> buf (left.capacity () + right.capacity () + 2);
PathCombineW (buf.data (), left.c_str (), right.c_str ());
return buf.data ();
}
std::wstring GetRamdomFileName (const std::wstring &directory, const std::wstring &ext = L".tmp", bool retfullpath = true)
{
std::wnstring name = std::wnstring::trim (GetRandomText (3) + L"-" + GetRandomText (5) + L"-" + GetRandomText (3)) + std::wnstring::trim (ext);
std::wnstring path = CombinePath (directory, name);
while (GetFileAttributesW (path.c_str ()) != INVALID_FILE_ATTRIBUTES)
{
name = GetRandomText (3) + L"-" + GetRandomText (5) + L"-" + GetRandomText (3) + ext;
path = CombinePath (directory, name);
}
if (retfullpath) return path;
else return name;
}
std::wstring GetTempDirectory ()
{
std::vector <WCHAR> ret (GetTempPathW (0, nullptr) + 2);
GetTempPathW (ret.size (), ret.data ());
return ret.data ();
}
std::wstring GetRamdomTempFileName (const std::wstring &ext = L".tmp", bool retfullpath = true)
{
return GetRamdomFileName (GetTempDirectory (), ext, retfullpath);
}
std::wstring IStreamToTempFile (IStream *p, const std::wstring &ext = L".tmp")
{
if (!p) throw ref new Platform::InvalidArgumentException ("IStream is nullptr.");
std::wnstring outpath = GetRamdomTempFileName (ext);
auto &stream = p;
STATSTG stat;
HRESULT hr = stream->Stat (&stat, STATFLAG_NONAME);
if (FAILED (hr)) throw Platform::Exception::CreateException (hr);
LARGE_INTEGER liZero = {};
stream->Seek (liZero, STREAM_SEEK_SET, nullptr);
HANDLE hFile = CreateFileW (outpath.c_str (), GENERIC_WRITE, 0, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_TEMPORARY, nullptr);
const size_t bufsize = 4096;
BYTE buf [bufsize] = {0};
ULONG bytesRead = 0;
DWORD bytesWritten = 0;
while (true)
{
hr = stream->Read (buf, bufsize, &bytesRead);
if (FAILED (hr)) { CloseHandle (hFile); throw Platform::Exception::CreateException (hr); }
if (bytesRead == 0) break;
if (!WriteFile (hFile, buf, bytesRead, &bytesWritten, nullptr) || bytesWritten != bytesRead)
{
CloseHandle (hFile);
throw std::runtime_error ("WriteFile failed.");
}
}
CloseHandle (hFile);
return outpath;
}
void DeleteFileThreadSafe (LPWSTR filepath)
{
raii endt ([&] () {
if (filepath) free (filepath);
filepath = nullptr;
});
Sleep (5000);
DeleteFileW (filepath);
}
HRESULT CreateToastNoticeWithIStream2 (LPCWSTR lpIdName, LPCWSTR lpTitle, LPCWSTR lpText, HANDLE pIImgStream, NOTICE_ACTIVECALLBACK pfCallback, void *pCustom, LPWSTR *lpExceptMsg)
{
auto &hr = g_lasthr;
try
{
std::wnstring imgpath = L"";
try
{
if (pIImgStream)
{
IStream *img = (IStream *)pIImgStream;
LARGE_INTEGER li;
li.QuadPart = 0;
img->Seek (li, STREAM_SEEK_SET, nullptr);
STATSTG stat;
hr = img->Stat (&stat, STATFLAG_DEFAULT);
if (SUCCEEDED (hr) && stat.pwcsName)
{
if (stat.pwcsName) imgpath = stat.pwcsName;
CoTaskMemFree (stat.pwcsName);
}
else
{
imgpath = IStreamToTempFile (img, L".jpg");
CreateThread (nullptr, 0, (LPTHREAD_START_ROUTINE)DeleteFileThreadSafe, _wcsdup (imgpath.c_str ()), 0, nullptr);
}
}
Windows::Foundation::Uri ^uri = ref new Windows::Foundation::Uri (ref new Platform::String (imgpath.c_str ()));
}
catch (...) { imgpath = L""; }
return hr = CreateToastNotice2 (lpIdName, lpTitle, lpText, imgpath.c_str (), pfCallback, pCustom, lpExceptMsg);
}
catch_lasterr (&hr, lpExceptMsg);
return hr;
}
HRESULT CreateToastNoticeWithIStream (LPCWSTR lpIdName, LPCWSTR lpText, HANDLE pIImgStream, NOTICE_ACTIVECALLBACK pfCallback, void *pCustom, LPWSTR *lpExceptMsg)
{
return CreateToastNoticeWithIStream2 (lpIdName, lpText, nullptr, pIImgStream, pfCallback, pCustom, lpExceptMsg);
}
HRESULT NoticeGetLastHResult () { return g_lasthr; }
LPCWSTR NoticeGetLastDetailMessage () { return g_lastexc.c_str (); }
HRESULT CreateShortcutWithAppIdW (LPCWSTR pszShortcutPath, LPCWSTR pszTargetPath, LPCWSTR pszAppId, LPWSTR *lpException)
{
HRESULT &hr = g_lasthr;
destruct relt ([&] () {
if (FAILED (hr))
{
if (lpException && !*lpException)
{
_com_error ex (hr);
g_lastexc = ex.ErrorMessage () ? ex.ErrorMessage () : L"";
*lpException = _wcsdup (g_lastexc.c_str ());
}
}
});
if (lpException) *lpException = nullptr;
try
{
hr = CoInitialize (NULL);
if (FAILED (hr)) return hr;
IShellLinkW *pShellLinkW = nullptr;
raii reltask1 ([&] () {
if (pShellLinkW) pShellLinkW->Release ();
pShellLinkW = nullptr;
});
hr = CoCreateInstance (CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLinkW, (void **)&pShellLinkW);
if (FAILED (hr)) return hr;
hr = pShellLinkW->SetPath (pszTargetPath);
if (FAILED (hr)) return hr;
IPropertyStore *pPropStore = nullptr;
raii reltask2 ([&] () {
if (pPropStore) pPropStore->Release ();
pPropStore = nullptr;
});
hr = pShellLinkW->QueryInterface (IID_IPropertyStore, (void **)&pPropStore);
if (SUCCEEDED (hr))
{
PROPVARIANT propvar;
hr = InitPropVariantFromString (pszAppId, &propvar);
if (SUCCEEDED (hr))
{
hr = pPropStore->SetValue (PKEY_AppUserModel_ID, propvar);
if (SUCCEEDED (hr)) hr = pPropStore->Commit ();
PropVariantClear (&propvar);
}
}
else pPropStore = nullptr;
IPersistFile *pPersistFile = nullptr;
raii reltask3 ([&] () {
if (pPersistFile) pPersistFile->Release ();
pPersistFile = nullptr;
});
hr = pShellLinkW->QueryInterface (IID_IPersistFile, (void **)&pPersistFile);
if (SUCCEEDED (hr)) hr = pPersistFile->Save (pszShortcutPath, TRUE);
else pPersistFile = nullptr;
return hr;
}
catch_lasterr (&hr, lpException);
return hr;
}
void NoticeApiFreeString (LPWSTR lpstr)
{
if (!lpstr) return;
CoTaskMemFree (lpstr);
}
size_t Base64ToBytes (const std::wstring &base64OrDataUri, std::vector <BYTE> &retbytes)
{
retbytes.clear ();
std::wstring base64 = base64OrDataUri;
size_t commaPos = base64.find (L',');
if (commaPos != std::wstring::npos) base64 = base64.substr (commaPos + 1);
DWORD binLen = 0;
if (!CryptStringToBinaryW (base64.c_str (), static_cast <DWORD> (base64.length ()), CRYPT_STRING_BASE64, nullptr, &binLen, nullptr, nullptr))
return 0;
retbytes.resize (binLen);
if (!CryptStringToBinaryW (base64.c_str (), static_cast <DWORD> (base64.length ()), CRYPT_STRING_BASE64, retbytes.data (), &binLen, nullptr, nullptr))
{
retbytes.clear ();
return 0; // 解码失败
}
return binLen;
}
HRESULT BytesToIStream (const std::vector <BYTE> &data, IStream **ppStream)
{
if (!ppStream) return E_POINTER;
*ppStream = nullptr;
HGLOBAL hMem = GlobalAlloc (GMEM_MOVEABLE, data.size ());
if (!hMem) return E_OUTOFMEMORY;
void *pMem = GlobalLock (hMem);
if (!pMem)
{
GlobalFree (hMem);
return E_FAIL;
}
memcpy (pMem, data.data (), data.size ());
GlobalUnlock (hMem);
HRESULT hr = CreateStreamOnHGlobal (hMem, TRUE, ppStream);
if (FAILED (hr)) GlobalFree (hMem);
return hr;
}
HRESULT CreateToastNoticeWithImgBase64 (LPCWSTR lpIdName, LPCWSTR lpText, LPCWSTR lpImgBase64, NOTICE_ACTIVECALLBACK pfCallback, void *pCustom, LPWSTR *lpExceptMsg)
{
IStream *ist = nullptr;
destruct relt ([&ist] () {
if (ist) ist->Release ();
ist = nullptr;
});
std::vector <BYTE> bytes;
Base64ToBytes (lpImgBase64 ? lpImgBase64 : L"", bytes);
if (bytes.size ())
{ if (FAILED (BytesToIStream (bytes, &ist))) ist = nullptr; }
return CreateToastNoticeWithIStream (lpIdName, lpText, ist, pfCallback, pCustom, lpExceptMsg);
}
HRESULT CreateToastNotice2WithImgBase64 (LPCWSTR lpIdName, LPCWSTR lpTitle, LPCWSTR lpText, LPCWSTR lpImgBase64, NOTICE_ACTIVECALLBACK pfCallback, void *pCustom, LPWSTR *lpExceptMsg)
{
IStream *ist = nullptr;
destruct relt ([&ist] () {
if (ist) ist->Release ();
ist = nullptr;
});
std::vector <BYTE> bytes;
Base64ToBytes (lpImgBase64 ? lpImgBase64 : L"", bytes);
if (bytes.size ())
{ if (FAILED (BytesToIStream (bytes, &ist))) ist = nullptr; }
return CreateToastNoticeWithIStream2 (lpIdName, lpTitle, lpText, ist, pfCallback, pCustom, lpExceptMsg);
}
HRESULT CreateMessageDialog (const std::wstring &content, const std::wstring &title, LPWSTR *lpException)
{
auto &hr = g_lasthr;
try
{
auto refcon = ref new Platform::String (content.c_str ());
auto reftit = ref new Platform::String (title.c_str ());
Windows::UI::Popups::MessageDialog ^msgdlg = nullptr;
if (IsNormalizeStringEmpty (title)) msgdlg = ref new Windows::UI::Popups::MessageDialog (refcon);
else msgdlg = ref new Windows::UI::Popups::MessageDialog (refcon, reftit);
msgdlg->ShowAsync ();
return S_OK;
}
catch_lasterr (&hr, lpException);
return hr;
}
HRESULT SimpleMessageDialog (LPCWSTR lpContent, LPCWSTR lpTitle, LPWSTR *lpException)
{
auto &hr = g_lasthr;
try
{
return CreateMessageDialog (
lpContent ? lpContent : L"",
lpTitle ? lpTitle : L"",
lpException
);
}
catch_lasterr (&hr, lpException);
return hr;
}
HRESULT CreateTileNoticifation (LPCWSTR lpAppId, LPCWSTR lpXmlDoc, LPWSTR *lpExMsg)
{
auto &hr = g_lasthr;
try
{
auto refcon = ref new Platform::String (lpXmlDoc ? lpXmlDoc : L"");
auto xmldoc = ref new Windows::Data::Xml::Dom::XmlDocument ();
xmldoc->LoadXml (ref new Platform::String (lpXmlDoc ? lpXmlDoc : L""));
auto tile = ref new Windows::UI::Notifications::TileNotification (xmldoc);
auto tilemgr = Windows::UI::Notifications::TileUpdateManager::CreateTileUpdaterForApplication (ref new Platform::String (lpAppId ? lpAppId : L""));
tilemgr->Update (tile);
return S_OK;
}
catch_lasterr (&hr, lpExMsg);
return hr;
}
Reference in New Issue View Git Blame Copy Permalink