xdg-dialog: implement new protocol

CMakeLists.txt

@@ -315,6 +315,7 @@ protocolnew("stable/viewporter" "viewporter" false)
 protocolnew("stable/linux-dmabuf" "linux-dmabuf-v1" false)
 protocolnew("staging/drm-lease" "drm-lease-v1" false)
 protocolnew("staging/linux-drm-syncobj" "linux-drm-syncobj-v1" false)
+protocolnew("staging/xdg-dialog" "xdg-dialog-v1" false)
 
 protocolwayland()
 

src/Compositor.cpp

@@ -1888,6 +1888,8 @@ void CCompositor::updateWindowAnimatedDecorationValues(PHLWINDOW pWindow) {
         pWindow->m_fBorderFadeAnimationProgress = 1.f;
     };
 
+    const bool IS_SHADOWED_BY_MODAL = pWindow->m_pXDGSurface && pWindow->m_pXDGSurface->toplevel && pWindow->m_pXDGSurface->toplevel->anyChildModal();
+
     // border
     const auto RENDERDATA = g_pLayoutManager->getCurrentLayout()->requestRenderHints(pWindow);
     if (RENDERDATA.isBorderGradient)
@@ -1921,11 +1923,16 @@ void CCompositor::updateWindowAnimatedDecorationValues(PHLWINDOW pWindow) {
     }
 
     // dim
-    if (pWindow == m_pLastWindow.lock() || pWindow->m_sWindowData.noDim.valueOrDefault() || !*PDIMENABLED) {
-        pWindow->m_fDimPercent = 0;
-    } else {
-        pWindow->m_fDimPercent = *PDIMSTRENGTH;
-    }
+    float goalDim = 1.F;
+    if (pWindow == m_pLastWindow.lock() || pWindow->m_sWindowData.noDim.valueOrDefault() || !*PDIMENABLED)
+        goalDim = 0;
+    else
+        goalDim = *PDIMSTRENGTH;
+
+    if (IS_SHADOWED_BY_MODAL)
+        goalDim += (1.F - goalDim) / 2.F;
+
+    pWindow->m_fDimPercent = goalDim;
 
     // shadow
     if (!pWindow->isX11OverrideRedirect() && !pWindow->m_bX11DoesntWantBorders) {

src/managers/ProtocolManager.cpp

@@ -43,6 +43,7 @@
 #include "../protocols/ToplevelExport.hpp"
 #include "../protocols/TextInputV1.hpp"
 #include "../protocols/GlobalShortcuts.hpp"
+#include "../protocols/XDGDialog.hpp"
 
 #include "../protocols/core/Seat.hpp"
 #include "../protocols/core/DataDevice.hpp"
@@ -150,6 +151,7 @@ CProtocolManager::CProtocolManager() {
     PROTO::screencopy          = std::make_unique<CScreencopyProtocol>(&zwlr_screencopy_manager_v1_interface, 3, "Screencopy");
     PROTO::toplevelExport      = std::make_unique<CToplevelExportProtocol>(&hyprland_toplevel_export_manager_v1_interface, 2, "ToplevelExport");
     PROTO::globalShortcuts     = std::make_unique<CGlobalShortcutsProtocol>(&hyprland_global_shortcuts_manager_v1_interface, 1, "GlobalShortcuts");
+    PROTO::xdgDialog           = std::make_unique<CXDGDialogProtocol>(&xdg_dialog_v1_interface, 1, "XDGDialog");
 
     for (auto const& b : g_pCompositor->m_pAqBackend->getImplementations()) {
         if (b->type() != Aquamarine::AQ_BACKEND_DRM)

src/protocols/XDGDialog.cpp

@@ -0,0 +1,88 @@
+#include "XDGDialog.hpp"
+#include "XDGShell.hpp"
+#include "../desktop/WLSurface.hpp"
+#include "../Compositor.hpp"
+#include <algorithm>
+
+CXDGDialogV1Resource::CXDGDialogV1Resource(SP<CXdgDialogV1> resource_, SP<CXDGToplevelResource> toplevel_) : resource(resource_), toplevel(toplevel_) {
+    if (!good())
+        return;
+
+    resource->setDestroy([this](CXdgDialogV1* r) { PROTO::xdgDialog->destroyResource(this); });
+    resource->setOnDestroy([this](CXdgDialogV1* r) { PROTO::xdgDialog->destroyResource(this); });
+
+    resource->setSetModal([this](CXdgDialogV1* r) {
+        modal = true;
+        updateWindow();
+    });
+
+    resource->setUnsetModal([this](CXdgDialogV1* r) {
+        modal = false;
+        updateWindow();
+    });
+}
+
+void CXDGDialogV1Resource::updateWindow() {
+    if (!toplevel || !toplevel->parent || !toplevel->parent->owner)
+        return;
+
+    auto HLSurface = CWLSurface::fromResource(toplevel->parent->owner->surface.lock());
+    if (!HLSurface || !HLSurface->getWindow())
+        return;
+
+    g_pCompositor->updateWindowAnimatedDecorationValues(HLSurface->getWindow());
+}
+
+bool CXDGDialogV1Resource::good() {
+    return resource->resource();
+}
+
+CXDGWmDialogManagerResource::CXDGWmDialogManagerResource(SP<CXdgWmDialogV1> resource_) : resource(resource_) {
+    if (!good())
+        return;
+
+    resource->setDestroy([this](CXdgWmDialogV1* r) { PROTO::xdgDialog->destroyResource(this); });
+    resource->setOnDestroy([this](CXdgWmDialogV1* r) { PROTO::xdgDialog->destroyResource(this); });
+
+    resource->setGetXdgDialog([this](CXdgWmDialogV1* r, uint32_t id, wl_resource* toplevel) {
+        auto tl = CXDGToplevelResource::fromResource(toplevel);
+        if (!tl) {
+            r->error(-1, "Toplevel inert");
+            return;
+        }
+
+        const auto RESOURCE = PROTO::xdgDialog->m_vDialogs.emplace_back(makeShared<CXDGDialogV1Resource>(makeShared<CXdgDialogV1>(r->client(), r->version(), id), tl));
+
+        if (!RESOURCE->good()) {
+            r->noMemory();
+            return;
+        }
+
+        tl->dialog = RESOURCE;
+    });
+}
+
+bool CXDGWmDialogManagerResource::good() {
+    return resource->resource();
+}
+
+CXDGDialogProtocol::CXDGDialogProtocol(const wl_interface* iface, const int& ver, const std::string& name) : IWaylandProtocol(iface, ver, name) {
+    ;
+}
+
+void CXDGDialogProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) {
+    const auto RESOURCE = m_vManagers.emplace_back(makeShared<CXDGWmDialogManagerResource>(makeShared<CXdgWmDialogV1>(client, ver, id)));
+
+    if (!RESOURCE->good()) {
+        wl_client_post_no_memory(client);
+        return;
+    }
+}
+
+void CXDGDialogProtocol::destroyResource(CXDGWmDialogManagerResource* res) {
+    std::erase_if(m_vManagers, [&](const auto& other) { return other.get() == res; });
+}
+
+void CXDGDialogProtocol::destroyResource(CXDGDialogV1Resource* res) {
+    std::erase_if(m_vDialogs, [&](const auto& other) { return other.get() == res; });
+}

src/protocols/XDGDialog.hpp

@@ -0,0 +1,57 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+#include <unordered_map>
+#include "WaylandProtocol.hpp"
+#include "xdg-dialog-v1.hpp"
+
+class CXDGToplevelResource;
+
+class CXDGDialogV1Resource {
+  public:
+    CXDGDialogV1Resource(SP<CXdgDialogV1> resource_, SP<CXDGToplevelResource> toplevel_);
+
+    bool good();
+
+    bool modal = false;
+
+  private:
+    SP<CXdgDialogV1>         resource;
+    WP<CXDGToplevelResource> toplevel;
+
+    void                     updateWindow();
+};
+
+class CXDGWmDialogManagerResource {
+  public:
+    CXDGWmDialogManagerResource(SP<CXdgWmDialogV1> resource_);
+
+    bool good();
+
+  private:
+    SP<CXdgWmDialogV1> resource;
+};
+
+class CXDGDialogProtocol : public IWaylandProtocol {
+  public:
+    CXDGDialogProtocol(const wl_interface* iface, const int& ver, const std::string& name);
+
+    virtual void bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id);
+
+  private:
+    void onManagerResourceDestroy(wl_resource* res);
+    void destroyResource(CXDGWmDialogManagerResource* res);
+    void destroyResource(CXDGDialogV1Resource* res);
+
+    //
+    std::vector<SP<CXDGWmDialogManagerResource>> m_vManagers;
+    std::vector<SP<CXDGDialogV1Resource>>        m_vDialogs;
+
+    friend class CXDGWmDialogManagerResource;
+    friend class CXDGDialogV1Resource;
+};
+
+namespace PROTO {
+    inline UP<CXDGDialogProtocol> xdgDialog;
+};

src/protocols/XDGShell.cpp

@@ -1,10 +1,12 @@
 #include "XDGShell.hpp"
+#include "XDGDialog.hpp"
 #include <algorithm>
 #include "../Compositor.hpp"
 #include "../managers/SeatManager.hpp"
 #include "core/Seat.hpp"
 #include "core/Compositor.hpp"
 #include <cstring>
+#include <ranges>
 
 void SXDGPositionerState::setAnchor(xdgPositionerAnchor edges) {
     anchor.setTop(edges == XDG_POSITIONER_ANCHOR_TOP || edges == XDG_POSITIONER_ANCHOR_TOP_LEFT || edges == XDG_POSITIONER_ANCHOR_TOP_RIGHT);
@@ -207,15 +209,25 @@ CXDGToplevelResource::CXDGToplevelResource(SP<CXdgToplevel> resource_, SP<CXDGSu
     });
 
     resource->setSetParent([this](CXdgToplevel* r, wl_resource* parentR) {
+        auto oldParent = parent;
+
+        if (parent)
+            std::erase(parent->children, self);
+
         auto newp = parentR ? CXDGToplevelResource::fromResource(parentR) : nullptr;
         parent    = newp;
 
-        LOGM(LOG, "Toplevel {:x} sets parent to {:x}", (uintptr_t)this, (uintptr_t)newp.get());
+        if (parent)
+            parent->children.emplace_back(self);
+
+        LOGM(LOG, "Toplevel {:x} sets parent to {:x}{}", (uintptr_t)this, (uintptr_t)newp.get(), (oldParent ? std::format(" (was {:x})", (uintptr_t)oldParent.get()) : ""));
     });
 }
 
 CXDGToplevelResource::~CXDGToplevelResource() {
     events.destroy.emit();
+    if (parent)
+        std::erase_if(parent->children, [this](const auto& other) { return !other || other.get() == this; });
 }
 
 SP<CXDGToplevelResource> CXDGToplevelResource::fromResource(wl_resource* res) {
@@ -227,6 +239,10 @@ bool CXDGToplevelResource::good() {
     return resource->resource();
 }
 
+bool CXDGToplevelResource::anyChildModal() {
+    return std::ranges::any_of(children, [](const auto& child) { return child && child->dialog && child->dialog->modal; });
+}
+
 uint32_t CXDGToplevelResource::setSize(const Vector2D& size) {
     pendingApply.size = size;
     applyState();

src/protocols/XDGShell.hpp

@@ -18,6 +18,7 @@ class CXDGToplevelResource;
 class CXDGPopupResource;
 class CSeatGrab;
 class CWLSurfaceResource;
+class CXDGDialogV1Resource;
 
 struct SXDGPositionerState {
     Vector2D requestedSize;
@@ -134,7 +135,12 @@ class CXDGToplevelResource {
         Vector2D maxSize = {1337420, 694200};
     } pending, current;
 
-    WP<CXDGToplevelResource> parent;
+    WP<CXDGToplevelResource>              parent;
+    WP<CXDGDialogV1Resource>              dialog;
+
+    bool                                  anyChildModal();
+
+    std::vector<WP<CXDGToplevelResource>> children;
 
   private:
     SP<CXdgToplevel> resource;

src/render/OpenGL.cpp

@@ -1378,8 +1378,7 @@ void CHyprOpenGLImpl::renderTextureInternalWithDamage(SP<CTexture> tex, CBox* pB
     CBox newBox = *pBox;
     m_RenderData.renderModif.applyToBox(newBox);
 
-    static auto PDIMINACTIVE = CConfigValue<Hyprlang::INT>("decoration:dim_inactive");
-    static auto PDT          = CConfigValue<Hyprlang::INT>("debug:damage_tracking");
+    static auto PDT = CConfigValue<Hyprlang::INT>("debug:damage_tracking");
 
     // get the needed transform for this texture
     const bool TRANSFORMS_MATCH = wlTransformToHyprutils(m_RenderData.pMonitor->transform) == tex->m_eTransform; // FIXME: combine them properly!!!
@@ -1493,7 +1492,7 @@ void CHyprOpenGLImpl::renderTextureInternalWithDamage(SP<CTexture> tex, CBox* pB
         glUniform2f(shader->fullSize, FULLSIZE.x, FULLSIZE.y);
         glUniform1f(shader->radius, round);
 
-        if (allowDim && m_pCurrentWindow.lock() && *PDIMINACTIVE) {
+        if (allowDim && m_pCurrentWindow.lock()) {
             glUniform1i(shader->applyTint, 1);
             const auto DIM = m_pCurrentWindow->m_fDimPercent.value();
             glUniform3f(shader->tint, 1.f - DIM, 1.f - DIM, 1.f - DIM);