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

src/app.cpp

@@ -2,6 +2,7 @@
 #include "../resources/resource.h"
 #include "ocr.h"
 #include "configuration.h"
+#include "screenshot_notifications.h"
 #include <algorithm>
 #include <commctrl.h>
 #include <set>
@@ -1452,6 +1453,7 @@ int App::execute()
         confirmUpdatedStartup(updateStartupEvent);
     if (startCommand)
         PostMessageW(window, WM_HOTKEY, startCommand, 0);
+    auto screenshotActivation=startScreenshotActivationListener();
     MSG msg;
     while (GetMessageW(&msg, nullptr, 0, 0) > 0)
     {
@@ -1470,6 +1472,7 @@ int App::execute()
         TranslateMessage(&msg);
         DispatchMessageW(&msg);
     }
+    if(screenshotActivation) CoRevokeClassObject(screenshotActivation);
     return (int)msg.wParam;
 }
 } // namespace ks

src/app.h

@@ -99,7 +99,7 @@ class App
     static LRESULT CALLBACK keyProc(int, WPARAM, LPARAM);
     static LRESULT CALLBACK mouseProc(int, WPARAM, LPARAM);
 };
-void showHistory(App &);
+void showHistory(App &, bool visible = true);
 void launchScreenshot(App &);
 void refreshHistory(App &);
 void showSettings(App &, bool visible = true);

src/screenshot.cpp

@@ -1,4 +1,5 @@
 #include "screenshot.h"
+#include "ocr.h"
 #include "../resources/resource.h"
 #include <algorithm>
 #include <cmath>
@@ -801,6 +802,20 @@ void edit(HWND w, Capture &c)
                  std::min(LONG(MulDiv(700,GetDpiForWindow(w),96)),work.bottom-work.top-40),SWP_FRAMECHANGED|SWP_SHOWWINDOW);
     layout(w,c); SetForegroundWindow(w); SetFocus(w);
 }
+void finishSelection(HWND w,Capture &c,DWORD (*publish)(HWND,const Clip &)=writeClipboard)
+{
+    if(!c.app.notify) { edit(w,c); return; }
+    auto r=region(c.start,c.end);
+    if(r.right-r.left<2 || r.bottom-r.top<2) return;
+    Surface cropped(r.right-r.left,r.bottom-r.top);
+    BitBlt(cropped.dc,0,0,cropped.width,cropped.height,c.image->dc,r.left,r.top,SRCCOPY);
+    auto clip=screenshotClip(cropped.dc,cropped.width,cropped.height,{});
+    publish(c.app.window,clip);
+    c.copied=true;
+    ShowWindow(w,SW_HIDE);
+    if(c.app.notify(clip)) DestroyWindow(w);
+    else edit(w,c);
+}
 LRESULT CALLBACK captureProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
 {
     auto c = reinterpret_cast<Capture *>(GetWindowLongPtrW(w,GWLP_USERDATA));
@@ -1100,7 +1115,7 @@ LRESULT CALLBACK captureProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
                 if (msg==WM_LBUTTONUP)
                 {
                     c->dragging=false; ReleaseCapture();
-                    if (!c->editing) edit(w,*c);
+                    if (!c->editing) { finishSelection(w,*c); return 0; }
                     else if(c->part!=MarkPart::None)
                     {
                         if(c->part==MarkPart::Start || c->part==MarkPart::End)
@@ -1513,6 +1528,22 @@ Clip screenshotClip(HDC source, int width, int height, const std::vector<Screens
     memcpy(bytes.data()+sizeof(header),output.pixels,bytes.size()-sizeof(header));
     return Clip{{{CF_DIB,L"",std::move(bytes)}}};
 }
+void showScreenshotEditor(ScreenshotHost &app,const Clip &clip)
+{
+    auto pixels=decodeImage(clip);
+    auto c=std::make_unique<Capture>(app);
+    c->image=std::make_unique<Surface>(pixels.width,pixels.height);
+    memcpy(c->image->pixels,pixels.bgra.data(),pixels.bgra.size());
+    c->start={0,0}; c->end={(LONG)pixels.width,(LONG)pixels.height}; c->copied=true;
+    WNDCLASSW cls{}; cls.hInstance=app.instance; cls.lpfnWndProc=captureProc; cls.lpszClassName=L"KSwitcher.Capture";
+    cls.style=CS_DBLCLKS; cls.hCursor=LoadCursorW(nullptr,IDC_CROSS);
+    cls.hIcon=LoadIconW(app.instance,MAKEINTRESOURCEW(IDI_KSWITCHER)); RegisterClassW(&cls);
+    auto window=CreateWindowExW(0,cls.lpszClassName,L"KSwitcher Screenshot",WS_POPUP,0,0,1,1,
+        app.window,nullptr,app.instance,c.get());
+    if(!window) throw std::runtime_error("Cannot open screenshot editor");
+    c->owned=true; ++app.windows;
+    auto state=c.release(); edit(window,*state);
+}
 void showScreenshot(ScreenshotHost &app)
 {
     if (activeCapture) { showRequestedWindow(activeCapture); SetForegroundWindow(activeCapture); return; }

src/screenshot.h

@@ -7,9 +7,11 @@ struct ScreenshotHost {
     HINSTANCE instance{};
     HWND window{};
     unsigned windows{};
+    bool (*notify)(const Clip &){};
 };
 inline constexpr UINT ScreenshotRequest=WM_APP+71, ScreenshotIdle=WM_APP+72;
 void showScreenshot(ScreenshotHost &);
+void showScreenshotEditor(ScreenshotHost &,const Clip &);
 enum class LineStyle { Solid, Dotted, Dashed, DashDot };
 enum class LineEnds { End, Start, Both, None };
 enum class ScreenshotShape { None, Rectangle, Circle, Ellipse };

src/screenshot_activation.cpp

@@ -0,0 +1,100 @@
+#include "screenshot_notifications.h"
+#include <atomic>
+namespace ks {
+namespace {
+constexpr wchar_t AppId[]=L"HrynCo.KSwitcher.Screenshot";
+constexpr GUID ActivatorId{0xe3f78047,0xf0ad,0x49b6,{0x90,0x74,0x41,0x19,0x31,0x70,0x61,0x67}};
+}
+bool validScreenshotToken(const std::wstring &id)
+{
+    if(id.size()!=36) return false;
+    for(size_t i=0;i<id.size();++i) {
+        if(i==8 || i==13 || i==18 || i==23) { if(id[i]!=L'-') return false; }
+        else if(!((id[i]>=L'0' && id[i]<=L'9') || (id[i]>=L'a' && id[i]<=L'f') || (id[i]>=L'A' && id[i]<=L'F'))) return false;
+    }
+    return true;
+}
+
+namespace {
+// Windows SDK INotificationActivationCallback ABI (notificationactivationcallback.h).
+constexpr GUID CallbackId{0x53e31837,0x6600,0x4a81,{0x93,0x95,0x75,0xcf,0xfe,0x74,0x6f,0x94}};
+struct NotificationInput { LPCWSTR key,value; };
+struct NotificationCallback : IUnknown {
+    virtual HRESULT STDMETHODCALLTYPE Activate(LPCWSTR,LPCWSTR,const NotificationInput *,ULONG)=0;
+};
+class Activator final : public NotificationCallback {
+    std::atomic<ULONG> references{1};
+    DWORD thread=GetCurrentThreadId();
+    std::wstring target;
+    bool quit;
+public:
+    Activator(std::wstring path,bool shouldQuit):target(std::move(path)),quit(shouldQuit) {}
+    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID id,void **out) override {
+        if(!out) return E_POINTER;
+        *out=nullptr;
+        if(id!=IID_IUnknown && id!=CallbackId) return E_NOINTERFACE;
+        *out=static_cast<NotificationCallback *>(this); AddRef(); return S_OK;
+    }
+    ULONG STDMETHODCALLTYPE AddRef() override { return ++references; }
+    ULONG STDMETHODCALLTYPE Release() override { auto count=--references; if(!count) delete this; return count; }
+    HRESULT STDMETHODCALLTYPE Activate(LPCWSTR app,LPCWSTR args,const NotificationInput *,ULONG) override {
+        if(!app || std::wstring(app)!=AppId || !args || !validScreenshotToken(args)) return E_INVALIDARG;
+        auto path=target; auto command=L"\""+path+L"\" --open \"kswitcher-screenshot:"+args+L"\"";
+        STARTUPINFOW startup{sizeof(startup)}; PROCESS_INFORMATION process{};
+        auto ok=CreateProcessW(path.c_str(),command.data(),nullptr,nullptr,FALSE,CREATE_SUSPENDED,nullptr,nullptr,&startup,&process);
+        auto result=ok?S_OK:HRESULT_FROM_WIN32(GetLastError());
+        if(ok) {
+            AllowSetForegroundWindow(process.dwProcessId); ResumeThread(process.hThread);
+            CloseHandle(process.hThread); CloseHandle(process.hProcess);
+        }
+        if(quit) PostThreadMessageW(thread,WM_QUIT,0,0);
+        return result;
+    }
+};
+class ActivatorFactory final : public IClassFactory {
+    std::atomic<ULONG> references{1};
+    std::wstring target;
+    bool quit;
+public:
+    ActivatorFactory(std::wstring path,bool shouldQuit):target(std::move(path)),quit(shouldQuit) {}
+    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID id,void **out) override {
+        if(!out) return E_POINTER;
+        *out=nullptr;
+        if(id!=IID_IUnknown && id!=IID_IClassFactory) return E_NOINTERFACE;
+        *out=static_cast<IClassFactory *>(this); AddRef(); return S_OK;
+    }
+    ULONG STDMETHODCALLTYPE AddRef() override { return ++references; }
+    ULONG STDMETHODCALLTYPE Release() override { auto count=--references; if(!count) delete this; return count; }
+    HRESULT STDMETHODCALLTYPE CreateInstance(IUnknown *outer,REFIID id,void **out) override {
+        if(outer) return CLASS_E_NOAGGREGATION;
+        auto object=new Activator(target,quit); auto result=object->QueryInterface(id,out); object->Release(); return result;
+    }
+    HRESULT STDMETHODCALLTYPE LockServer(BOOL) override { return S_OK; }
+};
+}
+int runScreenshotToastActivator()
+{
+    if(FAILED(CoInitializeEx(nullptr,COINIT_APARTMENTTHREADED))) return 1;
+    MSG message{}; PeekMessageW(&message,nullptr,0,0,PM_NOREMOVE);
+    auto factory=new ActivatorFactory(executable(),true); DWORD registration{};
+    auto result=CoRegisterClassObject(ActivatorId,factory,CLSCTX_LOCAL_SERVER,REGCLS_MULTIPLEUSE,&registration);
+    factory->Release();
+    if(SUCCEEDED(result)) {
+        auto timer=SetTimer(nullptr,0,60000,[](HWND,UINT,UINT_PTR,DWORD){PostQuitMessage(0);});
+        while(GetMessageW(&message,nullptr,0,0)>0) { TranslateMessage(&message); DispatchMessageW(&message); }
+        if(timer) KillTimer(nullptr,timer);
+        CoRevokeClassObject(registration);
+    }
+    CoUninitialize(); return FAILED(result)?1:0;
+}
+DWORD startScreenshotActivationListener()
+{
+    auto target=std::filesystem::path(executable()).parent_path()/L"KSwitcher.Screenshot.exe";
+    auto factory=new ActivatorFactory(target.wstring(),false);
+    DWORD registration{};
+    auto result=CoRegisterClassObject(ActivatorId,factory,CLSCTX_LOCAL_SERVER,REGCLS_MULTIPLEUSE,&registration);
+    factory->Release();
+    return SUCCEEDED(result)?registration:0;
+}
+
+}

src/screenshot_main.cpp

@@ -1,5 +1,8 @@
 #include "screenshot.h"
+#include "screenshot_notifications.h"
 #include <commctrl.h>
+#include <shellapi.h>
+#include <roapi.h>
 
 namespace {
 constexpr wchar_t ControllerClass[]=L"KSwitcher.Screenshot.Controller";
@@ -18,6 +21,18 @@ LRESULT CALLBACK controller(HWND window,UINT message,WPARAM wp,LPARAM lp)
         }
         return TRUE;
     }
+    if(host && message==WM_COPYDATA) {
+        auto data=(COPYDATASTRUCT *)lp;
+        if(!data || data->dwData!=73 || data->cbData!=37*sizeof(wchar_t) || !data->lpData) return FALSE;
+        std::wstring token((const wchar_t *)data->lpData,36);
+        if(!ks::validScreenshotToken(token)) return FALSE;
+        try { ks::showScreenshotEditor(*host,ks::loadNotifiedScreenshot(token)); }
+        catch(const std::exception &e) {
+            MessageBoxW(window,ks::wide(e.what()).c_str(),L"Screenshot",MB_OK|MB_ICONINFORMATION);
+            PostMessageW(window,ks::ScreenshotIdle,0,0);
+        }
+        return TRUE;
+    }
     if(host && message==ks::ScreenshotIdle && !host->windows) {
         DestroyWindow(window);
         PostQuitMessage(0);
@@ -29,6 +44,25 @@ LRESULT CALLBACK controller(HWND window,UINT message,WPARAM wp,LPARAM lp)
 
 int WINAPI wWinMain(HINSTANCE instance,HINSTANCE,PWSTR,int)
 {
+    std::wstring token;
+    int argc{}; auto argv=CommandLineToArgvW(GetCommandLineW(),&argc);
+    if(argc>=2 && std::wstring(argv[1])==L"--toast-activated") {
+        LocalFree(argv); return ks::runScreenshotToastActivator();
+    }
+    if(argc==2 && std::wstring(argv[1])==L"--register-notifications") {
+        LocalFree(argv); CoInitializeEx(nullptr,COINIT_APARTMENTTHREADED);
+        int result=0; try { ks::registerScreenshotNotifications(); } catch(...) { result=1; }
+        CoUninitialize(); return result;
+    }
+    if(argc>1) {
+        if(argc==3 && std::wstring(argv[1])==L"--open") {
+            std::wstring uri=argv[2]; const std::wstring prefix=L"kswitcher-screenshot:";
+            if(uri.starts_with(prefix)) token=uri.substr(prefix.size());
+        }
+        if(!ks::validScreenshotToken(token)) { LocalFree(argv); return 1; }
+    }
+    LocalFree(argv);
+    COPYDATASTRUCT open{73,DWORD((token.size()+1)*sizeof(wchar_t)),token.data()};
     HANDLE mutex=CreateMutexW(nullptr,FALSE,L"Local\\KSwitcher.Screenshot.Singleton");
     if(!mutex) return 1;
     // Wait through startup/shutdown races; the controller accepts requests only while alive.
@@ -40,30 +74,36 @@ int WINAPI wWinMain(HINSTANCE instance,HINSTANCE,PWSTR,int)
             DWORD pid{}; GetWindowThreadProcessId(existing,&pid);
             AllowSetForegroundWindow(pid);
             DWORD_PTR accepted{};
-            if(SendMessageTimeoutW(existing,ks::ScreenshotRequest,0,0,SMTO_ABORTIFHUNG,2000,&accepted) && accepted) {
+            if(SendMessageTimeoutW(existing,token.empty()?ks::ScreenshotRequest:WM_COPYDATA,0,
+                token.empty()?0:(LPARAM)&open,SMTO_ABORTIFHUNG,2000,&accepted) && accepted) {
                 CloseHandle(mutex); return 0;
             }
         }
         Sleep(50);
     }
     if(!acquired) { CloseHandle(mutex); return 1; }
-    CoInitializeEx(nullptr,COINIT_APARTMENTTHREADED);
+    RoInitialize(RO_INIT_SINGLETHREADED);
     INITCOMMONCONTROLSEX controls{sizeof(controls),ICC_STANDARD_CLASSES|ICC_BAR_CLASSES};
     InitCommonControlsEx(&controls);
     ks::ScreenshotHost host{instance};
+    host.notify=ks::notifyScreenshot;
     WNDCLASSW cls{}; cls.hInstance=instance; cls.lpfnWndProc=controller; cls.lpszClassName=ControllerClass;
     RegisterClassW(&cls);
     host.window=CreateWindowW(ControllerClass,L"KSwitcher Screenshot",0,0,0,0,0,nullptr,nullptr,instance,&host);
     int result=1;
     if(host.window) {
-        PostMessageW(host.window,ks::ScreenshotRequest,0,0);
+        // Toast protocol activation may run unelevated while the editor was launched by an elevated resident.
+        // WM_COPYDATA accepts only a validated cache GUID, never a path or executable command.
+        ChangeWindowMessageFilterEx(host.window,WM_COPYDATA,MSGFLT_ALLOW,nullptr);
+        if(token.empty()) PostMessageW(host.window,ks::ScreenshotRequest,0,0);
+        else SendMessageW(host.window,WM_COPYDATA,0,(LPARAM)&open);
         MSG message{};
         while((result=GetMessageW(&message,nullptr,0,0))>0) {
             TranslateMessage(&message); DispatchMessageW(&message);
         }
         result=result<0?1:0;
     }
-    CoUninitialize();
+    RoUninitialize();
     ReleaseMutex(mutex); CloseHandle(mutex);
     return result;
 }

src/screenshot_notifications.cpp

@@ -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(); }
+
+}

src/screenshot_notifications.h

@@ -0,0 +1,11 @@
+#pragma once
+#include "platform.h"
+namespace ks {
+bool notifyScreenshot(const Clip &);
+std::string screenshotNotificationError();
+void registerScreenshotNotifications();
+int runScreenshotToastActivator();
+DWORD startScreenshotActivationListener();
+bool validScreenshotToken(const std::wstring &);
+Clip loadNotifiedScreenshot(const std::wstring &);
+}

src/ui.cpp

@@ -31,7 +31,7 @@ HFONT font(HWND w)
 struct WindowLayout
 {
     int width{}, height{}, x{}, y{};
-    bool scrolling{}, arranging{};
+    bool scrolling{}, arranging{}, history{};
     int wheelRemainder{}, horizontalWheelRemainder{};
     std::vector<std::pair<HWND, RECT>> controls; // Original 96-DPI geometry; never rescale rounded pixels.
 };
@@ -68,9 +68,18 @@ void arrangeWindow(HWND w)
         layout->x = SetScrollInfo(w, SB_HORZ, &horizontal, TRUE);
         layout->y = SetScrollInfo(w, SB_VERT, &vertical, TRUE);
     }
+    RECT client{}; GetClientRect(w, &client);
+    int extraWidth = layout->history ? std::max(0, int(client.right) - scale(w, layout->width)) : 0;
+    int extraHeight = layout->history ? std::max(0, int(client.bottom) - scale(w, layout->height)) : 0;
     for (const auto &[child, r] : layout->controls)
-        SetWindowPos(child, nullptr, scale(w, r.left) - layout->x, scale(w, r.top) - layout->y,
-                     scale(w, r.right - r.left), scale(w, r.bottom - r.top), SWP_NOACTIVATE | SWP_NOZORDER);
+    {
+        int id = GetDlgCtrlID(child);
+        SetWindowPos(child, nullptr, scale(w, r.left) - layout->x,
+                         scale(w, r.top) - layout->y + (id >= 110 && id <= 114 ? extraHeight : 0),
+                         scale(w, r.right - r.left) + (id == 101 || id == 102 ? extraWidth : 0),
+                         scale(w, r.bottom - r.top) + (id == 102 ? extraHeight : 0),
+                         SWP_NOACTIVATE | SWP_NOZORDER);
+    }
     layout->arranging = false;
     InvalidateRect(w, nullptr, TRUE);
 }
@@ -1325,7 +1334,7 @@ void refreshHistory(App &app)
         search(app.historyWindow, v);
     }
 }
-void showHistory(App &app)
+void showHistory(App &app, bool visible)
 {
     if (!app.history)
     {
@@ -1333,7 +1342,7 @@ void showHistory(App &app)
         return;
     }
     HWND foreground = GetForegroundWindow();
-    if (app.historyWindow && IsWindowVisible(app.historyWindow) && foreground == app.historyWindow)
+    if (visible && app.historyWindow && IsWindowVisible(app.historyWindow) && foreground == app.historyWindow)
     {
         auto *v = (HistoryView *)GetWindowLongPtrW(app.historyWindow, GWLP_USERDATA);
         if (v->items.size() > 1)
@@ -1346,6 +1355,7 @@ void showHistory(App &app)
     {
         HWND w = makeWindow(app, L"KSwitcher.History", L"Clipboard history", historyProc, 760, 500);
         app.historyWindow = w;
+        windowLayoutState(w)->history = true;
         ((HistoryView *)GetWindowLongPtrW(w, GWLP_USERDATA))->rich = createRichText(w, 105, false);
         label(w, L"Search clipboard history", 16, 12, 500);
         edit(w, 101, 16, 38, 728);
@@ -1362,6 +1372,7 @@ void showHistory(App &app)
         SetWindowSubclass(list, historyKey, 1, (DWORD_PTR)w);
         SetWindowSubclass(GetDlgItem(w, 101), historyKey, 1, (DWORD_PTR)w);
     }
+    if (!visible) return;
     POINT cursor;
     GetCursorPos(&cursor);
     MONITORINFO monitor{sizeof(monitor)};

src/update.h

@@ -2,7 +2,7 @@
 #include "platform.h"
 namespace ks
 {
-inline constexpr wchar_t AppVersion[] = L"0.5.0";
+inline constexpr wchar_t AppVersion[] = L"0.6.0";
 inline constexpr UINT UpdateMessage = WM_APP + 7;
 struct UpdateResult
 {