hrynco/hrynco-kswitcher
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 41 Wiki Activity

Release v0.6.0: screenshot notifications with previews and responsive clipboard history

Browse Source
This commit is contained in:
Anatolii Hrynchuk
2026-10-29 00:01:04 +02:00
parent ccaa8dad3f
commit dd9629f8fd
19 changed files with 501 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/screenshot_notifications.cpp
+220
View File
@@ -0,0 +1,220 @@
#include "screenshot_notifications.h"
#include "ocr.h"
#include <algorithm>
#include <chrono>
#include <cstdio>
#include <aclapi.h>
#include <sddl.h>
#include <shlobj.h>
#include <propkey.h>
#include <propvarutil.h>
#include <roapi.h>
#include <winstring.h>
#include <wincodec.h>
#ifdef __MINGW32__
// This SDK aliases BYTE and boolean, producing duplicate template specializations.
// Notifications use the boolean specialization; IReference<BYTE> is unused here.
#define ____FIReference_1_BYTE_INTERFACE_DEFINED__
#endif
#include <windows.ui.notifications.h>
#include <windows.data.xml.dom.h>
#include <wrl/client.h>
namespace ks {
namespace {
using Microsoft::WRL::ComPtr;
namespace Notifications=ABI::Windows::UI::Notifications;
namespace Xml=ABI::Windows::Data::Xml::Dom;
constexpr wchar_t AppId[]=L"HrynCo.KSwitcher.Screenshot";
constexpr GUID ActivatorId{0xe3f78047,0xf0ad,0x49b6,{0x90,0x74,0x41,0x19,0x31,0x70,0x61,0x67}};
std::string notificationError;
void check(HRESULT result) { if(FAILED(result)) { char message[100]; snprintf(message,sizeof(message),"Windows screenshot notification failed (0x%08lx)",(unsigned long)result); throw std::runtime_error(message); } }
struct String {
HSTRING value{};
explicit String(const std::wstring &s) { check(WindowsCreateString(s.c_str(),(UINT32)s.size(),&value)); }
~String() { WindowsDeleteString(value); }
};
std::filesystem::path cacheDirectory()
{
PWSTR folder{}; check(SHGetKnownFolderPath(FOLDERID_LocalAppData,0,nullptr,&folder));
auto path=std::filesystem::path(folder)/L"KSwitcher"/L"ScreenshotNotifications";
CoTaskMemFree(folder); std::filesystem::create_directories(path); return path;
}
std::filesystem::path previewDirectory()
{
HANDLE token{};
if(!OpenProcessToken(GetCurrentProcess(),TOKEN_QUERY,&token)) check(HRESULT_FROM_WIN32(GetLastError()));
DWORD size{}; GetTokenInformation(token,TokenUser,nullptr,0,&size);
std::vector<BYTE> data(size);
BOOL read=GetTokenInformation(token,TokenUser,data.data(),size,&size);
DWORD error=read?ERROR_SUCCESS:GetLastError(); CloseHandle(token); check(HRESULT_FROM_WIN32(error));
auto user=reinterpret_cast<TOKEN_USER *>(data.data())->User.Sid;
LPWSTR sidText{}; if(!ConvertSidToStringSidW(user,&sidText)) check(HRESULT_FROM_WIN32(GetLastError()));
std::wstring sid(sidText); LocalFree(sidText);
PWSTR folder{}; check(SHGetKnownFolderPath(FOLDERID_ProgramData,0,nullptr,&folder));
auto path=std::filesystem::path(folder)/(L"KSwitcher.ScreenshotPreviews-"+sid); CoTaskMemFree(folder);
// The notification broker cannot load previews from some profile directories.
// Keep this cache outside the profile, private to the current user and SYSTEM.
auto sddl=L"O:"+sid+L"D:P(A;OICI;FA;;;SY)(A;OICI;FA;;;"+sid+L")";
PSECURITY_DESCRIPTOR security{};
if(!ConvertStringSecurityDescriptorToSecurityDescriptorW(sddl.c_str(),SDDL_REVISION_1,&security,nullptr))
check(HRESULT_FROM_WIN32(GetLastError()));
SECURITY_ATTRIBUTES attributes{sizeof(attributes),security,FALSE};
BOOL created=CreateDirectoryW(path.c_str(),&attributes);
error=created?ERROR_SUCCESS:GetLastError();
LocalFree(security);
if(error!=ERROR_ALREADY_EXISTS) check(HRESULT_FROM_WIN32(error));
// Do not use a pre-created directory or junction controlled by another user.
DWORD flags=GetFileAttributesW(path.c_str());
if(flags==INVALID_FILE_ATTRIBUTES || !(flags&FILE_ATTRIBUTE_DIRECTORY) || (flags&FILE_ATTRIBUTE_REPARSE_POINT))
throw std::runtime_error("Invalid screenshot preview directory");
PSID owner{}; PSECURITY_DESCRIPTOR existing{};
error=GetNamedSecurityInfoW(const_cast<wchar_t *>(path.c_str()),SE_FILE_OBJECT,OWNER_SECURITY_INFORMATION,
&owner,nullptr,nullptr,nullptr,&existing);
check(HRESULT_FROM_WIN32(error));
bool owned=EqualSid(owner,user); LocalFree(existing);
if(!owned) throw std::runtime_error("Screenshot preview directory belongs to another user");
return path;
}
void cleanCache(const std::filesystem::path &path)
{
std::vector<std::filesystem::directory_entry> files;
for(const auto &file:std::filesystem::directory_iterator(path))
if(file.is_regular_file() && validScreenshotToken(file.path().stem().wstring()) &&
(file.path().extension()==L".capture" || file.path().extension()==L".png")) files.push_back(file);
std::sort(files.begin(),files.end(),[](const auto &a,const auto &b){return a.last_write_time()>b.last_write_time();});
uintmax_t size=0;
for(size_t i=0;i<files.size();++i) {
size+=files[i].file_size();
if(i>=40 || size>256*1024*1024 || std::filesystem::file_time_type::clock::now()-files[i].last_write_time()>std::chrono::hours(24)) {
std::error_code ignored; std::filesystem::remove(files[i].path(),ignored);
}
}
}
void registryString(const std::wstring &path,const wchar_t *name,const std::wstring &value)
{
HKEY key{};
if(RegCreateKeyExW(HKEY_CURRENT_USER,path.c_str(),0,nullptr,0,KEY_SET_VALUE,nullptr,&key,nullptr)!=ERROR_SUCCESS)
throw std::runtime_error("Cannot register screenshot notifications");
auto result=RegSetValueExW(key,name,0,REG_SZ,(const BYTE *)value.c_str(),DWORD((value.size()+1)*sizeof(wchar_t)));
RegCloseKey(key);
if(result!=ERROR_SUCCESS) throw std::runtime_error("Cannot register screenshot notification activation");
}
void registerNotifications()
{
auto exe=executable();
registryString(L"Software\\Classes\\CLSID\\{e3f78047-f0ad-49b6-9074-411931706167}\\LocalServer32",nullptr,L"\""+exe+L"\" --toast-activated");
registryString(L"Software\\Classes\\CLSID\\{e3f78047-f0ad-49b6-9074-411931706167}\\LocalServer32",L"ServerExecutable",exe);
auto identity=std::wstring(L"Software\\Classes\\AppUserModelId\\")+AppId;
registryString(identity,L"DisplayName",L"KSwitcher Screenshot");
registryString(identity,L"IconUri",exe);
registryString(identity,L"CustomActivator",L"{e3f78047-f0ad-49b6-9074-411931706167}");
// A shortcut supplies desktop notification identity and its COM activation callback.
ComPtr<IShellLinkW> link; check(CoCreateInstance(CLSID_ShellLink,nullptr,CLSCTX_INPROC_SERVER,IID_PPV_ARGS(&link)));
check(link->SetPath(exe.c_str())); check(link->SetIconLocation(exe.c_str(),0));
ComPtr<IPropertyStore> properties; check(link.As(&properties));
PROPVARIANT id{}; check(InitPropVariantFromString(AppId,&id));
auto result=properties->SetValue(PKEY_AppUserModel_ID,id); PropVariantClear(&id); check(result);
GUID activator=ActivatorId;
PROPVARIANT clsid{}; clsid.vt=VT_CLSID; clsid.puuid=&activator;
check(properties->SetValue(PKEY_AppUserModel_ToastActivatorCLSID,clsid));
check(properties->Commit());
PWSTR programs{}; check(SHGetKnownFolderPath(FOLDERID_Programs,0,nullptr,&programs));
auto shortcut=std::filesystem::path(programs)/L"KSwitcher Screenshot.lnk"; CoTaskMemFree(programs);
ComPtr<IPersistFile> file; check(link.As(&file)); check(file->Save(shortcut.c_str(),TRUE));
// The notification broker caches protocol handlers independently of ShellExecute.
SHChangeNotify(SHCNE_ASSOCCHANGED,SHCNF_IDLIST,nullptr,nullptr);
check(SetCurrentProcessExplicitAppUserModelID(AppId));
}
void savePreview(const Clip &clip,const std::filesystem::path &path)
{
auto pixels=decodeImage(clip,360,220);
for(size_t i=3;i<pixels.bgra.size();i+=4) pixels.bgra[i]=255;
ComPtr<IWICImagingFactory> factory; check(CoCreateInstance(CLSID_WICImagingFactory,nullptr,CLSCTX_INPROC_SERVER,IID_PPV_ARGS(&factory)));
ComPtr<IWICStream> stream; check(factory->CreateStream(&stream)); check(stream->InitializeFromFilename(path.c_str(),GENERIC_WRITE));
ComPtr<IWICBitmapEncoder> encoder; check(factory->CreateEncoder(GUID_ContainerFormatPng,nullptr,&encoder));
check(encoder->Initialize(stream.Get(),WICBitmapEncoderNoCache));
ComPtr<IWICBitmapFrameEncode> frame; check(encoder->CreateNewFrame(&frame,nullptr)); check(frame->Initialize(nullptr));
check(frame->SetSize(pixels.width,pixels.height));
auto format=GUID_WICPixelFormat32bppBGRA; check(frame->SetPixelFormat(&format));
if(format!=GUID_WICPixelFormat32bppBGRA) throw std::runtime_error("Unsupported preview pixel format");
check(frame->WritePixels(pixels.height,pixels.width*4,(UINT)pixels.bgra.size(),pixels.bgra.data()));
check(frame->Commit()); check(encoder->Commit());
}
std::wstring escapeXml(const std::wstring &s)
{
std::wstring result;
for(auto ch:s) { if(ch==L'&') result+=L"&amp;"; else if(ch==L'\"') result+=L"&quot;"; else if(ch==L'<') result+=L"&lt;"; else result+=ch; }
return result;
}
}
Clip loadNotifiedScreenshot(const std::wstring &id)
{
if(!validScreenshotToken(id)) throw std::runtime_error("Invalid screenshot notification");
auto directory=cacheDirectory(); cleanCache(directory);
auto path=directory/(id+L".capture");
if(!std::filesystem::exists(path)) throw std::runtime_error("This screenshot notification has expired. Take a new screenshot.");
return Clip{{{CF_DIB,L"",unprotect(readFile(path,160*1024*1024))}}};
}
bool notifyScreenshot(const Clip &clip)
{
notificationError.clear();
const char *stage="registration";
try {
registerNotifications();
stage="notification manager";
ComPtr<Notifications::IToastNotificationManagerStatics> manager;
String managerClass(L"Windows.UI.Notifications.ToastNotificationManager");
check(RoGetActivationFactory(managerClass.value,IID_PPV_ARGS(&manager)));
ComPtr<Notifications::IToastNotifier> notifier; String appId(AppId);
stage="notifier";
check(manager->CreateToastNotifierWithId(appId.value,&notifier));
stage="settings";
Notifications::NotificationSetting setting{};
auto settingResult=notifier->get_Setting(&setting);
// A first-time sender has no settings record until its first notification.
if(settingResult!=HRESULT_FROM_WIN32(ERROR_NOT_FOUND)) check(settingResult);
if(setting!=Notifications::NotificationSetting_Enabled) throw std::runtime_error("Screenshot notifications are disabled in Windows settings");
stage="cache";
auto directory=cacheDirectory(); cleanCache(directory);
GUID guid{}; check(CoCreateGuid(&guid)); wchar_t value[40]{}; StringFromGUID2(guid,value,40);
std::wstring id(value+1,36);
auto dib=std::find_if(clip.formats.begin(),clip.formats.end(),[](const auto &format){return format.id==CF_DIB;});
if(dib==clip.formats.end() || dib->data.size()>128*1024*1024) return false;
atomicWrite(directory/(id+L".capture"),protect(dib->data));
stage="preview";
auto previews=previewDirectory(); cleanCache(previews);
auto preview=previews/(id+L".png"); savePreview(clip,preview);
cleanCache(previews);
cleanCache(directory);
stage="XML";
String documentClass(L"Windows.Data.Xml.Dom.XmlDocument"); ComPtr<IInspectable> documentInstance;
check(RoActivateInstance(documentClass.value,&documentInstance));
ComPtr<Xml::IXmlDocument> document; check(documentInstance.As(&document));
ComPtr<Xml::IXmlDocumentIO> documentIO; check(document.As(&documentIO));
auto uri=L"file:///"+preview.generic_wstring();
String content(L"<toast launch=\""+id+L"\"><visual><binding template=\"ToastGeneric\">"
L"<text>Screenshot copied</text><text>Click to edit and annotate</text><image id=\"1\" placement=\"appLogoOverride\" alt=\"Screenshot preview\" src=\""+escapeXml(uri)+L"\"/></binding></visual><audio silent=\"true\"/></toast>");
check(documentIO->LoadXml(content.value));
stage="toast factory";
ComPtr<Notifications::IToastNotificationFactory> toastFactory; String toastClass(L"Windows.UI.Notifications.ToastNotification");
check(RoGetActivationFactory(toastClass.value,IID_PPV_ARGS(&toastFactory)));
ComPtr<Notifications::IToastNotification> toast; check(toastFactory->CreateToastNotification(document.Get(),&toast));
ComPtr<ABI::Windows::Foundation::IPropertyValueStatics> values;
String propertyClass(L"Windows.Foundation.PropertyValue");
check(RoGetActivationFactory(propertyClass.value,IID_PPV_ARGS(&values)));
FILETIME now{}; GetSystemTimeAsFileTime(&now);
ULARGE_INTEGER timestamp{}; timestamp.LowPart=now.dwLowDateTime; timestamp.HighPart=now.dwHighDateTime;
ABI::Windows::Foundation::DateTime expires{(INT64)(timestamp.QuadPart+24ull*60*60*10000000)};
ComPtr<IInspectable> boxed; check(values->CreateDateTime(expires,&boxed));
ComPtr<ABI::Windows::Foundation::IReference<ABI::Windows::Foundation::DateTime>> expiration;
check(boxed.As(&expiration)); check(toast->put_ExpirationTime(expiration.Get()));
stage="show";
check(notifier->Show(toast.Get()));
return true;
} catch(const std::exception &e) { notificationError=std::string(stage)+": "+e.what(); return false; } // Clipboard is already populated; fall back to the editor.
}
std::string screenshotNotificationError() { return notificationError; }
void registerScreenshotNotifications() { registerNotifications(); }
}