Implement new Input Capture protocol

.gitmodules

@@ -1,6 +1,7 @@
 [submodule "subprojects/hyprland-protocols"]
 	path = subprojects/hyprland-protocols
-	url = https://github.com/hyprwm/hyprland-protocols
+	url = https://github.com/3l0w/hyprland-protocols
+	branch = feat/input-capture-impl
 [submodule "subprojects/udis86"]
 	path = subprojects/udis86
 	url = https://github.com/canihavesomecoffee/udis86

CMakeLists.txt

@@ -351,6 +351,8 @@ protocolnew("staging/xdg-dialog" "xdg-dialog-v1" false)
 protocolnew("staging/single-pixel-buffer" "single-pixel-buffer-v1" false)
 protocolnew("staging/security-context" "security-context-v1" false)
 
+protocolnew("subprojects/hyprland-protocols/protocols" "hyprland-input-capture-v1"
+            true)
 protocolwayland()
 
 # tools

hyprpm/src/core/PluginManager.cpp

@@ -464,7 +464,7 @@ bool CPluginManager::updateHeaders(bool force) {
         return false;
     }
 
-    progress.printMessageAbove(statusString("!", Colors::YELLOW, "Cloning https://github.com/hyprwm/Hyprland, this might take a moment."));
+    progress.printMessageAbove(statusString("!", Colors::YELLOW, "Cloning https://github.com/3l0w/Hyprland, this might take a moment."));
 
     const bool bShallow = (HLVER.branch == "main") && !m_bNoShallow;
 
@@ -475,12 +475,12 @@ bool CPluginManager::updateHeaders(bool force) {
     if (m_bVerbose && bShallow)
         progress.printMessageAbove(verboseString("will shallow since: {}", SHALLOW_DATE));
 
-    std::string ret = execAndGet(std::format("cd {} && git clone --recursive https://github.com/hyprwm/Hyprland hyprland-{}{}", getTempRoot(), USERNAME,
+    std::string ret = execAndGet(std::format("cd {} && git clone --recursive https://github.com/3l0w/Hyprland hyprland-{}{}", getTempRoot(), USERNAME,
                                              (bShallow ? " --shallow-since='" + SHALLOW_DATE + "'" : "")));
 
     if (!std::filesystem::exists(WORKINGDIR)) {
         progress.printMessageAbove(failureString("Clone failed. Retrying without shallow."));
-        ret = execAndGet(std::format("cd {} && git clone --recursive https://github.com/hyprwm/hyprland hyprland-{}", getTempRoot(), USERNAME));
+        ret = execAndGet(std::format("cd {} && git clone --recursive https://github.com/3l0w/hyprland hyprland-{}", getTempRoot(), USERNAME));
     }
 
     if (!std::filesystem::exists(WORKINGDIR + "/.git")) {

protocols/meson.build

@@ -37,6 +37,7 @@ protocols = [
 	hyprland_protocol_dir / 'protocols/hyprland-toplevel-export-v1.xml',
 	hyprland_protocol_dir / 'protocols/hyprland-focus-grab-v1.xml',
 	hyprland_protocol_dir / 'protocols/hyprland-ctm-control-v1.xml',
+	hyprland_protocol_dir / 'protocols/hyprland-input-capture-v1.xml',
 	wayland_protocol_dir / 'staging/tearing-control/tearing-control-v1.xml',
 	wayland_protocol_dir / 'staging/fractional-scale/fractional-scale-v1.xml',
 	wayland_protocol_dir / 'unstable/xdg-output/xdg-output-unstable-v1.xml',

src/managers/KeybindManager.cpp

@@ -5,13 +5,15 @@
 #include "../protocols/ShortcutsInhibit.hpp"
 #include "../protocols/GlobalShortcuts.hpp"
 #include "../render/decorations/CHyprGroupBarDecoration.hpp"
+#include "../devices/IKeyboard.hpp"
 #include "KeybindManager.hpp"
 #include "PointerManager.hpp"
 #include "Compositor.hpp"
 #include "TokenManager.hpp"
 #include "eventLoop/EventLoopManager.hpp"
 #include "debug/Log.hpp"
 #include "helpers/varlist/VarList.hpp"
+#include "protocols/InputCapture.hpp"
 
 #include <optional>
 #include <iterator>
@@ -126,6 +128,7 @@ CKeybindManager::CKeybindManager() {
     m_mDispatchers["event"]                          = event;
     m_mDispatchers["global"]                         = global;
     m_mDispatchers["setprop"]                        = setProp;
+    m_mDispatchers["releaseinputcapture"]            = releaseInputCapture;
 
     m_tScrollTimer.reset();
 
@@ -743,6 +746,14 @@ SDispatchResult CKeybindManager::handleKeybinds(const uint32_t modmask, const SP
 
             m_iPassPressed = (int)pressed;
 
+            // We only process the releaseinputcapture dispatcher when input capture is active
+            if (PROTO::inputCapture->isCaptured()) {
+                if (k->handler == "releaseinputcapture")
+                    res = DISPATCHER->second(k->arg);
+                else
+                    break;
+            }
+
             // if the dispatchers says to pass event then we will
             if (k->handler == "mouse")
                 res = DISPATCHER->second((pressed ? "1" : "0") + k->arg);
@@ -3053,3 +3064,7 @@ SDispatchResult CKeybindManager::setProp(std::string args) {
 
     return {};
 }
+SDispatchResult CKeybindManager::releaseInputCapture(std::string args) {
+    PROTO::inputCapture->forceRelease();
+    return {};
+}

src/managers/KeybindManager.hpp

@@ -215,6 +215,7 @@ class CKeybindManager {
     static SDispatchResult global(std::string);
     static SDispatchResult event(std::string);
     static SDispatchResult setProp(std::string);
+    static SDispatchResult releaseInputCapture(std::string);
 
     friend class CCompositor;
     friend class CInputManager;

src/managers/PointerManager.cpp

@@ -10,6 +10,7 @@
 #include "eventLoop/EventLoopManager.hpp"
 #include "../render/pass/TexPassElement.hpp"
 #include "SeatManager.hpp"
+#include "protocols/InputCapture.hpp"
 #include <cstring>
 #include <gbm.h>
 
@@ -699,6 +700,13 @@ void CPointerManager::move(const Vector2D& deltaLogical) {
     const auto oldPos = pointerPos;
     auto       newPos = oldPos + Vector2D{std::isnan(deltaLogical.x) ? 0.0 : deltaLogical.x, std::isnan(deltaLogical.y) ? 0.0 : deltaLogical.y};
 
+
+    if (!g_pInputManager->isLocked())
+        PROTO::inputCapture->sendMotion(newPos, deltaLogical);
+
+    if (PROTO::inputCapture->isCaptured())
+        return;
+
     warpTo(newPos);
 }
 
@@ -870,14 +878,7 @@ void CPointerManager::attachPointer(SP<IPointer> pointer) {
     });
 
     listener->frame = pointer->pointerEvents.frame.registerListener([] (std::any e) {
-        bool shouldSkip = false;
-        if (!g_pSeatManager->mouse.expired() && g_pInputManager->isLocked()) {
-            auto PMONITOR = g_pCompositor->m_pLastMonitor.get();
-            shouldSkip = PMONITOR && PMONITOR->shouldSkipScheduleFrameOnMouseEvent();
-        }
-        g_pSeatManager->isPointerFrameSkipped = shouldSkip;
-        if (!g_pSeatManager->isPointerFrameSkipped)
-            g_pSeatManager->sendPointerFrame();
+        g_pInputManager->onMouseFrame();
     });
 
     listener->swipeBegin = pointer->pointerEvents.swipeBegin.registerListener([] (std::any e) {

src/managers/ProtocolManager.cpp

@@ -47,6 +47,7 @@
 #include "../protocols/SinglePixel.hpp"
 #include "../protocols/SecurityContext.hpp"
 #include "../protocols/CTMControl.hpp"
+#include "../protocols/InputCapture.hpp"
 
 #include "../protocols/core/Seat.hpp"
 #include "../protocols/core/DataDevice.hpp"
@@ -159,6 +160,7 @@ CProtocolManager::CProtocolManager() {
     PROTO::singlePixel         = std::make_unique<CSinglePixelProtocol>(&wp_single_pixel_buffer_manager_v1_interface, 1, "SinglePixel");
     PROTO::securityContext     = std::make_unique<CSecurityContextProtocol>(&wp_security_context_manager_v1_interface, 1, "SecurityContext");
     PROTO::ctm                 = std::make_unique<CHyprlandCTMControlProtocol>(&hyprland_ctm_control_manager_v1_interface, 1, "CTMControl");
+    PROTO::inputCapture        = std::make_unique<CInputCaptureProtocol>(&hyprland_input_capture_manager_v1_interface, 1, "InputCapture");
 
     for (auto const& b : g_pCompositor->m_pAqBackend->getImplementations()) {
         if (b->type() != Aquamarine::AQ_BACKEND_DRM)
@@ -232,6 +234,7 @@ CProtocolManager::~CProtocolManager() {
     PROTO::singlePixel.reset();
     PROTO::securityContext.reset();
     PROTO::ctm.reset();
+    PROTO::inputCapture.reset();
 
     PROTO::lease.reset();
     PROTO::sync.reset();

src/managers/SeatManager.cpp

@@ -4,6 +4,7 @@
 #include "../protocols/DataDeviceWlr.hpp"
 #include "../protocols/PrimarySelection.hpp"
 #include "../protocols/core/Compositor.hpp"
+#include "../protocols/InputCapture.hpp"
 #include "../Compositor.hpp"
 #include "../devices/IKeyboard.hpp"
 #include "wlr-layer-shell-unstable-v1.hpp"
@@ -97,6 +98,7 @@ void CSeatManager::updateActiveKeyboardData() {
     if (keyboard)
         PROTO::seat->updateRepeatInfo(keyboard->repeatRate, keyboard->repeatDelay);
     PROTO::seat->updateKeymap();
+    PROTO::inputCapture->updateKeymap();
 }
 
 void CSeatManager::setKeyboardFocus(SP<CWLSurfaceResource> surf) {

src/managers/input/InputManager.cpp

@@ -19,6 +19,7 @@
 #include "../../protocols/core/DataDevice.hpp"
 #include "../../protocols/core/Compositor.hpp"
 #include "../../protocols/XDGShell.hpp"
+#include "../../protocols/InputCapture.hpp"
 
 #include "../../devices/Mouse.hpp"
 #include "../../devices/VirtualPointer.hpp"
@@ -99,6 +100,9 @@ void CInputManager::onMouseMoved(IPointer::SMotionEvent e) {
 
     g_pPointerManager->move(DELTA);
 
+    if (PROTO::inputCapture->isCaptured())
+        return;
+
     mouseMoveUnified(e.timeMs, false, e.mouse);
 
     m_tmrLastCursorMovement.reset();
@@ -545,6 +549,11 @@ void CInputManager::onMouseButton(IPointer::SButtonEvent e) {
     if (e.mouse)
         recheckMouseWarpOnMouseInput();
 
+    PROTO::inputCapture->sendButton(e.button, (hyprlandInputCaptureManagerV1ButtonState)e.state);
+
+    if (PROTO::inputCapture->isCaptured())
+        return;
+
     m_tmrLastCursorMovement.reset();
 
     if (e.state == WL_POINTER_BUTTON_STATE_PRESSED) {
@@ -782,7 +791,13 @@ void CInputManager::onMouseWheel(IPointer::SAxisEvent e) {
     if (e.mouse)
         recheckMouseWarpOnMouseInput();
 
-    bool passEvent = g_pKeybindManager->onAxisEvent(e);
+    PROTO::inputCapture->sendAxis((hyprlandInputCaptureManagerV1Axis)e.axis, e.delta);
+    if (e.source == 0)
+        PROTO::inputCapture->sendAxisValue120((hyprlandInputCaptureManagerV1Axis)e.axis, e.delta);
+    else if (e.delta == 0)
+        PROTO::inputCapture->sendAxisStop((hyprlandInputCaptureManagerV1Axis)e.axis);
+
+    bool passEvent = !PROTO::inputCapture->isCaptured() && g_pKeybindManager->onAxisEvent(e);
 
     if (!passEvent)
         return;
@@ -862,6 +877,22 @@ void CInputManager::onMouseWheel(IPointer::SAxisEvent e) {
     g_pSeatManager->sendPointerAxis(e.timeMs, e.axis, delta, deltaDiscrete, value120, e.source, WL_POINTER_AXIS_RELATIVE_DIRECTION_IDENTICAL);
 }
 
+void CInputManager::onMouseFrame() {
+    PROTO::inputCapture->sendFrame();
+
+    if (PROTO::inputCapture->isCaptured())
+        return;
+
+    bool shouldSkip = false;
+    if (!g_pSeatManager->mouse.expired() && g_pInputManager->isLocked()) {
+        auto PMONITOR = g_pCompositor->m_pLastMonitor.get();
+        shouldSkip    = PMONITOR && PMONITOR->shouldSkipScheduleFrameOnMouseEvent();
+    }
+    g_pSeatManager->isPointerFrameSkipped = shouldSkip;
+    if (!g_pSeatManager->isPointerFrameSkipped)
+        g_pSeatManager->sendPointerFrame();
+}
+
 Vector2D CInputManager::getMouseCoordsInternal() {
     return g_pPointerManager->position();
 }
@@ -1321,10 +1352,12 @@ void CInputManager::onKeyboardKey(std::any event, SP<IKeyboard> pKeyboard) {
     const auto EMAP = std::unordered_map<std::string, std::any>{{"keyboard", pKeyboard}, {"event", event}};
     EMIT_HOOK_EVENT_CANCELLABLE("keyPress", EMAP);
 
-    bool passEvent = DISALLOWACTION || g_pKeybindManager->onKeyEvent(event, pKeyboard);
+    bool passEvent = (DISALLOWACTION || g_pKeybindManager->onKeyEvent(event, pKeyboard)) && !PROTO::inputCapture->isCaptured();
 
     auto e = std::any_cast<IKeyboard::SKeyEvent>(event);
 
+    PROTO::inputCapture->sendKey(e.keycode, (hyprlandInputCaptureManagerV1KeyState)e.state);
+
     if (passEvent) {
         const auto IME = m_sIMERelay.m_pIME.lock();
 
@@ -1351,6 +1384,11 @@ void CInputManager::onKeyboardMod(SP<IKeyboard> pKeyboard) {
     auto       MODS = pKeyboard->modifiersState;
     MODS.depressed  = ALLMODS;
 
+    PROTO::inputCapture->sendModifiers(MODS.depressed,MODS.latched, MODS.locked, MODS.group);
+
+    if (PROTO::inputCapture->isCaptured())
+        return;
+
     const auto IME = m_sIMERelay.m_pIME.lock();
 
     if (IME && IME->hasGrab() && !DISALLOWACTION) {

src/managers/input/InputManager.hpp

@@ -87,6 +87,7 @@ class CInputManager {
     void               onMouseWarp(IPointer::SMotionAbsoluteEvent);
     void               onMouseButton(IPointer::SButtonEvent);
     void               onMouseWheel(IPointer::SAxisEvent);
+    void               onMouseFrame();
     void               onKeyboardKey(std::any, SP<IKeyboard>);
     void               onKeyboardMod(SP<IKeyboard>);
 

src/protocols/InputCapture.cpp

@@ -0,0 +1,111 @@
+#include "InputCapture.hpp"
+
+#include "managers/SeatManager.hpp"
+#include <fcntl.h>
+
+CInputCaptureProtocol::CInputCaptureProtocol(const wl_interface* iface, const int& ver, const std::string& name) : IWaylandProtocol(iface, ver, name) {
+    ;
+}
+
+void CInputCaptureProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) {
+    const auto& RESOURCE = m_vManagers.emplace_back(std::make_unique<CHyprlandInputCaptureManagerV1>(client, ver, id));
+
+    RESOURCE->setOnDestroy([this](CHyprlandInputCaptureManagerV1* p) { std::erase_if(m_vManagers, [&](const auto& other) { return other->resource() == p->resource(); }); });
+
+    RESOURCE->setCapture([this](CHyprlandInputCaptureManagerV1* p) {
+        Debug::log(LOG, "[input-capture] Input captured");
+        active = true;
+    });
+    RESOURCE->setRelease([this](CHyprlandInputCaptureManagerV1* p) {
+        Debug::log(LOG, "[input-capture] Input released");
+        active = false;
+    });
+
+    sendKeymap(g_pSeatManager->keyboard.lock(), RESOURCE);
+}
+
+bool CInputCaptureProtocol::isCaptured() {
+    return active;
+}
+
+void CInputCaptureProtocol::updateKeymap() {
+    for (const auto& manager : m_vManagers)
+        sendKeymap(g_pSeatManager->keyboard.lock(), manager);
+}
+
+void CInputCaptureProtocol::sendMotion(const Vector2D& absolutePosition, const Vector2D& delta) {
+    for (const auto& manager : m_vManagers) {
+        manager->sendMotion(wl_fixed_from_double(absolutePosition.x), wl_fixed_from_double(absolutePosition.y), wl_fixed_from_double(delta.x), wl_fixed_from_double(delta.y));
+    }
+}
+
+void CInputCaptureProtocol::sendKeymap(SP<IKeyboard> keyboard, const std::unique_ptr<CHyprlandInputCaptureManagerV1>& manager) {
+    if (!keyboard)
+        return;
+
+    hyprlandInputCaptureManagerV1KeymapFormat format;
+    int                                       fd;
+    uint32_t                                  size;
+    if (keyboard) {
+        format = HYPRLAND_INPUT_CAPTURE_MANAGER_V1_KEYMAP_FORMAT_XKB_V1;
+        fd     = keyboard->xkbKeymapFD;
+        size   = keyboard->xkbKeymapString.length() + 1;
+    } else {
+        format = HYPRLAND_INPUT_CAPTURE_MANAGER_V1_KEYMAP_FORMAT_NO_KEYMAP;
+        fd     = open("/dev/null", O_RDONLY | O_CLOEXEC);
+        if (fd < 0) {
+            LOGM(ERR, "Failed to open /dev/null");
+            return;
+        }
+        size = 0;
+    }
+
+    manager->sendKeymap(format, fd, size);
+
+    if (!keyboard)
+        close(fd);
+}
+
+void CInputCaptureProtocol::forceRelease() {
+    Debug::log(LOG, "[input-capture] Force Input released");
+    active = false;
+
+    for (const auto& manager : m_vManagers)
+        manager->sendForceRelease();
+}
+
+void CInputCaptureProtocol::sendKey(uint32_t keyCode, hyprlandInputCaptureManagerV1KeyState state) {
+    for (const auto& manager : m_vManagers)
+        manager->sendKey(keyCode, state);
+}
+
+void CInputCaptureProtocol::sendModifiers(uint32_t mods_depressed, uint32_t mods_latched, uint32_t mods_locked, uint32_t group) {
+    for (const auto& manager : m_vManagers)
+        manager->sendModifiers(mods_depressed, mods_locked, mods_locked, group);
+}
+
+
+void CInputCaptureProtocol::sendButton(uint32_t button, hyprlandInputCaptureManagerV1ButtonState state) {
+    for (const auto& manager : m_vManagers)
+        manager->sendButton(button, state);
+}
+
+void CInputCaptureProtocol::sendAxis(hyprlandInputCaptureManagerV1Axis axis, double value) {
+    for (const auto& manager : m_vManagers)
+        manager->sendAxis(axis, value);
+}
+
+void CInputCaptureProtocol::sendAxisValue120(hyprlandInputCaptureManagerV1Axis axis, int32_t value120) {
+    for (const auto& manager : m_vManagers)
+        manager->sendAxisValue120(axis, value120);
+}
+
+void CInputCaptureProtocol::sendAxisStop(hyprlandInputCaptureManagerV1Axis axis) {
+    for (const auto& manager : m_vManagers)
+        manager->sendAxisStop(axis);
+}
+
+void CInputCaptureProtocol::sendFrame() {
+    for (const auto& manager : m_vManagers)
+        manager->sendFrame();
+}