feat: adapt monochrome controls with low-rate perimeter sampling

Author: Fryingpan-Jason

experiments/glass_control_island.h

@@ -14,6 +14,7 @@
 #include <functional>
 #include <string>
 #include <utility>
+#include "../src/glass_control_appearance.h"
 
 namespace GlassControlIsland {
 
@@ -98,7 +99,7 @@ class Controller {
                     static_cast<LONG>(std::lround(centerY + radius))};
         }
     };
-    Controller() = default;
+    Controller() {appearanceFade_.Reset(RGB(0,0,0));}
     Controller(const Controller&) = delete;
     Controller& operator=(const Controller&) = delete;
     ~Controller() { Destroy(); }
@@ -185,7 +186,8 @@ class Controller {
 
     void Update(const RECT& noteRect, UINT dpi, bool visible, bool topmost,
                 bool passThrough, bool menuOpen, HWND noteWindow = nullptr, int cornerRadiusPx = 0,
-                bool folded = false, float foldProgress = 1.0f, bool noteTransition = false) {
+                bool folded = false, float foldProgress = 1.0f, bool noteTransition = false,
+                COLORREF backingColour=0,int backingAlpha=0) {
         if (!window_)
             return;
         const UINT newDpi = dpi ? dpi : 96;
@@ -205,7 +207,11 @@ class Controller {
         menuOpen_ = effectiveMenuOpen;
         // Retain the API for the host, but note/body hover and note capture are
         // deliberately no longer expansion sources, including click-through.
-        (void)noteWindow;
+        DWORD affinity=WDA_NONE;
+        if(noteWindow)GetWindowDisplayAffinity(noteWindow,&affinity);
+        appearanceRequest_.note=noteRect;appearanceRequest_.tint=backingColour;
+        appearanceRequest_.radius=cornerRadiusPx;
+        appearanceRequest_.alpha=!folded && affinity==WDA_EXCLUDEFROMCAPTURE?std::clamp(backingAlpha,0,255):0;
         noteRect_ = noteRect;
         cornerRadiusPx_ = std::max(0, cornerRadiusPx);
         const bool previousBelow = below_;
@@ -238,6 +244,7 @@ class Controller {
                          (flags & ~(SWP_SHOWWINDOW | SWP_HIDEWINDOW)));
         }
         if (!visible) {
+            appearanceRequest_.enabled=false;appearanceSampler_.Submit(appearanceRequest_);
             KillTimer(window_, kHoverTimer);
             KillTimer(window_, kMotionTimer);
             motionRunning_ = false;
@@ -272,9 +279,12 @@ class Controller {
         PollHover();
         if (geometryChanged || appearanceChanged || visibilityChanged || previousBelow != below_)
             Render();
+        PollAppearance();
     }
 
     void Destroy() {
+        appearanceSampler_.Stop();
+        for(auto& raster:rasters_)raster.Clear();
         closePointerDown_ = false;
         if (closeWindow_) {
             if (GetCapture() == closeWindow_) ReleaseCapture();
@@ -377,6 +387,13 @@ class Controller {
     Detail::Spring foldedHover_;
     Detail::DotImpulse dotImpulse_;
     float settingsTint_ = 0, closeTint_ = 0;
+    std::array<GlassControlAppearance::Raster,2> rasters_;
+    GlassControlAppearance::Sampler appearanceSampler_;
+    GlassControlAppearance::Request appearanceRequest_;
+    GlassAutoInk::Decision appearanceDecision_;
+    GlassAutoInk::Fade appearanceFade_;
+    unsigned appearanceSeen_=0;
+    float lightAppearance_=0;
     float foldProgress_ = 1.0f;
     bool noteTransition_ = false, transitionToFold_ = false;
     float insideCenterY_ = 0, outsideCenterY_ = 0, foldedCenterY_ = 0;
@@ -665,6 +682,7 @@ class Controller {
     void Animate() {
         if (!window_ || !visible_) return;
         if (reduceMotion_) {
+            lightAppearance_=GetRValue(appearanceFade_.target)/255.f;
             dotImpulse_.Clear();
             expansion_.value = expanded_ && ExpansionAllowed() ? 1.0f : 0.0f;
             expansion_.velocity = 0;
@@ -692,6 +710,8 @@ class Controller {
         // A faster, more pronounced rise and a short elastic settle. Retain
         // velocity when the pointer reverses instead of restarting an easing.
         bool active = expansion_.Step(expanded_ && ExpansionAllowed() ? 1.0f : 0.0f, seconds, 32.0f, 0.72f);
+        lightAppearance_=GetRValue(appearanceFade_.Sample(double(now)))/255.f;
+        active |= appearanceFade_.Running(double(now));
         active |= foldedHover_.Step(folded_ && !noteTransition_ && !inputSuppressed_ && hover_ ? 1.0f : 0.0f, seconds);
         active |= Detail::Fade(settingsTint_, hover_ && !closeHover_ && !inputSuppressed_ && !noteTransition_ ? 1.0f : 0.0f, seconds);
         active |= Detail::Fade(closeTint_, closeHover_ && ExpansionAllowed() ? 1.0f : 0.0f, seconds);
@@ -704,6 +724,28 @@ class Controller {
             KillTimer(window_, kMotionTimer);
             motionRunning_ = false;
         }
+        PollAppearance();
+    }
+
+    void PollAppearance() {
+        auto request=appearanceRequest_;
+        const auto rectangles=VisibleSurfaceRects();request.surface=rectangles[0];
+        if(rectangles[1].right>rectangles[1].left)UnionRect(&request.surface,&request.surface,&rectangles[1]);
+        request.padding=std::max(6,Scale(6));request.guard=std::max(2,Scale(3));
+        request.enabled=visible_ && !highContrast_ && !noteTransition_ && !inputSuppressed_;
+        appearanceSampler_.Submit(request);
+        double share=0;
+        if(appearanceSampler_.Read(appearanceSeen_,share))appearanceDecision_.Update(share,double(GetTickCount64()));
+        // Keep the chosen X colour throughout red hover, including its retreat.
+        if(closeHover_ || closePointerDown_ || closeTint_>.001f) {
+            const int c=int(std::lround(lightAppearance_*255));appearanceFade_.Reset(RGB(c,c,c));return;
+        }
+        if(!request.enabled || !appearanceDecision_.valid)return;
+        const COLORREF target=appearanceDecision_.white?RGB(255,255,255):RGB(0,0,0);
+        if(!appearanceFade_.initialized || appearanceFade_.target!=target) {
+            const int c=int(std::lround(lightAppearance_*255));
+            appearanceFade_.Aim(target,RGB(c,c,c),double(GetTickCount64()));Animate();
+        }
     }
 
     static void RoundPath(Gdiplus::GraphicsPath& path, float x, float y,
@@ -778,22 +820,9 @@ class Controller {
         const int height = static_cast<int>(bounds_.bottom - bounds_.top);
         if (width <= 0 || height <= 0)
             return;
-        BITMAPINFO info{};
-        info.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
-        info.bmiHeader.biWidth = width;
-        info.bmiHeader.biHeight = -height;
-        info.bmiHeader.biPlanes = 1;
-        info.bmiHeader.biBitCount = 32;
-        info.bmiHeader.biCompression = BI_RGB;
-        void* pixels = nullptr;
-        HDC dc = CreateCompatibleDC(nullptr);
-        HBITMAP dib = CreateDIBSection(dc, &info, DIB_RGB_COLORS, &pixels, nullptr, 0);
-        if (!dc || !dib || !pixels) {
-            if (dib) DeleteObject(dib);
-            if (dc) DeleteDC(dc);
-            return;
-        }
-        const HGDIOBJ old = SelectObject(dc, dib);
+        auto& raster=rasters_[close?1:0];
+        if(!raster.Ensure(width,height))return;
+        void* pixels=raster.pixels;HDC dc=raster.dc;
         {
             // GDI+ writes premultiplied BGRA directly, including edge coverage.
             // Do not re-premultiply these pixels after drawing.
@@ -839,15 +868,12 @@ class Controller {
             graphics.TranslateTransform(38.0f, centerY);
             graphics.ScaleTransform(surface.width / 72.0f, 1.0f);
             graphics.TranslateTransform(-38.0f, -centerY);
-            const float materialWeight = std::max(glyphAlpha, folded_ ? foldProgress_ : 0.0f);
-            Gdiplus::Color background = Mix(Gdiplus::Color(248, 64, 66, 70),
-                                              Gdiplus::Color(248, 48, 50, 54), materialWeight);
-            Gdiplus::Color settingsBackground = Mix(background, Gdiplus::Color(252, 72, 75, 80), settingsTint_);
+            Gdiplus::Color background = Mix(Gdiplus::Color(255,0,0,0),Gdiplus::Color(255,255,255,255),lightAppearance_);
+            Gdiplus::Color settingsBackground = background;
             Gdiplus::Color closeBackground = Mix(background, Gdiplus::Color(255, 220, 52, 65), closeTint_);
             closeBackground = Mix(settingsBackground, closeBackground, separation);
-            Gdiplus::Color foreground(255, 245, 247, 251);
-            Gdiplus::Color closeForeground = Mix(Gdiplus::Color(255, 255, 112, 113),
-                                                   Gdiplus::Color(255, 255, 255, 255), closeTint_);
+            Gdiplus::Color foreground(255,255-background.GetR(),255-background.GetG(),255-background.GetB());
+            Gdiplus::Color closeForeground = foreground;
             if (highContrast_) {
                 const COLORREF bg = GetSysColor(COLOR_BTNFACE), fg = GetSysColor(COLOR_BTNTEXT);
                 settingsBackground = Gdiplus::Color(255, GetRValue(bg), GetGValue(bg), GetBValue(bg));
@@ -871,9 +897,7 @@ class Controller {
             Gdiplus::SolidBrush closeFill(closeBackground);
             graphics.FillPath(&closeFill, &path);
             graphics.Restore(surfaceClip);
-            Gdiplus::Pen rim(Gdiplus::Color(highContrast_ ? 255 : 52, foreground.GetR(), foreground.GetG(),
-                                           foreground.GetB()), 0.65f);
-            graphics.DrawPath(&rim, &path);
+            if(highContrast_) {Gdiplus::Pen rim(foreground,0.65f);graphics.DrawPath(&rim,&path);}
             if (glyphAlpha > 0) {
                 Gdiplus::Color crossColor(static_cast<BYTE>(255 * glyphAlpha), closeForeground.GetR(),
                                           closeForeground.GetG(), closeForeground.GetB());
@@ -888,6 +912,10 @@ class Controller {
                 line.SetStartCap(Gdiplus::LineCapRound);
                 line.SetEndCap(Gdiplus::LineCapRound);
                 Gdiplus::SolidBrush knob(glyph);
+                const auto glyphTransform=graphics.Save();
+                graphics.TranslateTransform(24,centerY);
+                graphics.ScaleTransform(1+.06f*settingsTint_,1+.06f*settingsTint_);
+                graphics.TranslateTransform(-24,-centerY);
                 // Original vector artwork: three adjustment tracks with alternating
                 // handles, not a vendor font glyph or an embedded platform asset.
                 const float rows[] = {centerY - 5.0f, centerY, centerY + 5.0f};
@@ -898,9 +926,9 @@ class Controller {
                     graphics.FillEllipse(&cutout, handles[row] - 3, rows[row] - 3, 6.0f, 6.0f);
                     graphics.FillEllipse(&knob, handles[row] - 1.9f, rows[row] - 1.9f, 3.8f, 3.8f);
                 }
+                graphics.Restore(glyphTransform);
                 if (passThrough_) {
-                    Gdiplus::SolidBrush status(highContrast_ ? glyph :
-                        Gdiplus::Color(static_cast<BYTE>(255 * glyphAlpha), 111, 190, 255));
+                    Gdiplus::SolidBrush status(glyph);
                     graphics.FillEllipse(&status, 36.0f, centerY + 5.0f, 2.5f, 2.5f);
                 }
             }
@@ -920,9 +948,6 @@ class Controller {
         SIZE size{width, height};
         BLENDFUNCTION blend{AC_SRC_OVER, 0, 255, AC_SRC_ALPHA};
         UpdateLayeredWindow(target, nullptr, &destination, &size, dc, &source, 0, &blend, ULW_ALPHA);
-        SelectObject(dc, old);
-        DeleteObject(dib);
-        DeleteDC(dc);
     }
 
     void FinishPointer(bool click) {
@@ -1124,6 +1149,7 @@ class Controller {
             }
             if (wp == kHoverTimer) {
                 PollHover();
+                PollAppearance();
                 return 0;
             }
             break;

experiments/glass_experience.h

@@ -86,7 +86,8 @@ void SyncExperienceUI() {
     experienceIsland.Update(anchor,GetDpiForWindow(g_window),g_isVisible && (experienceFolded || IsWindowVisible(g_window)) && !IsIconic(g_window),
         state.pinned,state.passThrough,experiencePanel.Visible() || experienceCloseDialogOpen || experienceColorDialogOpen,
         g_window,ScaleForDpi(g_window,NoteCornerRadius()),experienceFolded || ExperienceAbsorbing(),
-        experienceAbsorbProgress,ExperienceAbsorbing());
+        experienceAbsorbProgress,ExperienceAbsorbing(),g_settings.themeColor,
+        std::max(g_settings.passThrough?0:1,MulDiv(EffectiveOpacityPercent(),255,100)));
     // Activation/restoration can raise the note above its independent hint.
     // Insert the controls immediately above the note, preserving applications
     // already above it rather than raising the controls to the top of the band.

src/glass_control_appearance.h

@@ -0,0 +1,121 @@
+#pragma once
+#include "glass_auto_ink.h"
+#include <chrono>
+#include <condition_variable>
+#include <mutex>
+#include <thread>
+#include <functional>
+
+namespace GlassControlAppearance {
+// Owned by one thread. Retain DIB/DC allocations across animation frames and
+// background samples; no screen image is written to disk.
+struct Raster {
+    HDC dc=nullptr;HBITMAP bitmap=nullptr;HGDIOBJ old=nullptr;
+    void* pixels=nullptr;int width=0,height=0;unsigned allocations=0;
+    Raster()=default;Raster(const Raster&)=delete;Raster& operator=(const Raster&)=delete;
+    ~Raster(){Clear();}
+    void Clear(){if(dc && old)SelectObject(dc,old);if(bitmap)DeleteObject(bitmap);if(dc)DeleteDC(dc);dc=nullptr;bitmap=nullptr;old=nullptr;pixels=nullptr;width=height=0;}
+    bool Ensure(int w,int h) {
+        if(w==width && h==height && pixels)return true;
+        if(w<=0 || h<=0 || w>2048 || h>1024)return false;
+        Clear();BITMAPINFO info{};info.bmiHeader.biSize=sizeof(BITMAPINFOHEADER);
+        info.bmiHeader.biWidth=w;info.bmiHeader.biHeight=-h;info.bmiHeader.biPlanes=1;
+        info.bmiHeader.biBitCount=32;info.bmiHeader.biCompression=BI_RGB;
+        dc=CreateCompatibleDC(nullptr);
+        if(dc)bitmap=CreateDIBSection(dc,&info,DIB_RGB_COLORS,&pixels,nullptr,0);
+        if(!dc || !bitmap || !pixels){Clear();return false;}
+        old=SelectObject(dc,bitmap);width=w;height=h;++allocations;return true;
+    }
+};
+struct Request {
+    RECT surface{},note{};int padding=6,guard=2,radius=0,alpha=0;COLORREF tint=0;
+    bool enabled=false;
+};
+inline bool Same(const Request& a,const Request& b) {
+    return EqualRect(&a.surface,&b.surface) && EqualRect(&a.note,&b.note) && a.padding==b.padding &&
+        a.guard==b.guard && a.radius==b.radius && a.alpha==b.alpha && a.tint==b.tint && a.enabled==b.enabled;
+}
+inline bool Inside(RECT r,int x,int y){return x>=r.left && x<r.right && y>=r.top && y<r.bottom;}
+inline bool InsideNote(const Request& r,int x,int y) {
+    if(!Inside(r.note,x,y))return false;
+    float cx=(r.note.left+r.note.right)*.5f,cy=(r.note.top+r.note.bottom)*.5f;
+    float radius=float(std::min({r.radius,int(r.note.right-r.note.left)/2,int(r.note.bottom-r.note.top)/2}));
+    float qx=std::max(std::abs(x+.5f-cx)-(r.note.right-r.note.left)*.5f+radius,0.f);
+    float qy=std::max(std::abs(y+.5f-cy)-(r.note.bottom-r.note.top)*.5f+radius,0.f);
+    return qx*qx+qy*qy<=radius*radius;
+}
+inline bool Vote(const Raster& raster,RECT crop,const Request& request,double& darkShare) {
+    RECT excluded=request.surface;InflateRect(&excluded,request.guard,request.guard);
+    int dark=0,total=0;
+    const int step=std::max(1,int(std::sqrt(double(raster.width)*raster.height/512)));
+    for(int y=step/2;y<raster.height;y+=step)for(int x=step/2;x<raster.width;x+=step) {
+        const int sx=crop.left+x,sy=crop.top+y;
+        if(Inside(excluded,sx,sy))continue;
+        const auto p=static_cast<const BYTE*>(raster.pixels)+(size_t(y)*raster.width+x)*4;
+        int red=p[2],green=p[1],blue=p[0];
+        // Capture-excluded notes may be absent from BitBlt. Restore only their
+        // known overlay tint for perimeter samples inside the rounded note.
+        if(request.alpha>0 && InsideNote(request,sx,sy)) {
+            auto mix=[&](int a,int b){return (a*(255-request.alpha)+b*request.alpha+127)/255;};
+            red=mix(red,GetRValue(request.tint));green=mix(green,GetGValue(request.tint));blue=mix(blue,GetBValue(request.tint));
+        }
+        dark+=GlassAutoInk::PrefersWhite(RGB(red,green,blue));++total;
+    }
+    if(total<8)return false;
+    darkShare=double(dark)/total;return true;
+}
+inline bool Capture(Raster& raster,const Request& request,double& darkShare) {
+    RECT crop=request.surface;InflateRect(&crop,request.padding,request.padding);
+    MONITORINFO monitor{sizeof(monitor)};
+    if(!GetMonitorInfoW(MonitorFromRect(&request.surface,MONITOR_DEFAULTTONEAREST),&monitor) ||
+       !IntersectRect(&crop,&crop,&monitor.rcMonitor) || !raster.Ensure(crop.right-crop.left,crop.bottom-crop.top))return false;
+    HDC screen=GetDC(nullptr);if(!screen)return false;
+    const bool copied=BitBlt(raster.dc,0,0,raster.width,raster.height,screen,crop.left,crop.top,SRCCOPY|CAPTUREBLT)!=FALSE;
+    if(copied)GdiFlush();ReleaseDC(nullptr,screen);
+    return copied && Vote(raster,crop,request,darkShare);
+}
+class Sampler {
+    std::function<bool(Raster&,const Request&,double&)> capture_;
+    std::mutex mutex_;std::condition_variable wake_;std::thread worker_;
+    Request request_{};bool stop_=false;unsigned generation_=0,sequence_=0;
+    double share_=.5,elapsedMs_=0;unsigned resultGeneration_=0;
+    void Run() {
+        SetThreadDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
+        Raster raster;auto next=std::chrono::steady_clock::now();
+        std::unique_lock lock(mutex_);
+        while(!stop_) {
+            wake_.wait(lock,[&]{return stop_ || request_.enabled;});if(stop_)break;
+            if(wake_.wait_until(lock,next,[&]{return stop_ || !request_.enabled;}))continue;
+            const Request request=request_;const unsigned generation=generation_;
+            lock.unlock();double share=0;const auto began=std::chrono::steady_clock::now();
+            bool ok=capture_(raster,request,share);
+            const double ms=std::chrono::duration<double,std::milli>(std::chrono::steady_clock::now()-began).count();
+            lock.lock();
+            if(ok && generation==generation_ && request_.enabled){share_=share;elapsedMs_=ms;resultGeneration_=generation;++sequence_;}
+            // Expensive/unsupported desktop capture backs off instead of
+            // spending the normal 4 Hz budget or blocking the UI thread.
+            next=std::chrono::steady_clock::now()+std::chrono::milliseconds(ok && ms<8?250:1000);
+        }
+    }
+public:
+    explicit Sampler(std::function<bool(Raster&,const Request&,double&)> capture=Capture):capture_(std::move(capture)){}
+    ~Sampler(){Stop();}
+    void Submit(const Request& request) {
+        std::lock_guard lock(mutex_);
+        if(Same(request,request_))return;
+        request_=request;++generation_;
+        if(request.enabled && !worker_.joinable()){stop_=false;worker_=std::thread([this]{Run();});}
+        wake_.notify_one();
+    }
+    bool Read(unsigned& seen,double& share,double* elapsed=nullptr) {
+        std::unique_lock lock(mutex_,std::try_to_lock);
+        if(!lock || sequence_==seen || resultGeneration_!=generation_)return false;
+        seen=sequence_;share=share_;if(elapsed)*elapsed=elapsedMs_;return true;
+    }
+    void Stop() {
+        {std::lock_guard lock(mutex_);stop_=true;wake_.notify_one();}
+        if(worker_.joinable())worker_.join();
+        std::lock_guard lock(mutex_);request_={};++generation_;
+    }
+};
+}