Small problem with the glow effect.

[Mira-Bellenbaum]

Since I use the theme
“aero_7_themes_for_win10_final_by_sagorpirbd”
the buttons are all different widths.
Is it possible to add a glow effect to all three buttons separately?
Because the graphics supplied do not match the two “blue” buttons.
“blue” buttons.
But if they were separate, I could adapt the graphics accordingly!
I had to do the same with the close button!

[Mira-Bellenbaum]

To illustrate what I mean, I have created some screenshots.
to 1. the close button, I simply made the graphic (btnglow_close.png) 5px flatter. Fits.
to 2. here exactly the same, simply the graphic (btnglow_other.png) also simply 5px flatter. And it fits perfectly here too!
to 3. and here the mishap (mishap)!
The button is slightly narrower and so the graphic (btnglow_other.png) does not match the button.
to 4. serves only the comparability!

I could now try to change the width of the button
in the theme, but that would damage the look!
It would be nicer if the graphics for the glow effect were separate,
so that they could be customized separately!
Basically, I think it's better to be able to customize the graphics for changes anyway.
the graphics, because very few people know anything about programming.
But most people manage to change an “image” somehow ;)

Translated with DeepL.com (free version)

[Mira-Bellenbaum]

Addendum!
I would try myself, but I just can't find the assignment to the graphics in your code!
I had the bold idea of splitting it using ChatGPT.
It was probably nothing. ¯\ _ (ツ)_/¯

Oh and sorry for the possibly bad English!
It's translated via DeepL, unfortunately I don't speak English.

[Mira-Bellenbaum]

Is that correct?
Would the “new” ButtonGlowBackdrop.hpp:

#pragma once
#include "DCompBackdrop.hpp"
#include <Shlwapi.h>

namespace MDWMBlurGlassExt
{
class CButtonGlowBackdrop : public implements<CButtonGlowBackdrop, IUnknown>, COverlayVisual
{
static inline wuc::CompositionDrawingSurface s_glowCloseTexture{ nullptr };
static inline wuc::CompositionDrawingSurface s_glowFirstTexture{ nullptr }; // Neue Variable für den ersten Button
static inline wuc::CompositionDrawingSurface s_glowSecondTexture{ nullptr }; // Neue Variable für den zweiten Button
static inline com_ptrDCompPrivate::IDCompositionDesktopDevicePartner s_dcompDevice{ nullptr };
static inline wg::SizeInt32 s_glowCloseSize{};
static inline wg::SizeInt32 s_glowFirstSize{}; // Neue Größe für den ersten Button
static inline wg::SizeInt32 s_glowSecondSize{}; // Neue Größe für den zweiten Button

    wuc::CompositionSurfaceBrush m_textureSurfaceBrush[3]{ { nullptr}, { nullptr }, { nullptr } }; // Array erweitert für drei Buttons
    wuc::CompositionNineGridBrush m_textureNineGridBrush[3]{ { nullptr}, { nullptr }, { nullptr } }; // Drei Brushes
    wuc::CompositionColorBrush m_opacityBrush{ nullptr };
    wuc::SpriteVisual m_spriteVisual[3]{ {nullptr}, {nullptr}, {nullptr} };

    bool m_visible[3] = { false, false, false }; // Sichtbarkeit für drei Buttons
public:
    CButtonGlowBackdrop(DWM::CVisual* visual) : COverlayVisual(visual)
    {
        CButtonGlowBackdrop::InitializeVisual();
    }
    ~CButtonGlowBackdrop() override
    {
        CButtonGlowBackdrop::UninitializeVisual();
    }

    HRESULT InitializeVisual() override
    {
        InitializeInteropDevice(DWM::CDesktopManager::s_pDesktopManagerInstance->GetDCompositionInteropDevice());
        RETURN_IF_FAILED(COverlayVisual::InitializeVisual());
        EnsureTextureSurface();

        auto compositor{ m_dcompDevice.as<wuc::Compositor>() };
        m_spriteVisual[0] = compositor.CreateSpriteVisual();
        m_spriteVisual[1] = compositor.CreateSpriteVisual();
        m_spriteVisual[2] = compositor.CreateSpriteVisual();

        m_visualCollection.InsertAtTop(m_spriteVisual[2]);
        m_visualCollection.InsertAtTop(m_spriteVisual[1]);
        m_visualCollection.InsertAtTop(m_spriteVisual[0]);

        m_textureNineGridBrush[0] = compositor.CreateNineGridBrush();
        m_textureNineGridBrush[1] = compositor.CreateNineGridBrush();
        m_textureNineGridBrush[2] = compositor.CreateNineGridBrush();

        m_textureSurfaceBrush[0] = compositor.CreateSurfaceBrush(s_glowCloseTexture); // Close-Button
        m_textureSurfaceBrush[0].Stretch(wuc::CompositionStretch::Fill);

        m_textureSurfaceBrush[1] = compositor.CreateSurfaceBrush(s_glowFirstTexture);  // Erster Button
        m_textureSurfaceBrush[1].Stretch(wuc::CompositionStretch::Fill);

        m_textureSurfaceBrush[2] = compositor.CreateSurfaceBrush(s_glowSecondTexture); // Zweiter Button
        m_textureSurfaceBrush[2].Stretch(wuc::CompositionStretch::Fill);

        m_textureNineGridBrush[0].Source(m_textureSurfaceBrush[0]);
        m_textureNineGridBrush[0].SetInsets(15.f, 10.f, 15.f, 10.f);
        m_textureNineGridBrush[1].Source(m_textureSurfaceBrush[1]);
        m_textureNineGridBrush[1].SetInsets(15.f, 10.f, 15.f, 10.f);
        m_textureNineGridBrush[2].Source(m_textureSurfaceBrush[2]);
        m_textureNineGridBrush[2].SetInsets(15.f, 10.f, 15.f, 10.f);

        m_opacityBrush = compositor.CreateColorBrush();
        m_spriteVisual[0].Brush(m_opacityBrush);
        m_spriteVisual[1].Brush(m_opacityBrush);
        m_spriteVisual[2].Brush(m_opacityBrush);

        return S_OK;
    }

    void UninitializeVisual() override
    {
        m_opacityBrush = nullptr;
        m_spriteVisual[0] = nullptr;
        m_spriteVisual[1] = nullptr;
        m_spriteVisual[2] = nullptr;

        COverlayVisual::UninitializeVisual();
    }

    void Update(int index, POINT offset, SIZE size, float scale, bool show) try
    {
        EnsureTextureSurface();

        if (!s_glowCloseTexture || !s_glowFirstTexture || !s_glowSecondTexture)
            return;

        m_textureSurfaceBrush[0].Surface(s_glowCloseTexture);   // Close-Button
        m_textureSurfaceBrush[1].Surface(s_glowFirstTexture);   // Erster Button
        m_textureSurfaceBrush[2].Surface(s_glowSecondTexture);  // Zweiter Button

        index--;

        if (index == 2)
        {
            m_spriteVisual[index].Offset(
                winrt::Windows::Foundation::Numerics::float3{ (float)offset.x - 9.5f, (float)offset.y - 7.f, 0.f }
            );
            m_spriteVisual[index].Size(winrt::Windows::Foundation::Numerics::float2
            {
                (float)size.cx + 19.5f + scale, (float)size.cy + 16.f + round(scale)
            });

        }
        else if (index == 1 || index == 0)
        {
            m_spriteVisual[index].Offset(
                winrt::Windows::Foundation::Numerics::float3{ (float)offset.x - 9.5f, (float)offset.y - 7.f, 0.f }
            );
            m_spriteVisual[index].Size(winrt::Windows::Foundation::Numerics::float2
            {
                (float)size.cx + 19.5f + scale, (float)size.cy + 16.f + round(scale)
            });
        }
        else
            return;

        auto newBrush = show ? m_textureNineGridBrush[index].as<wuc::CompositionBrush>() : m_opacityBrush.as<wuc::CompositionBrush>();
        auto currentBrush = m_visible[index] ? m_textureNineGridBrush[index].as<wuc::CompositionBrush>() : m_opacityBrush.as<wuc::CompositionBrush>();

        if (m_visible[index] != show)
        {
            auto compositor{ m_dcompDevice.as<wuc::Compositor>() };

            auto crossfadeBrush{ CreateCrossFadeBrush(compositor, currentBrush, newBrush) };

            m_visible[index] = show;
            m_spriteVisual[index].Brush(crossfadeBrush);

            crossfadeBrush.StartAnimation(
                L"Crossfade.Weight",
                CreateCrossFadeAnimation(
                    compositor,
                    0,
                    std::chrono::milliseconds(60)
                )
            );
        }
    }
    CATCH_LOG_RETURN()

    static comp::CompositionDrawingSurface LoadTexture(std::wstring_view path) try
    {
        WCHAR filePath[MAX_PATH + 1]{};
        GetModuleFileName(wil::GetModuleInstanceHandle(), filePath, MAX_PATH);
        PathCchRemoveFileSpec(filePath, MAX_PATH);
        PathCchAppend(filePath, MAX_PATH, path.data());

        wil::unique_hfile file{ CreateFileW(filePath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0) };
        THROW_LAST_ERROR_IF(!file.is_valid());

        LARGE_INTEGER fileSize{};
        THROW_IF_WIN32_BOOL_FALSE(GetFileSizeEx(file.get(), &fileSize));

        auto buffer{ std::make_unique<BYTE[]>(static_cast<size_t>(fileSize.QuadPart)) };
        THROW_IF_WIN32_BOOL_FALSE(ReadFile(file.get(), buffer.get(), static_cast<DWORD>(fileSize.QuadPart), nullptr, nullptr));
        com_ptr<IStream> stream{ SHCreateMemStream(buffer.get(), static_cast<UINT>(fileSize.QuadPart)), winrt::take_ownership_from_abi };
        THROW_LAST_ERROR_IF_NULL(stream);

        com_ptr<IWICImagingFactory2> wicFactory{ nullptr };
        wicFactory.copy_from(DWM::CDesktopManager::s_pDesktopManagerInstance->GetWICFactory());
        com_ptr<IWICBitmapDecoder> wicDecoder{ nullptr };
        THROW_IF_FAILED(wicFactory->CreateDecoderFromStream(stream.get(), &GUID_VendorMicrosoft, WICDecodeMetadataCacheOnDemand, wicDecoder.put()));
        com_ptr<IWICBitmapFrameDecode> wicFrame{ nullptr };
        THROW_IF_FAILED(wicDecoder->GetFrame(0, wicFrame.put()));
        com_ptr<IWICFormatConverter> wicConverter{ nullptr };
        THROW_IF_FAILED(wicFactory->CreateFormatConverter(wicConverter.put()));
        com_ptr<IWICPalette> wicPalette{ nullptr };
        THROW_IF_FAILED(
            wicConverter->Initialize(
                wicFrame.get(),
                GUID_WICPixelFormat32bppPBGRA,
                WICBitmapDitherTypeNone,
                wicPalette.get(),
                0, WICBitmapPaletteTypeCustom
            )
        );
        com_ptr<IWICBitmap> wicBitmap{ nullptr };
        THROW_IF_FAILED(wicFactory->CreateBitmapFromSource(wicConverter.get(), WICBitmapCreateCacheOption::WICBitmapNoCache, wicBitmap.put()));

        auto compositor{ s_dcompDevice.as<wuc::Compositor>() };
        comp::CompositionDrawingSurface surface{ compositor.CreateDrawingSurface2(
            {
                static_cast<int32_t>(fileSize.LowPart),
                static_cast<int32_t>(fileSize.HighPart)
            },
            GUID_WICPixelFormat32bppPBGRA
        ) };

        return surface;
    }
    CATCH_LOG_RETURN()

    static void EnsureTextureSurface()
    {
        if (!s_dcompDevice)
        {
            s_dcompDevice.copy_from(DWM::CDesktopManager::s_pDesktopManagerInstance->GetDCompositionInteropDevice());
        }
        if (!CheckDeviceState(s_dcompDevice))
        {
            s_glowCloseTexture = nullptr;
            s_glowFirstTexture = nullptr;   // Neue Textur freigeben
            s_glowSecondTexture = nullptr;  // Neue Textur freigeben
        }
        if (!s_glowCloseTexture)
            s_glowCloseTexture = LoadTexture(Utils::GetCurrentDir() + L"\\data\\btnglow_close.png");
        if (!s_glowFirstTexture)
            s_glowFirstTexture = LoadTexture(Utils::GetCurrentDir() + L"\\data\\btnglow_first.png");  // Für den ersten Button
        if (!s_glowSecondTexture)
            s_glowSecondTexture = LoadTexture(Utils::GetCurrentDir() + L"\\data\\btnglow_second.png"); // Für den zweiten Button
    }

    static void Shutdown()
    {
        s_glowCloseTexture = nullptr;
        s_glowFirstTexture = nullptr;   // Neue Textur freigeben
        s_glowSecondTexture = nullptr;  // Neue Textur freigeben
        s_dcompDevice = nullptr;
    }
};

}

And is that enough?

[Mira-Bellenbaum]

The issue has been resolved!
I have adjusted the graphics in “my” theme
and use AWM.
Now it fits!