protocols: add support for xdg-system-bell-v1

CMakeLists.txt

@@ -384,6 +384,7 @@ protocolnew("staging/security-context" "security-context-v1" false)
 protocolnew("staging/content-type" "content-type-v1" false)
 protocolnew("staging/color-management" "color-management-v1" false)
 protocolnew("staging/xdg-toplevel-tag" "xdg-toplevel-tag-v1" false)
+protocolnew("staging/xdg-system-bell" "xdg-system-bell-v1" false)
 
 protocolwayland()
 

protocols/meson.build

@@ -74,6 +74,7 @@ protocols = [
 	wayland_protocol_dir / 'staging/content-type/content-type-v1.xml',
 	wayland_protocol_dir / 'staging/color-management/color-management-v1.xml',
 	wayland_protocol_dir / 'staging/xdg-toplevel-tag/xdg-toplevel-tag-v1.xml',
+	wayland_protocol_dir / 'staging/xdg-system-bell/xdg-system-bell-v1.xml',
 ]
 
 wl_protocols = []

src/managers/ProtocolManager.cpp

@@ -61,6 +61,7 @@
 #include "../protocols/FrogColorManagement.hpp"
 #include "../protocols/ContentType.hpp"
 #include "../protocols/XDGTag.hpp"
+#include "../protocols/XDGBell.hpp"
 
 #include "../helpers/Monitor.hpp"
 #include "../render/Renderer.hpp"
@@ -186,6 +187,7 @@ CProtocolManager::CProtocolManager() {
     PROTO::hyprlandSurface     = makeUnique<CHyprlandSurfaceProtocol>(&hyprland_surface_manager_v1_interface, 2, "HyprlandSurface");
     PROTO::contentType         = makeUnique<CContentTypeProtocol>(&wp_content_type_manager_v1_interface, 1, "ContentType");
     PROTO::xdgTag              = makeUnique<CXDGToplevelTagProtocol>(&xdg_toplevel_tag_manager_v1_interface, 1, "XDGTag");
+    PROTO::xdgBell             = makeUnique<CXDGSystemBellProtocol>(&xdg_system_bell_v1_interface, 1, "XDGBell");
 
     if (*PENABLECM)
         PROTO::colorManagement = makeUnique<CColorManagementProtocol>(&wp_color_manager_v1_interface, 1, "ColorManagement", *PDEBUGCM);
@@ -277,6 +279,7 @@ CProtocolManager::~CProtocolManager() {
     PROTO::xxColorManagement.reset();
     PROTO::frogColorManagement.reset();
     PROTO::xdgTag.reset();
+    PROTO::xdgBell.reset();
 
     PROTO::lease.reset();
     PROTO::sync.reset();
@@ -329,11 +332,12 @@ bool CProtocolManager::isGlobalPrivileged(const wl_global* global) {
         PROTO::primarySelection->getGlobal(),
 		PROTO::hyprlandSurface->getGlobal(),
 		PROTO::xdgTag->getGlobal(),
+		PROTO::xdgBell->getGlobal(),
         PROTO::sync     ? PROTO::sync->getGlobal()      : nullptr,
         PROTO::mesaDRM  ? PROTO::mesaDRM->getGlobal()   : nullptr,
         PROTO::linuxDma ? PROTO::linuxDma->getGlobal()  : nullptr,
     };
     // clang-format on
 
-    return std::find(ALLOWED_WHITELIST.begin(), ALLOWED_WHITELIST.end(), global) == ALLOWED_WHITELIST.end();
+    return std::ranges::find(ALLOWED_WHITELIST, global) == ALLOWED_WHITELIST.end();
 }

src/protocols/XDGBell.cpp

@@ -0,0 +1,64 @@
+#include "XDGBell.hpp"
+#include "XDGShell.hpp"
+#include "../desktop/Window.hpp"
+#include "../managers/EventManager.hpp"
+#include "../Compositor.hpp"
+
+CXDGSystemBellManagerResource::CXDGSystemBellManagerResource(UP<CXdgSystemBellV1>&& resource) : m_resource(std::move(resource)) {
+    if UNLIKELY (!good())
+        return;
+
+    m_resource->setDestroy([this](CXdgSystemBellV1* r) { PROTO::xdgBell->destroyResource(this); });
+    m_resource->setOnDestroy([this](CXdgSystemBellV1* r) { PROTO::xdgBell->destroyResource(this); });
+
+    resource->setRing([](CXdgSystemBellV1* r, wl_resource* toplevel) {
+        auto TOPLEVEL = CXDGToplevelResource::fromResource(toplevel);
+
+        if (!TOPLEVEL) {
+            g_pEventManager->postEvent(SHyprIPCEvent{
+                .event = "bell",
+                .data  = "",
+            });
+            return;
+        }
+
+        for (const auto& w : g_pCompositor->m_windows) {
+            if (!w->m_isMapped || w->m_isX11 || !w->m_xdgSurface)
+                continue;
+
+            if (w->m_xdgSurface == TOPLEVEL->owner) {
+                g_pEventManager->postEvent(SHyprIPCEvent{
+                    .event = "bell",
+                    .data  = std::format("{:x}", (uintptr_t)w.get()),
+                });
+                return;
+            }
+        }
+
+        g_pEventManager->postEvent(SHyprIPCEvent{
+            .event = "bell",
+            .data  = "",
+        });
+    });
+}
+
+bool CXDGSystemBellManagerResource::good() {
+    return m_resource->resource();
+}
+
+CXDGSystemBellProtocol::CXDGSystemBellProtocol(const wl_interface* iface, const int& ver, const std::string& name) : IWaylandProtocol(iface, ver, name) {
+    ;
+}
+
+void CXDGSystemBellProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) {
+    const auto RESOURCE = WP<CXDGSystemBellManagerResource>{m_vManagers.emplace_back(makeUnique<CXDGSystemBellManagerResource>(makeUnique<CXdgSystemBellV1>(client, ver, id)))};
+
+    if UNLIKELY (!RESOURCE->good()) {
+        wl_client_post_no_memory(client);
+        return;
+    }
+}
+
+void CXDGSystemBellProtocol::destroyResource(CXDGSystemBellManagerResource* res) {
+    std::erase_if(m_vManagers, [&](const auto& other) { return other.get() == res; });
+}

src/protocols/XDGBell.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <vector>
+#include "WaylandProtocol.hpp"
+#include "xdg-system-bell-v1.hpp"
+
+class CXDGSystemBellManagerResource {
+  public:
+    CXDGSystemBellManagerResource(UP<CXdgSystemBellV1>&& resource);
+
+    bool good();
+
+  private:
+    UP<CXdgSystemBellV1> m_resource;
+};
+
+class CXDGSystemBellProtocol : public IWaylandProtocol {
+  public:
+    CXDGSystemBellProtocol(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 destroyResource(CXDGSystemBellManagerResource* res);
+
+    //
+    std::vector<UP<CXDGSystemBellManagerResource>> m_vManagers;
+
+    friend class CXDGSystemBellManagerResource;
+};
+
+namespace PROTO {
+    inline UP<CXDGSystemBellProtocol> xdgBell;
+};