Added desktop notifications implementation for Windows 7 (and earlier)

brightray/browser/win/notification_presenter_win7.cc

@@ -0,0 +1,47 @@
+#include "notification_presenter_win7.h"
+#include "win32_notification.h"
+
+namespace brightray {
+
+brightray::Notification* NotificationPresenterWin7::CreateNotificationObject(NotificationDelegate* delegate)
+{
+    return new Win32Notification(delegate, this);
+}
+
+Win32Notification* NotificationPresenterWin7::GetNotificationObjectByRef(const DesktopNotificationController::Notification& ref)
+{
+    for(auto n : this->notifications())
+    {
+        auto w32n = static_cast<Win32Notification*>(n);
+        if(w32n->GetRef() == ref)
+            return w32n;
+    }
+
+    return nullptr;
+}
+
+Win32Notification* NotificationPresenterWin7::GetNotificationObjectByTag(const std::string& tag)
+{
+    for(auto n : this->notifications())
+    {
+        auto w32n = static_cast<Win32Notification*>(n);
+        if(w32n->GetTag() == tag)
+            return w32n;
+    }
+
+    return nullptr;
+}
+
+void NotificationPresenterWin7::OnNotificationClicked(Notification& notification)
+{
+    auto n = GetNotificationObjectByRef(notification);
+    if(n) n->NotificationClicked();
+}
+
+void NotificationPresenterWin7::OnNotificationDismissed(Notification& notification)
+{
+    auto n = GetNotificationObjectByRef(notification);
+    if(n) n->NotificationDismissed();
+}
+
+}

brightray/browser/win/notification_presenter_win7.h

@@ -0,0 +1,28 @@
+#pragma once
+#include "browser/notification_presenter.h"
+#include "browser/win/win32_desktop_notifications/desktop_notification_controller.h"
+
+namespace brightray {
+
+class Win32Notification;
+
+class NotificationPresenterWin7 :
+    public NotificationPresenter,
+    public DesktopNotificationController
+{
+public:
+    NotificationPresenterWin7() = default;
+
+    Win32Notification* GetNotificationObjectByRef(const DesktopNotificationController::Notification& ref);
+    Win32Notification* GetNotificationObjectByTag(const std::string& tag);
+
+private:
+    DISALLOW_COPY_AND_ASSIGN(NotificationPresenterWin7);
+
+    brightray::Notification* CreateNotificationObject(NotificationDelegate* delegate) override;
+
+    void OnNotificationClicked(Notification& notification) override;
+    void OnNotificationDismissed(Notification& notification) override;
+};
+
+}  // namespace

brightray/browser/win/win32_desktop_notifications/common.h

@@ -0,0 +1,57 @@
+#pragma once
+#include <Windows.h>
+
+namespace brightray {
+
+struct NotificationData
+{
+    DesktopNotificationController* controller = nullptr;
+
+    std::wstring caption;
+    std::wstring bodyText;
+    HBITMAP image = NULL;
+
+
+    NotificationData() = default;
+
+    ~NotificationData()
+    {
+        if(image) DeleteObject(image);
+    }
+
+    NotificationData(const NotificationData& other) = delete;
+    NotificationData& operator=(const NotificationData& other) = delete;
+};
+
+template<typename T>
+inline T ScaleForDpi(T value, unsigned dpi)
+{
+    return value * dpi / 96;
+}
+
+struct ScreenMetrics
+{
+    UINT dpiX, dpiY;
+
+    ScreenMetrics()
+    {
+        typedef HRESULT WINAPI GetDpiForMonitor_t(HMONITOR, int, UINT*, UINT*);
+        auto GetDpiForMonitor = (GetDpiForMonitor_t*)GetProcAddress(GetModuleHandle(TEXT("shcore")), "GetDpiForMonitor");
+        if(GetDpiForMonitor)
+        {
+            auto monitor = MonitorFromPoint({}, MONITOR_DEFAULTTOPRIMARY);
+            if(GetDpiForMonitor(monitor, 0, &dpiX, &dpiY) == S_OK)
+                return;
+        }
+
+        HDC hdc = GetDC(NULL);
+        dpiX = GetDeviceCaps(hdc, LOGPIXELSX);
+        dpiY = GetDeviceCaps(hdc, LOGPIXELSY);
+        ReleaseDC(NULL, hdc);
+    }
+
+    template<typename T> T X(T value) const { return ScaleForDpi(value, dpiX); }
+    template<typename T> T Y(T value) const { return ScaleForDpi(value, dpiY); }
+};
+
+}

brightray/browser/win/win32_desktop_notifications/desktop_notification_controller.cc

@@ -0,0 +1,426 @@
+#define NOMINMAX
+#define WIN32_LEAN_AND_MEAN
+#include "desktop_notification_controller.h"
+#include "common.h"
+#include "toast.h"
+#include <algorithm>
+#include <vector>
+#include <windowsx.h>
+
+using namespace std;
+
+namespace brightray {
+
+HBITMAP CopyBitmap(HBITMAP bitmap)
+{
+    HBITMAP ret = NULL;
+
+    BITMAP bm;
+    if(bitmap && GetObject(bitmap, sizeof(bm), &bm))
+    {
+        HDC hdcScreen = GetDC(NULL);
+        ret = CreateCompatibleBitmap(hdcScreen, bm.bmWidth, bm.bmHeight);
+        ReleaseDC(NULL, hdcScreen);
+
+        if(ret)
+        {
+            HDC hdcSrc = CreateCompatibleDC(NULL);
+            HDC hdcDst = CreateCompatibleDC(NULL);
+            SelectBitmap(hdcSrc, bitmap);
+            SelectBitmap(hdcDst, ret);
+            BitBlt(hdcDst, 0, 0, bm.bmWidth, bm.bmHeight, hdcSrc, 0, 0, SRCCOPY);
+            DeleteDC(hdcDst);
+            DeleteDC(hdcSrc);
+        }
+    }
+
+    return ret;
+}
+
+HINSTANCE DesktopNotificationController::RegisterWndClasses()
+{
+    // We keep a static `module` variable which serves a dual purpose:
+    // 1. Stores the HINSTANCE where the window classes are registered, which can be passed to `CreateWindow`
+    // 2. Indicates whether we already attempted the registration so that we don't do it twice (we don't retry
+    //    even if registration fails, as there is no point.
+    static HMODULE module = NULL;
+
+    if(!module)
+    {
+        if(GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, reinterpret_cast<LPCWSTR>(&RegisterWndClasses), &module))
+        {
+            Toast::Register(module);
+
+            WNDCLASSEX wc = { sizeof(wc) };
+            wc.lpfnWndProc = &WndProc;
+            wc.lpszClassName = className;
+            wc.cbWndExtra = sizeof(DesktopNotificationController*);
+            wc.hInstance = module;
+
+            RegisterClassEx(&wc);
+        }
+    }
+
+    return module;
+}
+
+DesktopNotificationController::DesktopNotificationController(unsigned maximumToasts)
+{
+    instances.reserve(maximumToasts);
+}
+
+DesktopNotificationController::~DesktopNotificationController()
+{
+    for(auto&& inst : instances) DestroyToast(inst);
+    if(hwndController) DestroyWindow(hwndController);
+    ClearAssets();
+}
+
+LRESULT CALLBACK DesktopNotificationController::WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+    switch(message)
+    {
+    case WM_CREATE:
+        {
+            auto& cs = reinterpret_cast<const CREATESTRUCT*&>(lParam);
+            SetWindowLongPtr(hWnd, 0, (LONG_PTR)cs->lpCreateParams);
+        }
+        break;
+
+    case WM_TIMER:
+        if(wParam == TimerID_Animate)
+        {
+            Get(hWnd)->AnimateAll();
+        }
+        return 0;
+
+    case WM_DISPLAYCHANGE:
+        {
+            auto inst = Get(hWnd);
+            inst->ClearAssets();
+            inst->AnimateAll();
+        }
+        break;
+
+    case WM_SETTINGCHANGE:
+        if(wParam == SPI_SETWORKAREA)
+        {
+            Get(hWnd)->AnimateAll();
+        }
+        break;
+    }
+
+    return DefWindowProc(hWnd, message, wParam, lParam);
+}
+
+void DesktopNotificationController::StartAnimation()
+{
+    _ASSERT(hwndController);
+
+    if(!isAnimating && hwndController)
+    {
+        // NOTE: 15ms is shorter than what we'd need for 60 fps, but since the timer
+        //       is not accurate we must request a higher frame rate to get at least 60
+
+        SetTimer(hwndController, TimerID_Animate, 15, nullptr);
+        isAnimating = true;
+    }
+}
+
+HFONT DesktopNotificationController::GetCaptionFont()
+{
+    InitializeFonts();
+    return captionFont;
+}
+
+HFONT DesktopNotificationController::GetBodyFont()
+{
+    InitializeFonts();
+    return bodyFont;
+}
+
+void DesktopNotificationController::InitializeFonts()
+{
+    if(!bodyFont)
+    {
+        NONCLIENTMETRICS metrics = { sizeof(metrics) };
+        if(SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, &metrics, 0))
+        {
+            auto baseHeight = metrics.lfMessageFont.lfHeight;
+
+            HDC hdc = GetDC(NULL);
+            auto dpiY = GetDeviceCaps(hdc, LOGPIXELSY);
+            ReleaseDC(NULL, hdc);
+
+            metrics.lfMessageFont.lfHeight = (LONG)ScaleForDpi(baseHeight * 1.1f, dpiY);
+            bodyFont = CreateFontIndirect(&metrics.lfMessageFont);
+
+            if(captionFont) DeleteFont(captionFont);
+            metrics.lfMessageFont.lfHeight = (LONG)ScaleForDpi(baseHeight * 1.4f, dpiY);
+            captionFont = CreateFontIndirect(&metrics.lfMessageFont);
+        }
+    }
+}
+
+void DesktopNotificationController::ClearAssets()
+{
+    if(captionFont) { DeleteFont(captionFont); captionFont = NULL; }
+    if(bodyFont) { DeleteFont(bodyFont); bodyFont = NULL; }
+}
+
+void DesktopNotificationController::AnimateAll()
+{
+    // NOTE: This function refreshes position and size of all toasts according
+    // to all current conditions. Animation time is only one of the variables
+    // influencing them. Screen resolution is another.
+
+    bool keepAnimating = false;
+
+    if(!instances.empty())
+    {
+        RECT workArea;
+        if(SystemParametersInfo(SPI_GETWORKAREA, 0, &workArea, 0))
+        {
+            ScreenMetrics metrics;
+            POINT origin = { workArea.right,
+                             workArea.bottom - metrics.Y(toastMargin<int>) };
+
+            auto hdwp = BeginDeferWindowPos((int)instances.size());
+            for(auto&& inst : instances)
+            {
+                if(!inst.hwnd) continue;
+
+                auto notification = Toast::Get(inst.hwnd);
+                hdwp = notification->Animate(hdwp, origin);
+                if(!hdwp) break;
+                keepAnimating |= notification->IsAnimationActive();
+            }
+            if(hdwp) EndDeferWindowPos(hdwp);
+        }
+    }
+
+    if(!keepAnimating)
+    {
+        _ASSERT(hwndController);
+        if(hwndController) KillTimer(hwndController, TimerID_Animate);
+        isAnimating = false;
+    }
+
+    // Purge dismissed notifications and collapse the stack between
+    // items which are highlighted
+    if(!instances.empty())
+    {
+        auto isAlive = [](ToastInstance& inst) {
+            return inst.hwnd && IsWindowVisible(inst.hwnd);
+        };
+
+        auto isHighlighted = [](ToastInstance& inst) {
+            return inst.hwnd && Toast::Get(inst.hwnd)->IsHighlighted();
+        };
+
+        for(auto it = instances.begin();; ++it)
+        {
+            // find next highlighted item
+            auto it2 = find_if(it, instances.end(), isHighlighted);
+
+            // collapse the stack in front of the highlighted item
+            it = stable_partition(it, it2, isAlive);
+
+            // purge the dead items
+            for_each(it, it2, [this](auto&& inst) { DestroyToast(inst); });
+
+            if(it2 == instances.end())
+            {
+                instances.erase(it, it2);
+                break;
+            }
+
+            it = move(it2);
+        }
+    }
+
+    // Set new toast positions
+    if(!instances.empty())
+    {
+        ScreenMetrics metrics;
+        auto margin = metrics.Y(toastMargin<int>);
+
+        int targetPos = 0;
+        for(auto&& inst : instances)
+        {
+            if(inst.hwnd)
+            {
+                auto toast = Toast::Get(inst.hwnd);
+
+                if(toast->IsHighlighted())
+                    targetPos = toast->GetVerticalPosition();
+                else
+                    toast->SetVerticalPosition(targetPos);
+
+                targetPos += toast->GetHeight() + margin;
+            }
+        }
+    }
+
+    // Create new toasts from the queue
+    CheckQueue();
+}
+
+DesktopNotificationController::Notification DesktopNotificationController::AddNotification(std::wstring caption, std::wstring bodyText, HBITMAP image)
+{
+    NotificationLink data(this);
+
+    data->caption = move(caption);
+    data->bodyText = move(bodyText);
+    data->image = CopyBitmap(image);
+
+    // Enqueue new notification
+    Notification ret = *queue.insert(queue.end(), move(data));
+    CheckQueue();
+    return ret;
+}
+
+void DesktopNotificationController::CloseNotification(Notification& notification)
+{
+    // Remove it from the queue
+    auto it = find(queue.begin(), queue.end(), notification.data);
+    if(it != queue.end())
+    {
+        queue.erase(it);
+        this->OnNotificationClosed(notification);
+        return;
+    }
+
+    // Dismiss active toast
+    auto hwnd = GetToast(notification.data.get());
+    if(hwnd)
+    {
+        auto toast = Toast::Get(hwnd);
+        toast->Dismiss();
+    }
+}
+
+void DesktopNotificationController::CheckQueue()
+{
+    while(instances.size() < instances.capacity() && !queue.empty())
+    {
+        CreateToast(move(queue.front()));
+        queue.pop_front();
+    }
+}
+
+void DesktopNotificationController::CreateToast(NotificationLink&& data)
+{
+    auto hInstance = RegisterWndClasses();
+    auto hwnd = Toast::Create(hInstance, data);
+    if(hwnd)
+    {
+        int toastPos = 0;
+        if(!instances.empty())
+        {
+            auto& item = instances.back();
+            _ASSERT(item.hwnd);
+
+            ScreenMetrics scr;
+            auto toast = Toast::Get(item.hwnd);
+            toastPos = toast->GetVerticalPosition() + toast->GetHeight() + scr.Y(toastMargin<int>);
+        }
+
+        instances.push_back({ hwnd, move(data) });
+
+        if(!hwndController)
+        {
+            // NOTE: We cannot use a message-only window because we need to receive system notifications
+            hwndController = CreateWindow(className, nullptr, 0, 0, 0, 0, 0, NULL, NULL, hInstance, this);
+        }
+
+        auto toast = Toast::Get(hwnd);
+        toast->PopUp(toastPos);
+    }
+}
+
+HWND DesktopNotificationController::GetToast(const NotificationData* data) const
+{
+    auto it = find_if(instances.cbegin(), instances.cend(), [data](auto&& inst) {
+        auto toast = Toast::Get(inst.hwnd);
+        return data == toast->GetNotification().get();
+    });
+
+    return (it != instances.cend()) ? it->hwnd : NULL;
+}
+
+void DesktopNotificationController::DestroyToast(ToastInstance& inst)
+{
+    if(inst.hwnd)
+    {
+        auto data = Toast::Get(inst.hwnd)->GetNotification();
+
+        DestroyWindow(inst.hwnd);
+        inst.hwnd = NULL;
+
+        Notification notification(data);
+        OnNotificationClosed(notification);
+    }
+}
+
+
+DesktopNotificationController::Notification::Notification(const shared_ptr<NotificationData>& data) :
+    data(data)
+{
+    _ASSERT(data != nullptr);
+}
+
+bool DesktopNotificationController::Notification::operator==(const Notification& other) const
+{
+    return data == other.data;
+}
+
+void DesktopNotificationController::Notification::Close()
+{
+    // No business calling this when not pointing to a valid instance
+    _ASSERT(data);
+
+    if(data->controller)
+        data->controller->CloseNotification(*this);
+}
+
+void DesktopNotificationController::Notification::Set(std::wstring caption, std::wstring bodyText, HBITMAP image)
+{
+    // No business calling this when not pointing to a valid instance
+    _ASSERT(data);
+
+    // Do nothing when the notification has been closed
+    if(!data->controller)
+        return;
+
+    if(data->image) DeleteBitmap(data->image);
+
+    data->caption = move(caption);
+    data->bodyText = move(bodyText);
+    data->image = CopyBitmap(image);
+
+    auto hwnd = data->controller->GetToast(data.get());
+    if(hwnd)
+    {
+        auto toast = Toast::Get(hwnd);
+        toast->ResetContents();
+    }
+
+    // Change of contents can affect size and position of all toasts
+    data->controller->StartAnimation();
+}
+
+
+DesktopNotificationController::NotificationLink::NotificationLink(DesktopNotificationController* controller) :
+    shared_ptr(make_shared<NotificationData>())
+{
+    get()->controller = controller;
+}
+
+DesktopNotificationController::NotificationLink::~NotificationLink()
+{
+    auto p = get();
+    if(p) p->controller = nullptr;
+}
+
+}

brightray/browser/win/win32_desktop_notifications/desktop_notification_controller.h

@@ -0,0 +1,103 @@
+#pragma once
+#include <deque>
+#include <memory>
+#include <string>
+#include <vector>
+#include <Windows.h>
+
+namespace brightray {
+
+struct NotificationData;
+
+class DesktopNotificationController
+{
+public:
+    DesktopNotificationController(unsigned maximumToasts = 3);
+    ~DesktopNotificationController();
+
+    class Notification;
+    Notification AddNotification(std::wstring caption, std::wstring bodyText, HBITMAP image);
+    void CloseNotification(Notification& notification);
+
+    // Event handlers -- override to receive the events
+private:
+    virtual void OnNotificationClosed(Notification& notification) {}
+    virtual void OnNotificationClicked(Notification& notification) {}
+    virtual void OnNotificationDismissed(Notification& notification) {}
+
+private:
+    static HINSTANCE RegisterWndClasses();
+    void StartAnimation();
+    HFONT GetCaptionFont();
+    HFONT GetBodyFont();
+
+private:
+    enum TimerID {
+        TimerID_Animate = 1
+    };
+
+    template<typename T>
+    static constexpr T toastMargin = 20;
+
+    // Wrapper around `NotificationData` which makes sure that
+    // the `controller` member is cleared when the controller object
+    // stops tracking the notification
+    struct NotificationLink : std::shared_ptr<NotificationData> {
+        NotificationLink(DesktopNotificationController* controller);
+        ~NotificationLink();
+
+        NotificationLink(NotificationLink&&) = default;
+        NotificationLink(const NotificationLink&) = delete;
+        NotificationLink& operator=(NotificationLink&&) = default;
+    };
+
+    struct ToastInstance {
+        HWND hwnd;
+        NotificationLink data;
+    };
+
+    class Toast;
+
+    static LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
+    static DesktopNotificationController* Get(HWND hWnd)
+    {
+        return reinterpret_cast<DesktopNotificationController*>(GetWindowLongPtr(hWnd, 0));
+    }
+
+    DesktopNotificationController(const DesktopNotificationController&) = delete;
+
+    void InitializeFonts();
+    void ClearAssets();
+    void AnimateAll();
+    void CheckQueue();
+    void CreateToast(NotificationLink&& data);
+    HWND GetToast(const NotificationData* data) const;
+    void DestroyToast(ToastInstance& inst);
+
+private:
+    static constexpr const TCHAR className[] = TEXT("DesktopNotificationController");
+    HWND hwndController = NULL;
+    HFONT captionFont = NULL, bodyFont = NULL;
+    std::vector<ToastInstance> instances;
+    std::deque<NotificationLink> queue;
+    bool isAnimating = false;
+};
+
+class DesktopNotificationController::Notification
+{
+public:
+    Notification() = default;
+    Notification(const std::shared_ptr<NotificationData>& data);
+
+    bool operator==(const Notification& other) const;
+
+    void Close();
+    void Set(std::wstring caption, std::wstring bodyText, HBITMAP image);
+
+private:
+    std::shared_ptr<NotificationData> data;
+
+    friend class DesktopNotificationController;
+};
+
+}

brightray/browser/win/win32_desktop_notifications/toast.cc

@@ -0,0 +1,811 @@
+#define NOMINMAX
+#include "toast.h"
+#include "common.h"
+#include <algorithm>
+#include <uxtheme.h>
+#include <windowsx.h>
+
+#pragma comment(lib, "msimg32.lib")
+#pragma comment(lib, "uxtheme.lib")
+
+using namespace std;
+
+namespace brightray {
+
+static COLORREF GetAccentColor()
+{
+    bool success = false;
+    if(IsAppThemed())
+    {
+        HKEY hkey;
+        if(RegOpenKeyEx(HKEY_CURRENT_USER, TEXT("SOFTWARE\\Microsoft\\Windows\\DWM"), 0, KEY_QUERY_VALUE, &hkey) == ERROR_SUCCESS)
+        {
+            COLORREF color;
+            DWORD type, size;
+            if(RegQueryValueEx(hkey, TEXT("AccentColor"), nullptr, &type, (BYTE*)&color, &(size = sizeof(color))) == ERROR_SUCCESS && type == REG_DWORD)
+            {
+                // convert from RGBA
+                color = RGB(GetRValue(color), GetGValue(color), GetBValue(color));
+                success = true;
+            }
+            else if(RegQueryValueEx(hkey, TEXT("ColorizationColor"), nullptr, &type, (BYTE*)&color, &(size = sizeof(color))) == ERROR_SUCCESS && type == REG_DWORD)
+            {
+                // convert from BGRA
+                color = RGB(GetBValue(color), GetGValue(color), GetRValue(color));
+                success = true;
+            }
+
+            RegCloseKey(hkey);
+
+            if(success) return color;
+        }
+    }
+
+    return GetSysColor(COLOR_ACTIVECAPTION);
+}
+
+// Stretches a bitmap to the specified size, preserves alpha channel
+static HBITMAP StretchBitmap(HBITMAP bitmap, unsigned width, unsigned height)
+{
+    // We use StretchBlt for the scaling, but that discards the alpha channel.
+    // Therefore we first create a separate grayscale bitmap from the alpha channel,
+    // scale that separately and copy it back to the scaled color bitmap.
+
+    BITMAP bm;
+    if(!GetObject(bitmap, sizeof(bm), &bm))
+        return NULL;
+
+    if(width == 0 || height == 0)
+        return NULL;
+
+    HBITMAP resultBitmap = NULL;
+
+    HDC hdcScreen = GetDC(NULL);
+
+    HBITMAP alphaSrcBitmap;
+    {
+        BITMAPINFOHEADER bmi = { sizeof(BITMAPINFOHEADER) };
+        bmi.biWidth = bm.bmWidth;
+        bmi.biHeight = bm.bmHeight;
+        bmi.biPlanes = bm.bmPlanes;
+        bmi.biBitCount = bm.bmBitsPixel;
+        bmi.biCompression = BI_RGB;
+
+        void* alphaSrcBits;
+        alphaSrcBitmap = CreateDIBSection(NULL, (BITMAPINFO*)&bmi, DIB_RGB_COLORS, &alphaSrcBits, NULL, 0);
+
+        if(alphaSrcBitmap)
+        {
+            if(GetDIBits(hdcScreen, bitmap, 0, 0, 0, (BITMAPINFO*)&bmi, DIB_RGB_COLORS) &&
+               bmi.biSizeImage > 0 &&
+               (bmi.biSizeImage % 4) == 0)
+            {
+                auto buf = (DWORD*)_aligned_malloc(bmi.biSizeImage, sizeof(DWORD));
+                if(buf)
+                {
+                    GetDIBits(hdcScreen, bitmap, 0, bm.bmHeight, buf, (BITMAPINFO*)&bmi, DIB_RGB_COLORS);
+
+                    BYTE* dest = (BYTE*)alphaSrcBits;
+                    for(const DWORD *src = buf, *end = (DWORD*)((BYTE*)buf + bmi.biSizeImage);
+                        src != end;
+                        ++src, ++dest)
+                    {
+                        BYTE a = *src >> 24;
+                        *dest++ = a;
+                        *dest++ = a;
+                        *dest++ = a;
+                    }
+
+                    _aligned_free(buf);
+                }
+            }
+        }
+    }
+
+    if(alphaSrcBitmap)
+    {
+        BITMAPINFOHEADER bmi = { sizeof(BITMAPINFOHEADER) };
+        bmi.biWidth = width;
+        bmi.biHeight = height;
+        bmi.biPlanes = 1;
+        bmi.biBitCount = 32;
+        bmi.biCompression = BI_RGB;
+
+        void* colorBits;
+        auto colorBitmap = CreateDIBSection(NULL, (BITMAPINFO*)&bmi, DIB_RGB_COLORS, &colorBits, NULL, 0);
+
+        void* alphaBits;
+        auto alphaBitmap = CreateDIBSection(NULL, (BITMAPINFO*)&bmi, DIB_RGB_COLORS, &alphaBits, NULL, 0);
+
+        HDC hdc = CreateCompatibleDC(NULL);
+        HDC hdcSrc = CreateCompatibleDC(NULL);
+
+        if(colorBitmap && alphaBitmap && hdc && hdcSrc)
+        {
+            SetStretchBltMode(hdc, HALFTONE);
+
+            // resize color channels
+            SelectObject(hdc, colorBitmap);
+            SelectObject(hdcSrc, bitmap);
+            StretchBlt(hdc, 0, 0, width, height, hdcSrc, 0, 0, bm.bmWidth, bm.bmHeight, SRCCOPY);
+
+            // resize alpha channel
+            SelectObject(hdc, alphaBitmap);
+            SelectObject(hdcSrc, alphaSrcBitmap);
+            StretchBlt(hdc, 0, 0, width, height, hdcSrc, 0, 0, bm.bmWidth, bm.bmHeight, SRCCOPY);
+
+            // flush before touching the bits
+            GdiFlush();
+
+            // apply the alpha channel
+            auto dest = (BYTE*)colorBits;
+            auto src = (const BYTE*)alphaBits;
+            auto end = src + (width * height * 4);
+            while(src != end)
+            {
+                dest[3] = src[0];
+                dest += 4;
+                src += 4;
+            }
+
+            // create the resulting bitmap
+            resultBitmap = CreateDIBitmap(hdcScreen, &bmi, CBM_INIT, colorBits, (BITMAPINFO*)&bmi, DIB_RGB_COLORS);
+        }
+
+        if(hdcSrc) DeleteDC(hdcSrc);
+        if(hdc) DeleteDC(hdc);
+
+        if(alphaBitmap) DeleteObject(alphaBitmap);
+        if(colorBitmap) DeleteObject(colorBitmap);
+
+        DeleteObject(alphaSrcBitmap);
+    }
+
+    ReleaseDC(NULL, hdcScreen);
+
+    return resultBitmap;
+}
+
+DesktopNotificationController::Toast::Toast(HWND hWnd, shared_ptr<NotificationData>* data) :
+    hWnd(hWnd), data(*data)
+{
+    HDC hdcScreen = GetDC(NULL);
+    hdc = CreateCompatibleDC(hdcScreen);
+    ReleaseDC(NULL, hdcScreen);
+}
+
+DesktopNotificationController::Toast::~Toast()
+{
+    DeleteDC(hdc);
+    if(bitmap) DeleteBitmap(bitmap);
+    if(scaledImage) DeleteBitmap(scaledImage);
+}
+
+void DesktopNotificationController::Toast::Register(HINSTANCE hInstance)
+{
+    WNDCLASSEX wc = { sizeof(wc) };
+    wc.lpfnWndProc = &Toast::WndProc;
+    wc.lpszClassName = className;
+    wc.cbWndExtra = sizeof(Toast*);
+    wc.hInstance = hInstance;
+    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
+
+    RegisterClassEx(&wc);
+}
+
+LRESULT DesktopNotificationController::Toast::WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+    switch(message)
+    {
+    case WM_CREATE:
+        {
+            auto& cs = reinterpret_cast<const CREATESTRUCT*&>(lParam);
+            auto inst = new Toast(hWnd, static_cast<shared_ptr<NotificationData>*>(cs->lpCreateParams));
+            SetWindowLongPtr(hWnd, 0, (LONG_PTR)inst);
+        }
+        break;
+
+    case WM_NCDESTROY:
+        delete Get(hWnd);
+        SetWindowLongPtr(hWnd, 0, 0);
+        return 0;
+
+    case WM_MOUSEACTIVATE:
+        return MA_NOACTIVATE;
+
+    case WM_TIMER:
+        if(wParam == TimerID_AutoDismiss)
+        {
+            Get(hWnd)->AutoDismiss();
+        }
+        return 0;
+
+    case WM_LBUTTONDOWN:
+        {
+            auto inst = Get(hWnd);
+
+            inst->Dismiss();
+
+            Notification notification(inst->data);
+            if(inst->isCloseHot)
+                inst->data->controller->OnNotificationDismissed(notification);
+            else
+                inst->data->controller->OnNotificationClicked(notification);
+        }
+        return 0;
+
+    case WM_MOUSEMOVE:
+        {
+            auto inst = Get(hWnd);
+            if(!inst->isHighlighted)
+            {
+                inst->isHighlighted = true;
+
+                TRACKMOUSEEVENT tme = { sizeof(tme), TME_LEAVE, hWnd };
+                TrackMouseEvent(&tme);
+            }
+
+            POINT cursor = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
+            inst->isCloseHot = (PtInRect(&inst->closeButtonRect, cursor) != FALSE);
+
+            if(!inst->isNonInteractive)
+                inst->CancelDismiss();
+
+            inst->UpdateContents();
+        }
+        return 0;
+
+    case WM_MOUSELEAVE:
+        {
+            auto inst = Get(hWnd);
+            inst->isHighlighted = false;
+            inst->isCloseHot = false;
+            inst->UpdateContents();
+
+            if(!inst->easeOutActive && inst->easeInPos == 1.0f)
+                inst->ScheduleDismissal();
+
+            // Make sure stack collapse happens if needed
+            inst->data->controller->StartAnimation();
+        }
+        return 0;
+
+    case WM_WINDOWPOSCHANGED:
+        {
+            auto& wp = reinterpret_cast<WINDOWPOS*&>(lParam);
+            if(wp->flags & SWP_HIDEWINDOW)
+            {
+                if(!IsWindowVisible(hWnd))
+                    Get(hWnd)->isHighlighted = false;
+            }
+        }
+        break;
+    }
+
+    return DefWindowProc(hWnd, message, wParam, lParam);
+}
+
+HWND DesktopNotificationController::Toast::Create(HINSTANCE hInstance, shared_ptr<NotificationData>& data)
+{
+    return CreateWindowEx(WS_EX_LAYERED | WS_EX_NOACTIVATE | WS_EX_TOPMOST, className, nullptr, WS_POPUP, 0, 0, 0, 0, NULL, NULL, hInstance, &data);
+}
+
+void DesktopNotificationController::Toast::Draw()
+{
+    const COLORREF accent = GetAccentColor();
+
+    COLORREF backColor;
+    {
+        // base background color is 2/3 of accent
+        // highlighted adds a bit of intensity to every channel
+
+        int h = isHighlighted ? (0xff / 20) : 0;
+
+        backColor = RGB(min(0xff, (GetRValue(accent) * 2 / 3) + h),
+                        min(0xff, (GetGValue(accent) * 2 / 3) + h),
+                        min(0xff, (GetBValue(accent) * 2 / 3) + h));
+    }
+
+    const float backLuma =
+        (GetRValue(backColor) * 0.299f / 255) +
+        (GetGValue(backColor) * 0.587f / 255) +
+        (GetBValue(backColor) * 0.114f / 255);
+
+    const struct { float r, g, b; } backF = {
+        GetRValue(backColor) / 255.0f,
+        GetGValue(backColor) / 255.0f,
+        GetBValue(backColor) / 255.0f,
+    };
+
+    COLORREF foreColor, dimmedColor;
+    {
+        // based on the lightness of background, we draw foreground in light or dark
+        // shades of gray blended onto the background with slight transparency
+        // to avoid sharp contrast
+
+        constexpr float alpha = 0.9f;
+        constexpr float intensityLight[] = { (1.0f * alpha), (0.8f * alpha) };
+        constexpr float intensityDark[] = { (0.1f * alpha), (0.3f * alpha) };
+
+        // select foreground intensity values (light or dark)
+        auto& i = (backLuma < 0.6f) ? intensityLight : intensityDark;
+
+        float r, g, b;
+
+        r = i[0] + backF.r * (1 - alpha);
+        g = i[0] + backF.g * (1 - alpha);
+        b = i[0] + backF.b * (1 - alpha);
+        foreColor = RGB(r * 0xff, g * 0xff, b * 0xff);
+
+        r = i[1] + backF.r * (1 - alpha);
+        g = i[1] + backF.g * (1 - alpha);
+        b = i[1] + backF.b * (1 - alpha);
+        dimmedColor = RGB(r * 0xff, g * 0xff, b * 0xff);
+    }
+
+    // Draw background
+    {
+        auto brush = CreateSolidBrush(backColor);
+
+        RECT rc = { 0, 0, toastSize.cx, toastSize.cy };
+        FillRect(hdc, &rc, brush);
+
+        DeleteBrush(brush);
+    }
+
+    SetBkMode(hdc, TRANSPARENT);
+
+    const auto close = L'\x2715';
+    auto captionFont = data->controller->GetCaptionFont();
+    auto bodyFont = data->controller->GetBodyFont();
+
+    TEXTMETRIC tmCap;
+    SelectFont(hdc, captionFont);
+    GetTextMetrics(hdc, &tmCap);
+
+    auto textOffsetX = margin.cx;
+
+    BITMAP imageInfo = {};
+    if(scaledImage)
+    {
+        GetObject(scaledImage, sizeof(imageInfo), &imageInfo);
+
+        textOffsetX += margin.cx + imageInfo.bmWidth;
+    }
+
+    // calculate close button rect
+    POINT closePos;
+    {
+        SIZE extent = {};
+        GetTextExtentPoint32W(hdc, &close, 1, &extent);
+
+        closeButtonRect.right = toastSize.cx;
+        closeButtonRect.top = 0;
+
+        closePos.x = closeButtonRect.right - margin.cy - extent.cx;
+        closePos.y = closeButtonRect.top + margin.cy;
+
+        closeButtonRect.left = closePos.x - margin.cy;
+        closeButtonRect.bottom = closePos.y + extent.cy + margin.cy;
+    }
+
+    // image
+    if(scaledImage)
+    {
+        HDC hdcImage = CreateCompatibleDC(NULL);
+        SelectBitmap(hdcImage, scaledImage);
+        BLENDFUNCTION blend = { AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };
+        AlphaBlend(hdc, margin.cx, margin.cy, imageInfo.bmWidth, imageInfo.bmHeight, hdcImage, 0, 0, imageInfo.bmWidth, imageInfo.bmHeight, blend);
+        DeleteDC(hdcImage);
+    }
+
+    // caption
+    {
+        RECT rc = {
+            textOffsetX,
+            margin.cy,
+            closeButtonRect.left,
+            toastSize.cy
+        };
+
+        SelectFont(hdc, captionFont);
+        SetTextColor(hdc, foreColor);
+        DrawText(hdc, data->caption.data(), (UINT)data->caption.length(), &rc, DT_SINGLELINE | DT_END_ELLIPSIS | DT_NOPREFIX);
+    }
+
+    // body text
+    if(!data->bodyText.empty())
+    {
+        RECT rc = {
+            textOffsetX,
+            2 * margin.cy + tmCap.tmAscent,
+            toastSize.cx - margin.cx,
+            toastSize.cy - margin.cy
+        };
+
+        SelectFont(hdc, bodyFont);
+        SetTextColor(hdc, dimmedColor);
+        DrawText(hdc, data->bodyText.data(), (UINT)data->bodyText.length(), &rc, DT_LEFT | DT_WORDBREAK | DT_NOPREFIX | DT_END_ELLIPSIS | DT_EDITCONTROL);
+    }
+
+    // close button
+    {
+        SelectFont(hdc, captionFont);
+        SetTextColor(hdc, isCloseHot ? foreColor : dimmedColor);
+        ExtTextOut(hdc, closePos.x, closePos.y, 0, nullptr, &close, 1, nullptr);
+    }
+
+    isContentUpdated = true;
+}
+
+void DesktopNotificationController::Toast::Invalidate()
+{
+    isContentUpdated = false;
+}
+
+bool DesktopNotificationController::Toast::IsRedrawNeeded() const
+{
+    return !isContentUpdated;
+}
+
+void DesktopNotificationController::Toast::UpdateBufferSize()
+{
+    if(hdc)
+    {
+        SIZE newSize;
+        {
+            TEXTMETRIC tmCap = {};
+            HFONT font = data->controller->GetCaptionFont();
+            if(font)
+            {
+                SelectFont(hdc, font);
+                if(!GetTextMetrics(hdc, &tmCap)) return;
+            }
+
+            TEXTMETRIC tmBody = {};
+            font = data->controller->GetBodyFont();
+            if(font)
+            {
+                SelectFont(hdc, font);
+                if(!GetTextMetrics(hdc, &tmBody)) return;
+            }
+
+            this->margin = { tmCap.tmAveCharWidth * 2, tmCap.tmAscent / 2 };
+
+            newSize.cx = margin.cx + (32 * tmCap.tmAveCharWidth) + margin.cx;
+            newSize.cy = margin.cy + (tmCap.tmHeight) + margin.cy;
+
+            if(!data->bodyText.empty())
+                newSize.cy += margin.cy + (3 * tmBody.tmHeight);
+
+            if(data->image)
+            {
+                BITMAP bm;
+                if(GetObject(data->image, sizeof(bm), &bm))
+                {
+                    // cap the image size
+                    const int maxDimSize = 80;
+
+                    auto width = bm.bmWidth;
+                    auto height = bm.bmHeight;
+                    if(width < height)
+                    {
+                        if(height > maxDimSize)
+                        {
+                            width = width * maxDimSize / height;
+                            height = maxDimSize;
+                        }
+                    }
+                    else
+                    {
+                        if(width > maxDimSize)
+                        {
+                            height = height * maxDimSize / width;
+                            width = maxDimSize;
+                        }
+                    }
+
+                    ScreenMetrics scr;
+                    SIZE imageDrawSize = { scr.X(width), scr.Y(height) };
+
+                    newSize.cx += imageDrawSize.cx + margin.cx;
+
+                    auto heightWithImage = margin.cy + (imageDrawSize.cy) + margin.cy;
+                    if(newSize.cy < heightWithImage) newSize.cy = heightWithImage;
+
+                    UpdateScaledImage(imageDrawSize);
+                }
+            }
+        }
+
+        if(newSize.cx != this->toastSize.cx || newSize.cy != this->toastSize.cy)
+        {
+            HDC hdcScreen = GetDC(NULL);
+            auto newBitmap = CreateCompatibleBitmap(hdcScreen, newSize.cx, newSize.cy);
+            ReleaseDC(NULL, hdcScreen);
+
+            if(newBitmap)
+            {
+                if(SelectBitmap(hdc, newBitmap))
+                {
+                    RECT dirty1 = {}, dirty2 = {};
+                    if(toastSize.cx < newSize.cx) dirty1 = { toastSize.cx, 0, newSize.cx, toastSize.cy };
+                    if(toastSize.cy < newSize.cy) dirty2 = { 0, toastSize.cy, newSize.cx, newSize.cy };
+
+                    if(this->bitmap) DeleteBitmap(this->bitmap);
+                    this->bitmap = newBitmap;
+                    this->toastSize = newSize;
+
+                    Invalidate();
+
+                    // Resize also the DWM buffer to prevent flicker during window resizing.
+                    // Make sure any existing data is not overwritten by marking the dirty region.
+                    {
+                        POINT origin = { 0, 0 };
+
+                        UPDATELAYEREDWINDOWINFO ulw;
+                        ulw.cbSize = sizeof(ulw);
+                        ulw.hdcDst = NULL;
+                        ulw.pptDst = nullptr;
+                        ulw.psize = &toastSize;
+                        ulw.hdcSrc = hdc;
+                        ulw.pptSrc = &origin;
+                        ulw.crKey = 0;
+                        ulw.pblend = nullptr;
+                        ulw.dwFlags = 0;
+                        ulw.prcDirty = &dirty1;
+                        auto b1 = UpdateLayeredWindowIndirect(hWnd, &ulw);
+                        ulw.prcDirty = &dirty2;
+                        auto b2 = UpdateLayeredWindowIndirect(hWnd, &ulw);
+                        _ASSERT(b1 && b2);
+                    }
+
+                    return;
+                }
+
+                DeleteBitmap(newBitmap);
+            }
+        }
+    }
+}
+
+void DesktopNotificationController::Toast::UpdateScaledImage(const SIZE& size)
+{
+    BITMAP bm;
+    if(!GetObject(scaledImage, sizeof(bm), &bm) ||
+       bm.bmWidth != size.cx ||
+       bm.bmHeight != size.cy)
+    {
+        if(scaledImage) DeleteBitmap(scaledImage);
+        scaledImage = StretchBitmap(data->image, size.cx, size.cy);
+    }
+}
+
+void DesktopNotificationController::Toast::UpdateContents()
+{
+    Draw();
+
+    if(IsWindowVisible(hWnd))
+    {
+        RECT rc;
+        GetWindowRect(hWnd, &rc);
+        POINT origin = { 0, 0 };
+        SIZE size = { rc.right - rc.left, rc.bottom - rc.top };
+        UpdateLayeredWindow(hWnd, NULL, nullptr, &size, hdc, &origin, 0, nullptr, 0);
+    }
+}
+
+void DesktopNotificationController::Toast::Dismiss()
+{
+    if(!isNonInteractive)
+    {
+        // Set a flag to prevent further interaction. We don't disable the HWND because
+        // we still want to receive mouse move messages in order to keep the toast under
+        // the cursor and not collapse it while dismissing.
+        isNonInteractive = true;
+
+        AutoDismiss();
+    }
+}
+
+void DesktopNotificationController::Toast::AutoDismiss()
+{
+    KillTimer(hWnd, TimerID_AutoDismiss);
+    StartEaseOut();
+}
+
+void DesktopNotificationController::Toast::CancelDismiss()
+{
+    KillTimer(hWnd, TimerID_AutoDismiss);
+    easeOutActive = false;
+    easeOutPos = 0;
+}
+
+void DesktopNotificationController::Toast::ScheduleDismissal()
+{
+    SetTimer(hWnd, TimerID_AutoDismiss, 4000, nullptr);
+}
+
+void DesktopNotificationController::Toast::ResetContents()
+{
+    if(scaledImage)
+    {
+        DeleteBitmap(scaledImage);
+        scaledImage = NULL;
+    }
+
+    Invalidate();
+}
+
+void DesktopNotificationController::Toast::PopUp(int y)
+{
+    verticalPosTarget = verticalPos = y;
+    StartEaseIn();
+}
+
+void DesktopNotificationController::Toast::SetVerticalPosition(int y)
+{
+    // Don't restart animation if current target is the same
+    if(y == verticalPosTarget)
+        return;
+
+    // Make sure the new animation's origin is at the current position
+    verticalPos += (int)((verticalPosTarget - verticalPos) * stackCollapsePos);
+
+    // Set new target position and start the animation
+    verticalPosTarget = y;
+    stackCollapseStart = GetTickCount();
+    data->controller->StartAnimation();
+}
+
+HDWP DesktopNotificationController::Toast::Animate(HDWP hdwp, const POINT& origin)
+{
+    UpdateBufferSize();
+
+    if(IsRedrawNeeded())
+        Draw();
+
+    POINT srcOrigin = { 0, 0 };
+
+    UPDATELAYEREDWINDOWINFO ulw;
+    ulw.cbSize = sizeof(ulw);
+    ulw.hdcDst = NULL;
+    ulw.pptDst = nullptr;
+    ulw.psize = nullptr;
+    ulw.hdcSrc = hdc;
+    ulw.pptSrc = &srcOrigin;
+    ulw.crKey = 0;
+    ulw.pblend = nullptr;
+    ulw.dwFlags = 0;
+    ulw.prcDirty = nullptr;
+
+    POINT pt = { 0, 0 };
+    SIZE size = { 0, 0 };
+    BLENDFUNCTION blend;
+    UINT dwpFlags = SWP_NOACTIVATE | SWP_SHOWWINDOW | SWP_NOREDRAW | SWP_NOCOPYBITS;
+
+    auto easeInPos = AnimateEaseIn();
+    auto easeOutPos = AnimateEaseOut();
+    auto stackCollapsePos = AnimateStackCollapse();
+
+    auto yOffset = (verticalPosTarget - verticalPos) * stackCollapsePos;
+
+    size.cx = (int)(toastSize.cx * easeInPos);
+    size.cy = toastSize.cy;
+
+    pt.x = origin.x - size.cx;
+    pt.y = (int)(origin.y - verticalPos - yOffset - size.cy);
+
+    ulw.pptDst = &pt;
+    ulw.psize = &size;
+
+    if(easeInActive && easeInPos == 1.0f)
+    {
+        easeInActive = false;
+        ScheduleDismissal();
+    }
+
+    this->easeInPos = easeInPos;
+    this->stackCollapsePos = stackCollapsePos;
+
+    if(easeOutPos != this->easeOutPos)
+    {
+        blend.BlendOp = AC_SRC_OVER;
+        blend.BlendFlags = 0;
+        blend.SourceConstantAlpha = (BYTE)(255 * (1.0f - easeOutPos));
+        blend.AlphaFormat = 0;
+
+        ulw.pblend = &blend;
+        ulw.dwFlags = ULW_ALPHA;
+
+        this->easeOutPos = easeOutPos;
+
+        if(easeOutPos == 1.0f)
+        {
+            easeOutActive = false;
+
+            dwpFlags &= ~SWP_SHOWWINDOW;
+            dwpFlags |= SWP_HIDEWINDOW;
+        }
+    }
+
+    if(stackCollapsePos == 1.0f)
+    {
+        verticalPos = verticalPosTarget;
+    }
+
+    // `UpdateLayeredWindowIndirect` updates position, size, and transparency.
+    // `DeferWindowPos` updates z-order, and also position and size in case ULWI fails,
+    // which can happen when one of the dimensions is zero (e.g. at the beginning of ease-in).
+
+    auto ulwResult = UpdateLayeredWindowIndirect(hWnd, &ulw);
+    hdwp = DeferWindowPos(hdwp, hWnd, HWND_TOPMOST, pt.x, pt.y, size.cx, size.cy, dwpFlags);
+    return hdwp;
+}
+
+void DesktopNotificationController::Toast::StartEaseIn()
+{
+    _ASSERT(!easeInActive);
+    easeInStart = GetTickCount();
+    easeInActive = true;
+    data->controller->StartAnimation();
+}
+
+void DesktopNotificationController::Toast::StartEaseOut()
+{
+    _ASSERT(!easeOutActive);
+    easeOutStart = GetTickCount();
+    easeOutActive = true;
+    data->controller->StartAnimation();
+}
+
+bool DesktopNotificationController::Toast::IsStackCollapseActive() const
+{
+    return (verticalPos != verticalPosTarget);
+}
+
+float DesktopNotificationController::Toast::AnimateEaseIn()
+{
+    if(!easeInActive)
+        return easeInPos;
+
+    constexpr float duration = 500.0f;
+    float time = std::min(duration, (float)(GetTickCount() - easeInStart)) / duration;
+
+    // decelerating exponential ease
+    const float a = -8.0f;
+    auto pos = (std::exp(a * time) - 1.0f) / (std::exp(a) - 1.0f);
+
+    return pos;
+}
+
+float DesktopNotificationController::Toast::AnimateEaseOut()
+{
+    if(!easeOutActive)
+        return easeOutPos;
+
+    constexpr float duration = 120.0f;
+    float time = std::min(duration, (float)(GetTickCount() - easeOutStart)) / duration;
+
+    // accelerating circle ease
+    auto pos = 1.0f - std::sqrt(1 - time * time);
+
+    return pos;
+}
+
+float DesktopNotificationController::Toast::AnimateStackCollapse()
+{
+    if(!IsStackCollapseActive())
+        return stackCollapsePos;
+
+    constexpr float duration = 500.0f;
+    float time = std::min(duration, (float)(GetTickCount() - stackCollapseStart)) / duration;
+
+    // decelerating exponential ease
+    const float a = -8.0f;
+    auto pos = (std::exp(a * time) - 1.0f) / (std::exp(a) - 1.0f);
+
+    return pos;
+}
+
+}

brightray/browser/win/win32_desktop_notifications/toast.h

@@ -0,0 +1,99 @@
+#pragma once
+#include "desktop_notification_controller.h"
+
+namespace brightray {
+
+class DesktopNotificationController::Toast
+{
+public:
+    static void Register(HINSTANCE hInstance);
+    static HWND Create(HINSTANCE hInstance, std::shared_ptr<NotificationData>& data);
+    static Toast* Get(HWND hWnd)
+    {
+        return reinterpret_cast<Toast*>(GetWindowLongPtr(hWnd, 0));
+    }
+
+    static LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
+
+    const std::shared_ptr<NotificationData>& GetNotification() const
+    {
+        return data;
+    }
+
+    void ResetContents();
+
+    void Dismiss();
+
+    void PopUp(int y);
+    void SetVerticalPosition(int y);
+    int GetVerticalPosition() const
+    {
+        return verticalPosTarget;
+    }
+    int GetHeight() const
+    {
+        return toastSize.cy;
+    }
+    HDWP Animate(HDWP hdwp, const POINT& origin);
+    bool IsAnimationActive() const
+    {
+        return easeInActive || easeOutActive || IsStackCollapseActive();
+    }
+    bool IsHighlighted() const
+    {
+        _ASSERT(!(isHighlighted && !IsWindowVisible(hWnd)));
+        return isHighlighted;
+    }
+
+private:
+    enum TimerID {
+        TimerID_AutoDismiss = 1
+    };
+
+    Toast(HWND hWnd, std::shared_ptr<NotificationData>* data);
+    ~Toast();
+
+    void UpdateBufferSize();
+    void UpdateScaledImage(const SIZE& size);
+    void Draw();
+    void Invalidate();
+    bool IsRedrawNeeded() const;
+    void UpdateContents();
+
+    void AutoDismiss();
+    void CancelDismiss();
+    void ScheduleDismissal();
+
+    void StartEaseIn();
+    void StartEaseOut();
+    bool IsStackCollapseActive() const;
+
+    float AnimateEaseIn();
+    float AnimateEaseOut();
+    float AnimateStackCollapse();
+
+private:
+    static constexpr const TCHAR className[] = TEXT("DesktopNotificationToast");
+
+    const HWND hWnd;
+    HDC hdc;
+    HBITMAP bitmap = NULL;
+
+    const std::shared_ptr<NotificationData> data; // never null
+
+    SIZE toastSize = {};
+    SIZE margin = {};
+    RECT closeButtonRect = {};
+    HBITMAP scaledImage = NULL;
+
+    int verticalPos = 0;
+    int verticalPosTarget = 0;
+    bool isNonInteractive = false;
+    bool easeInActive = false;
+    bool easeOutActive = false;
+    bool isContentUpdated = false, isHighlighted = false, isCloseHot = false;
+    DWORD easeInStart, easeOutStart, stackCollapseStart;
+    float easeInPos = 0, easeOutPos = 0, stackCollapsePos = 0;
+};
+
+}

brightray/browser/win/win32_notification.cc

@@ -0,0 +1,60 @@
+#define WIN32_LEAN_AND_MEAN
+#include "win32_notification.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include <windows.h>
+
+namespace brightray {
+
+void Win32Notification::Show(const base::string16& title, const base::string16& msg, const std::string& tag, const GURL& icon_url, const SkBitmap& icon, const bool silent)
+{
+    auto presenter = static_cast<NotificationPresenterWin7*>(this->presenter());
+    if(!presenter) return;
+
+    HBITMAP image = NULL;
+
+    if(!icon.drawsNothing())
+    {
+        if(icon.colorType() == kBGRA_8888_SkColorType)
+        {
+            icon.lockPixels();
+
+            BITMAPINFOHEADER bmi = { sizeof(BITMAPINFOHEADER) };
+            bmi.biWidth = icon.width();
+            bmi.biHeight = -icon.height();
+            bmi.biPlanes = 1;
+            bmi.biBitCount = 32;
+            bmi.biCompression = BI_RGB;
+
+            HDC hdcScreen = GetDC(NULL);
+            image = CreateDIBitmap(hdcScreen, &bmi, CBM_INIT, icon.getPixels(), (BITMAPINFO*)&bmi, DIB_RGB_COLORS);
+            ReleaseDC(NULL, hdcScreen);
+
+            icon.unlockPixels();
+        }
+    }
+
+    Win32Notification* existing = nullptr;
+    if(!tag.empty()) existing = presenter->GetNotificationObjectByTag(tag);
+
+    if(existing)
+    {
+        existing->tag.clear();
+        this->notificationRef = std::move(existing->notificationRef);
+        this->notificationRef.Set(title, msg, image);
+    }
+    else
+    {
+        this->notificationRef = presenter->AddNotification(title, msg, image);
+    }
+
+    this->tag = tag;
+
+    if(image) DeleteObject(image);
+}
+
+void Win32Notification::Dismiss()
+{
+    notificationRef.Close();
+}
+
+}

brightray/browser/win/win32_notification.h

@@ -0,0 +1,30 @@
+#pragma once
+#include "browser/notification.h"
+#include "browser/win/notification_presenter_win7.h"
+
+namespace brightray {
+
+class Win32Notification : public brightray::Notification
+{
+public:
+    Win32Notification(NotificationDelegate* delegate, NotificationPresenterWin7* presenter) : Notification(delegate, presenter) {}
+    void Show(const base::string16& title, const base::string16& msg, const std::string& tag, const GURL& icon_url, const SkBitmap& icon, const bool silent) override;
+    void Dismiss() override;
+
+    const DesktopNotificationController::Notification& GetRef() const
+    {
+        return notificationRef;
+    }
+
+    const std::string& GetTag() const
+    {
+        return tag;
+    }
+
+private:
+    DISALLOW_COPY_AND_ASSIGN(Win32Notification);
+    DesktopNotificationController::Notification notificationRef;
+    std::string tag;
+};
+
+}

brightray/filenames.gypi

@@ -84,12 +84,21 @@
       'browser/linux/libnotify_notification.cc',
       'browser/linux/notification_presenter_linux.h',
       'browser/linux/notification_presenter_linux.cc',
-      'browser/win/notification_presenter_win.h',
       'browser/win/notification_presenter_win.cc',
-      'browser/win/windows_toast_notification.h',
+      'browser/win/notification_presenter_win.h',
-      'browser/win/windows_toast_notification.cc',
+      'browser/win/notification_presenter_win7.cc',
-      'browser/win/scoped_hstring.h',
+      'browser/win/notification_presenter_win7.h',
       'browser/win/scoped_hstring.cc',
+      'browser/win/scoped_hstring.h',
+      'browser/win/win32_desktop_notifications/common.h',
+      'browser/win/win32_desktop_notifications/desktop_notification_controller.cc',
+      'browser/win/win32_desktop_notifications/desktop_notification_controller.h',
+      'browser/win/win32_desktop_notifications/toast.cc',
+      'browser/win/win32_desktop_notifications/toast.h',
+      'browser/win/win32_notification.cc',
+      'browser/win/win32_notification.h',
+      'browser/win/windows_toast_notification.cc',
+      'browser/win/windows_toast_notification.h',
       'browser/special_storage_policy.cc',
       'browser/special_storage_policy.h',
       'browser/url_request_context_getter.cc',