add CCExtSessionLockV1

Author: PaideiaDilemma

CMakeLists.txt

@@ -143,6 +143,11 @@ add_executable(controls "tests/Controls.cpp")
 target_link_libraries(controls PRIVATE PkgConfig::deps hyprtoolkit)
 add_dependencies(tests controls)
 
+add_executable(simpleSessionLock "tests/SimpleSessionLock.cpp")
+target_link_libraries(simpleSessionLock PRIVATE PkgConfig::deps hyprtoolkit)
+add_dependencies(tests simpleSessionLock)
+
+
 # Installation
 install(TARGETS hyprtoolkit)
 install(DIRECTORY "include/hyprtoolkit" DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})

include/hyprtoolkit/core/Backend.hpp

@@ -32,6 +32,13 @@ namespace Hyprtoolkit {
         */
         static Hyprutils::Memory::CSharedPointer<CBackend> create();
 
+        /*
+            Attempt to initialize the platform.
+            Optional. Can be used in case the outputAdded/Removed events are used to create new windows.
+            In such a szenario the platform must be initialized before opening a window.
+        */
+        static bool attempt();
+
         /*
             Destroy the backend.
             Backend will be destroyed once:
@@ -73,9 +80,10 @@ namespace Hyprtoolkit {
 
         Hyprutils::Memory::CSharedPointer<CPalette> getPalette();
 
+        void                                        unlockSession();
+
         struct {
             Hyprutils::Signal::CSignalT<uint32_t> outputAdded;
-            Hyprutils::Signal::CSignalT<uint32_t> outputRemoved;
         } m_events;
 
         HT_HIDDEN : CBackend();

src/core/Backend.cpp

@@ -71,6 +71,17 @@ SP<CBackend> CBackend::create() {
     return g_backend;
 };
 
+bool CBackend::attempt() {
+    g_waylandPlatform = makeUnique<CWaylandPlatform>();
+    if (!g_waylandPlatform->attempt()) {
+        g_waylandPlatform = nullptr;
+        return false;
+    }
+    g_openGL   = makeShared<COpenGLRenderer>(g_waylandPlatform->m_drmState.fd);
+    g_renderer = g_openGL;
+    return true;
+}
+
 void CBackend::destroy() {
     terminate();
 }
@@ -83,14 +94,16 @@ SP<CPalette> CBackend::getPalette() {
     return g_palette;
 }
 
+void CBackend::unlockSession() {
+    if (!g_waylandPlatform)
+        return;
+
+    g_waylandPlatform->unlockSessionLock();
+}
+
 SP<IWindow> CBackend::openWindow(const SWindowCreationData& data) {
-    if (!g_waylandPlatform) {
-        g_waylandPlatform = makeUnique<CWaylandPlatform>();
-        if (!g_waylandPlatform->attempt())
-            return nullptr;
-        g_openGL   = makeShared<COpenGLRenderer>(g_waylandPlatform->m_drmState.fd);
-        g_renderer = g_openGL;
-    }
+    if (!g_waylandPlatform && !attempt())
+        return nullptr;
 
     if (data.type == HT_WINDOW_LAYER) {
         if (!g_waylandPlatform->m_waylandState.layerShell)
@@ -101,6 +114,17 @@ SP<IWindow> CBackend::openWindow(const SWindowCreationData& data) {
         w->m_rootElement->impl->window = w;
         g_waylandPlatform->m_layers.emplace_back(w);
         return w;
+    } else if (data.type == HT_WINDOW_LOCK_SURFACE) {
+        if (!g_waylandPlatform->m_waylandState.sessionLock) {
+            g_logger->log(HT_LOG_ERROR, "No session lock manager. Does your compositor support it?");
+            return nullptr;
+        }
+
+        auto w                         = makeShared<CWaylandLockSurface>(data);
+        w->m_self                      = w;
+        w->m_rootElement->impl->window = w;
+        g_waylandPlatform->m_lockSurfaces.emplace_back(w);
+        return w;
     }
 
     auto w                         = makeShared<CWaylandWindow>(data);

src/core/platforms/WaylandPlatform.cpp

@@ -2,13 +2,15 @@
 
 #include <algorithm>
 #include <hyprutils/memory/Casts.hpp>
+#include <optional>
 #include <xkbcommon/xkbcommon-keysyms.h>
 
 #include "../InternalBackend.hpp"
 #include "../Input.hpp"
 #include "../../element/Element.hpp"
 #include "../../window/WaylandWindow.hpp"
 #include "../../window/WaylandLayer.hpp"
+#include "../../window/WaylandLockSurface.hpp"
 #include "../../output/WaylandOutput.hpp"
 #include "../../Macros.hpp"
 
@@ -100,15 +102,23 @@ bool CWaylandPlatform::attempt() {
             // We just need to deferre it a bit so that the globals are defined before we emit the event.
             // But once they are defined, we probably don't want it to be a idle function.
             m_idleCallbacks.emplace_back([id]() { g_backend->m_events.outputAdded.emit(id); });
+        } else if (NAME == ext_session_lock_manager_v1_interface.name) {
+            TRACE(g_logger->log(HT_LOG_TRACE, "  > binding to global: {} (version {}) with id {}", name, 1, id));
+            m_waylandState.sessionLock = makeShared<CCExtSessionLockManagerV1>(
+                (wl_proxy*)wl_registry_bind((wl_registry*)m_waylandState.registry->resource(), id, &ext_session_lock_manager_v1_interface, 1));
         }
     });
     m_waylandState.registry->setGlobalRemove([this](CCWlRegistry* r, uint32_t id) {
+        TRACE(g_logger->log(HT_LOG_TRACE, "Global {} removed", id));
+
+        auto lockSurfaceIt = std::ranges::find_if(m_lockSurfaces, [id](const auto& other) { return other->m_outputId == id; });
+        if (lockSurfaceIt != m_lockSurfaces.end()) {
+            (*lockSurfaceIt)->m_events.closeRequest.emit();
+            m_lockSurfaces.erase(lockSurfaceIt);
+        }
         auto outputIt = std::ranges::find_if(m_outputs, [id](const auto& other) { return other->m_id == id; });
         if (outputIt != m_outputs.end())
             m_outputs.erase(outputIt);
-
-        g_logger->log(HT_LOG_DEBUG, "Global {} removed", id);
-        g_backend->m_events.outputRemoved.emit(id);
     });
 
     wl_display_roundtrip(m_waylandState.display);
@@ -127,9 +137,7 @@ bool CWaylandPlatform::attempt() {
 }
 
 CWaylandPlatform::~CWaylandPlatform() {
-    const auto DPY = m_waylandState.display;
-    m_waylandState = {};
-    wl_display_disconnect(DPY);
+    m_outputs.clear();
 
     if (m_drmState.fd >= 0)
         close(m_drmState.fd);
@@ -140,6 +148,10 @@ CWaylandPlatform::~CWaylandPlatform() {
         xkb_keymap_unref(m_waylandState.seatState.xkbKeymap);
     if (m_waylandState.seatState.xkbContext)
         xkb_context_unref(m_waylandState.seatState.xkbContext);
+
+    const auto DPY = m_waylandState.display;
+    m_waylandState = {};
+    wl_display_disconnect(DPY);
 }
 
 bool CWaylandPlatform::dispatchEvents() {
@@ -618,3 +630,50 @@ void CWaylandPlatform::stopRepeatTimer() {
     m_waylandState.seatState.repeatTimer->cancel();
     m_waylandState.seatState.repeatTimer.reset();
 }
+
+SP<CCExtSessionLockV1> CWaylandPlatform::aquireSessionLock() {
+    if (m_waylandState.sessionLockState.sessionLocked && m_waylandState.sessionLockState.sessionUnlocked) {
+        g_logger->log(HT_LOG_ERROR, "We already unlocked. We shouldn't be calling aquireSessionLock?");
+        return nullptr;
+    }
+
+    if (!m_waylandState.sessionLockState.lock) {
+        m_waylandState.sessionLockState.lock = makeShared<CCExtSessionLockV1>(m_waylandState.sessionLock->sendLock());
+        if (!m_waylandState.sessionLockState.lock) {
+            g_logger->log(HT_LOG_ERROR, "Failed to create a session lock object!");
+            return nullptr;
+        }
+
+        m_waylandState.sessionLockState.lock->setLocked([this](CCExtSessionLockV1* r) { m_waylandState.sessionLockState.sessionLocked = true; });
+
+        m_waylandState.sessionLockState.lock->setFinished([](CCExtSessionLockV1* r) { //FIXME: we need to make sure the client can exit after this event
+        });
+
+        // roundtrip in case the compositor sends `finished` right away
+        wl_display_roundtrip(m_waylandState.display);
+
+        // FIXME: we need to test if finished was sent right here too!
+    }
+
+    return m_waylandState.sessionLockState.lock;
+}
+
+void CWaylandPlatform::unlockSessionLock() {
+    if (!m_waylandState.sessionLockState.lock)
+        return;
+
+    m_waylandState.sessionLockState.lock->sendUnlockAndDestroy();
+    m_waylandState.sessionLockState.lock            = nullptr;
+    m_waylandState.sessionLockState.sessionUnlocked = true;
+
+    // roundtrip in order to make sure we have unlocked before sending closeRequest
+    wl_display_roundtrip(m_waylandState.display);
+
+    for (const auto& sls : m_lockSurfaces) {
+        if (sls.expired())
+            continue;
+        sls->m_events.closeRequest.emit();
+    }
+
+    m_lockSurfaces.clear();
+}

src/core/platforms/WaylandPlatform.hpp

@@ -22,6 +22,7 @@
 #include <cursor-shape-v1.hpp>
 #include <text-input-unstable-v3.hpp>
 #include <wlr-layer-shell-unstable-v1.hpp>
+#include <ext-session-lock-v1.hpp>
 
 #include <aquamarine/allocator/GBM.hpp>
 #include <aquamarine/backend/Misc.hpp>
@@ -33,6 +34,7 @@ namespace Hyprtoolkit {
     class IWaylandWindow;
     class CWaylandLayer;
     class CWaylandOutput;
+    class CWaylandLockSurface;
 
     class CWaylandPlatform {
       public:
@@ -58,6 +60,9 @@ namespace Hyprtoolkit {
 
         void                              onRepeatTimerFire();
 
+        SP<CCExtSessionLockV1>            aquireSessionLock();
+        void                              unlockSessionLock();
+
         //
         std::vector<FIdleCallback> m_idleCallbacks;
 
@@ -86,6 +91,7 @@ namespace Hyprtoolkit {
             Hyprutils::Memory::CSharedPointer<CCZwpTextInputManagerV3>      textInputManager;
             Hyprutils::Memory::CSharedPointer<CCZwpTextInputV3>             textInput;
             Hyprutils::Memory::CSharedPointer<CCZwlrLayerShellV1>           layerShell;
+            Hyprutils::Memory::CSharedPointer<CCExtSessionLockManagerV1>    sessionLock;
 
             // control
             bool dmabufFailed = false;
@@ -111,20 +117,27 @@ namespace Hyprtoolkit {
 
                 std::string originalString;
             } imState;
+
+            struct {
+                SP<CCExtSessionLockV1> lock            = nullptr;
+                bool                   sessionLocked   = false;
+                bool                   sessionUnlocked = false;
+            } sessionLockState;
         } m_waylandState;
 
         struct {
             int         fd       = -1;
             std::string nodeName = "";
         } m_drmState;
 
-        std::vector<UP<CWaylandOutput>> m_outputs;
+        std::vector<UP<CWaylandOutput>>      m_outputs;
 
-        std::vector<WP<CWaylandWindow>> m_windows;
-        std::vector<WP<CWaylandLayer>>  m_layers;
-        WP<IWaylandWindow>              m_currentWindow;
-        uint32_t                        m_currentMods     = 0; // HT modifiers, not xkb
-        uint32_t                        m_lastEnterSerial = 0;
+        std::vector<WP<CWaylandWindow>>      m_windows;
+        std::vector<WP<CWaylandLayer>>       m_layers;
+        std::vector<WP<CWaylandLockSurface>> m_lockSurfaces;
+        WP<IWaylandWindow>                   m_currentWindow;
+        uint32_t                             m_currentMods     = 0; // HT modifiers, not xkb
+        uint32_t                             m_lastEnterSerial = 0;
     };
 
     inline UP<CWaylandPlatform> g_waylandPlatform;

src/output/WaylandOutput.cpp

@@ -1,6 +1,5 @@
 #include "WaylandOutput.hpp"
 #include "../core/InternalBackend.hpp"
-#include "../helpers/Memory.hpp"
 
 using namespace Hyprtoolkit;
 
@@ -28,14 +27,14 @@ CWaylandOutput::CWaylandOutput(wl_proxy* wlResource, uint32_t id) : m_id(id), m_
     m_wlOutput.setName([this](CCWlOutput* r, const char* name) {
         m_configuration.name = std::string{name} + m_configuration.name;
         m_configuration.port = std::string{name};
-        g_logger->log(HT_LOG_DEBUG, "wayland output {}: name {}", name, name);
+        g_logger->log(HT_LOG_DEBUG, "wayland output {}: name {}", m_id, name);
     });
 
     m_wlOutput.setScale([this](CCWlOutput* r, int32_t sc) { m_configuration.scale = sc; });
 
     m_wlOutput.setDone([this](CCWlOutput* r) {
         m_configuration.done = true;
-        g_logger->log(HT_LOG_DEBUG, "wayland output {} done", m_id);
+        g_logger->log(HT_LOG_DEBUG, "wayland output {}: done", m_id);
     });
 
     m_wlOutput.setMode([this](CCWlOutput* r, uint32_t flags, int32_t width, int32_t height, int32_t refresh) {
@@ -45,13 +44,13 @@ CWaylandOutput::CWaylandOutput(wl_proxy* wlResource, uint32_t id) : m_id(id), m_
         else
             m_configuration.size = {width, height};
 
-        g_logger->log(HT_LOG_DEBUG, "wayland output {} dimensions {}", m_id);
+        g_logger->log(HT_LOG_DEBUG, "wayland output {}: dimensions {}", m_id, m_configuration.size);
     });
 
     m_wlOutput.setGeometry(
         [this](CCWlOutput* r, int32_t x, int32_t y, int32_t physical_width, int32_t physical_height, int32_t subpixel, const char* make, const char* model, int32_t transform_) {
             m_configuration.transform = wlTransformToHyprutils((wl_output_transform)transform_);
 
-            g_logger->log(HT_LOG_DEBUG, "wayland output {} make {} model {}", m_id, make ? make : "", model ? model : "");
+            g_logger->log(HT_LOG_DEBUG, "wayland output {}: make {} model {}", m_id, make ? make : "", model ? model : "");
         });
 }

src/renderer/gl/OpenGL.cpp

@@ -62,6 +62,7 @@ static const char* eglErrorToString(EGLint error) {
 
 static void eglLog(EGLenum error, const char* command, EGLint type, EGLLabelKHR thread, EGLLabelKHR obj, const char* msg) {
     g_logger->log(eglLogToLevel(type), "[EGL] Command {} errored out with {} (0x{}): {}", command, eglErrorToString(error), error, msg);
+    RASSERT(false, "");
 }
 
 static GLuint compileShader(const GLuint& type, std::string src) {
@@ -502,6 +503,8 @@ COpenGLRenderer::COpenGLRenderer(int drmFD) {
 }
 
 COpenGLRenderer::~COpenGLRenderer() {
+    m_glTextures.clear();
+
     if (m_eglDisplay && m_eglContext != EGL_NO_CONTEXT)
         eglDestroyContext(m_eglDisplay, m_eglContext);
 

src/window/Builder.cpp

@@ -1,6 +1,8 @@
 #include "Window.hpp"
 #include "../core/InternalBackend.hpp"
 #include "ToolkitWindow.hpp"
+#include "core/platforms/WaylandPlatform.hpp"
+#include "hyprtoolkit/core/LogTypes.hpp"
 
 using namespace Hyprtoolkit;