mirror/Hyprland
3
0
Fork 0
mirror of https://github.com/hyprwm/Hyprland.git synced 2025-10-29 11:22:47 +00:00
Code Issues Projects Releases Wiki Activity

protocols: implement pointer-warp-v1 (#11469)

Browse Source
This commit is contained in:
Ikalco 2025-08-29 15:16:40 -05:00 committed by GitHub
parent 05a1c0aa73
commit ea42041f93
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
17 changed files with 699 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
CMakeLists.txt
View File

@ -132,7 +132,7 @@ pkg_check_modules(
xkbcommon
uuid
wayland-server>=1.22.90
wayland-protocols>=1.43
wayland-protocols>=1.45
cairo
pango
pangocairo
@ -383,6 +383,7 @@ protocolnew("staging/xdg-toplevel-tag" "xdg-toplevel-tag-v1" false)
protocolnew("staging/xdg-system-bell" "xdg-system-bell-v1" false)
protocolnew("staging/ext-workspace" "ext-workspace-v1" false)
protocolnew("staging/ext-data-control" "ext-data-control-v1" false)
protocolnew("staging/pointer-warp" "pointer-warp-v1" false)
protocolwayland()

70
hyprtester/CMakeLists.txt
View File

@ -5,6 +5,7 @@ project(hyprtester DESCRIPTION "Hyprland test suite")
include(GNUInstallDirs)
set(CMAKE_CXX_STANDARD 26)
set(CMAKE_EXPORT_COMPILE_COMMANDS TRUE)
find_package(PkgConfig REQUIRED)
@ -28,3 +29,72 @@ install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/test.conf
install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/plugin/hyprtestplugin.so
DESTINATION ${CMAKE_INSTALL_PREFIX}/lib)
file(WRITE ${CMAKE_CURRENT_SOURCE_DIR}/src/tests/clients/build.hpp
"#include <string>\n"
"static const std::string binaryDir = \"${CMAKE_CURRENT_BINARY_DIR}\";"
)
######## wayland protocols testing stuff
if(CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES DEBUG)
set(CMAKE_EXECUTABLE_ENABLE_EXPORTS TRUE)
endif()
find_package(hyprwayland-scanner 0.4.0 REQUIRED)
pkg_check_modules(
protocols_deps
REQUIRED
IMPORTED_TARGET
hyprutils>=0.8.0
wayland-client
wayland-protocols
)
pkg_get_variable(WAYLAND_PROTOCOLS_DIR wayland-protocols pkgdatadir)
message(STATUS "Found wayland-protocols at ${WAYLAND_PROTOCOLS_DIR}")
pkg_get_variable(WAYLAND_SCANNER_PKGDATA_DIR wayland-scanner pkgdatadir)
message(STATUS "Found wayland-scanner pkgdatadir at ${WAYLAND_SCANNER_PKGDATA_DIR}")
# gen core wayland stuff
add_custom_command(
OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/protocols/wayland.cpp
${CMAKE_CURRENT_SOURCE_DIR}/protocols/wayland.hpp
COMMAND hyprwayland-scanner --wayland-enums --client
${WAYLAND_SCANNER_PKGDATA_DIR}/wayland.xml ${CMAKE_CURRENT_SOURCE_DIR}/protocols/
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
function(protocolNew protoPath protoName external)
if(external)
set(path ${CMAKE_CURRENT_SOURCE_DIR}/${protoPath})
else()
set(path ${WAYLAND_PROTOCOLS_DIR}/${protoPath})
endif()
add_custom_command(
OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/protocols/${protoName}.cpp
${CMAKE_CURRENT_SOURCE_DIR}/protocols/${protoName}.hpp
COMMAND hyprwayland-scanner --client ${path}/${protoName}.xml
${CMAKE_CURRENT_SOURCE_DIR}/protocols/
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
endfunction()
function(clientNew sourceName)
cmake_parse_arguments(PARSE_ARGV 1 ARG "" "" "PROTOS")
add_executable(${sourceName} clients/${sourceName}.cpp)
target_include_directories(${sourceName} BEFORE PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/protocols")
target_link_libraries(${sourceName} PUBLIC PkgConfig::protocols_deps)
target_sources(${sourceName} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/protocols/wayland.cpp ${CMAKE_CURRENT_SOURCE_DIR}/protocols/wayland.hpp)
foreach(protoName IN LISTS ARG_PROTOS)
target_sources(${sourceName} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/protocols/${protoName}.cpp
${CMAKE_CURRENT_SOURCE_DIR}/protocols/${protoName}.hpp)
endforeach()
endfunction()
protocolnew("staging/pointer-warp" "pointer-warp-v1" false)
protocolnew("stable/xdg-shell" "xdg-shell" false)
clientNew("pointer-warp" PROTOS "pointer-warp-v1" "xdg-shell")

317
hyprtester/clients/pointer-warp.cpp Normal file
View File

@ -0,0 +1,317 @@
#include <cstring>
#include <sys/poll.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <print>
#include <format>
#include <string>
#include <wayland-client.h>
#include <wayland.hpp>
#include <xdg-shell.hpp>
#include <pointer-warp-v1.hpp>
#include <hyprutils/memory/SharedPtr.hpp>
#include <hyprutils/math/Vector2D.hpp>
#include <hyprutils/os/FileDescriptor.hpp>
using Hyprutils::Math::Vector2D;
using namespace Hyprutils::Memory;
struct SWlState {
wl_display* display;
CSharedPointer<CCWlRegistry> registry;
// protocols
CSharedPointer<CCWlCompositor> wlCompositor;
CSharedPointer<CCWlSeat> wlSeat;
CSharedPointer<CCWlShm> wlShm;
CSharedPointer<CCXdgWmBase> xdgShell;
CSharedPointer<CCWpPointerWarpV1> pointerWarp;
// shm/buffer stuff
CSharedPointer<CCWlShmPool> shmPool;
CSharedPointer<CCWlBuffer> shmBuf;
int shmFd;
size_t shmBufSize;
bool xrgb8888_support = false;
// surface/toplevel stuff
CSharedPointer<CCWlSurface> surf;
CSharedPointer<CCXdgSurface> xdgSurf;
CSharedPointer<CCXdgToplevel> xdgToplevel;
Vector2D geom;
// pointer
CSharedPointer<CCWlPointer> pointer;
uint32_t enterSerial;
};
static bool debug, started, shouldExit;
template <typename... Args>
//NOLINTNEXTLINE
static void clientLog(std::format_string<Args...> fmt, Args&&... args) {
std::println("{}", std::vformat(fmt.get(), std::make_format_args(args...)));
std::fflush(stdout);
}
template <typename... Args>
//NOLINTNEXTLINE
static void debugLog(std::format_string<Args...> fmt, Args&&... args) {
if (!debug)
return;
std::println("{}", std::vformat(fmt.get(), std::make_format_args(args...)));
std::fflush(stdout);
}
static bool bindRegistry(SWlState& state) {
state.registry = makeShared<CCWlRegistry>((wl_proxy*)wl_display_get_registry(state.display));
state.registry->setGlobal([&](CCWlRegistry* r, uint32_t id, const char* name, uint32_t version) {
const std::string NAME = name;
if (NAME == "wl_compositor") {
debugLog(" > binding to global: {} (version {}) with id {}", name, version, id);
state.wlCompositor = makeShared<CCWlCompositor>((wl_proxy*)wl_registry_bind((wl_registry*)state.registry->resource(), id, &wl_compositor_interface, 6));
} else if (NAME == "wl_shm") {
debugLog(" > binding to global: {} (version {}) with id {}", name, version, id);
state.wlShm = makeShared<CCWlShm>((wl_proxy*)wl_registry_bind((wl_registry*)state.registry->resource(), id, &wl_shm_interface, 1));
} else if (NAME == "wl_seat") {
debugLog(" > binding to global: {} (version {}) with id {}", name, version, id);
state.wlSeat = makeShared<CCWlSeat>((wl_proxy*)wl_registry_bind((wl_registry*)state.registry->resource(), id, &wl_seat_interface, 9));
} else if (NAME == "xdg_wm_base") {
debugLog(" > binding to global: {} (version {}) with id {}", name, version, id);
state.xdgShell = makeShared<CCXdgWmBase>((wl_proxy*)wl_registry_bind((wl_registry*)state.registry->resource(), id, &xdg_wm_base_interface, 1));
} else if (NAME == "wp_pointer_warp_v1") {
debugLog(" > binding to global: {} (version {}) with id {}", name, version, id);
state.pointerWarp = makeShared<CCWpPointerWarpV1>((wl_proxy*)wl_registry_bind((wl_registry*)state.registry->resource(), id, &wp_pointer_warp_v1_interface, 1));
}
});
state.registry->setGlobalRemove([](CCWlRegistry* r, uint32_t id) { debugLog("Global {} removed", id); });
wl_display_roundtrip(state.display);
if (!state.wlCompositor || !state.wlShm || !state.wlSeat || !state.xdgShell || !state.pointerWarp) {
clientLog("Failed to get protocols from Hyprland");
return false;
}
return true;
}
static bool createShm(SWlState& state, Vector2D geom) {
if (!state.xrgb8888_support)
return false;
size_t stride = geom.x * 4;
size_t size = geom.y * stride;
if (!state.shmPool) {
const char* name = "/wl-shm-pointer-warp";
state.shmFd = shm_open(name, O_RDWR | O_CREAT | O_EXCL, 0600);
if (state.shmFd < 0)
return false;
if (shm_unlink(name) < 0 || ftruncate(state.shmFd, size) < 0) {
close(state.shmFd);
return false;
}
state.shmPool = makeShared<CCWlShmPool>(state.wlShm->sendCreatePool(state.shmFd, size));
if (!state.shmPool->resource()) {
close(state.shmFd);
state.shmFd = -1;
state.shmPool.reset();
return false;
}
state.shmBufSize = size;
} else if (size > state.shmBufSize) {
if (ftruncate(state.shmFd, size) < 0) {
close(state.shmFd);
state.shmFd = -1;
state.shmPool.reset();
return false;
}
state.shmPool->sendResize(size);
state.shmBufSize = size;
}
auto buf = makeShared<CCWlBuffer>(state.shmPool->sendCreateBuffer(0, geom.x, geom.y, stride, WL_SHM_FORMAT_XRGB8888));
if (!buf->resource())
return false;
if (state.shmBuf) {
state.shmBuf->sendDestroy();
state.shmBuf.reset();
}
state.shmBuf = buf;
return true;
}
static bool setupToplevel(SWlState& state) {
state.wlShm->setFormat([&](CCWlShm* p, uint32_t format) {
if (format == WL_SHM_FORMAT_XRGB8888)
state.xrgb8888_support = true;
});
state.xdgShell->setPing([&](CCXdgWmBase* p, uint32_t serial) { state.xdgShell->sendPong(serial); });
state.surf = makeShared<CCWlSurface>(state.wlCompositor->sendCreateSurface());
if (!state.surf->resource())
return false;
state.xdgSurf = makeShared<CCXdgSurface>(state.xdgShell->sendGetXdgSurface(state.surf->resource()));
if (!state.xdgSurf->resource())
return false;
state.xdgToplevel = makeShared<CCXdgToplevel>(state.xdgSurf->sendGetToplevel());
if (!state.xdgToplevel->resource())
return false;
state.xdgToplevel->setClose([&](CCXdgToplevel* p) { exit(0); });
state.xdgToplevel->setConfigure([&](CCXdgToplevel* p, int32_t w, int32_t h, wl_array* arr) {
state.geom = {1280, 720};
if (!createShm(state, state.geom))
exit(-1);
});
state.xdgSurf->setConfigure([&](CCXdgSurface* p, uint32_t serial) {
if (!state.shmBuf)
debugLog("xdgSurf configure but no buf made yet?");
state.xdgSurf->sendSetWindowGeometry(0, 0, state.geom.x, state.geom.y);
state.surf->sendAttach(state.shmBuf.get(), 0, 0);
state.surf->sendCommit();
state.xdgSurf->sendAckConfigure(serial);
if (!started) {
started = true;
clientLog("started");
}
});
state.xdgToplevel->sendSetTitle("pointer-warp test client");
state.xdgToplevel->sendSetAppId("pointer-warp");
state.surf->sendAttach(nullptr, 0, 0);
state.surf->sendCommit();
return true;
}
static bool setupSeat(SWlState& state) {
state.pointer = makeShared<CCWlPointer>(state.wlSeat->sendGetPointer());
if (!state.pointer->resource())
return false;
state.pointer->setEnter([&](CCWlPointer* p, uint32_t serial, wl_proxy* surf, wl_fixed_t x, wl_fixed_t y) {
debugLog("Got pointer enter event, serial {}, x {}, y {}", serial, x, y);
state.enterSerial = serial;
});
state.pointer->setLeave([&](CCWlPointer* p, uint32_t serial, wl_proxy* surf) { debugLog("Got pointer leave event, serial {}", serial); });
state.pointer->setMotion([&](CCWlPointer* p, uint32_t serial, wl_fixed_t x, wl_fixed_t y) { debugLog("Got pointer motion event, serial {}, x {}, y {}", serial, x, y); });
return true;
}
// format is like below
// "warp 20 20\n" would ask to warp cursor to x=20,y=20 in surface local coords
static void parseRequest(SWlState& state, std::string req) {
if (req.contains("exit")) {
shouldExit = true;
return;
}
if (!req.starts_with("warp "))
return;
auto it = req.find_first_of('\n');
if (it == std::string::npos)
return;
req = req.substr(0, it);
it = req.find_first_of(' ');
if (it == std::string::npos)
return;
req = req.substr(it + 1);
it = req.find_first_of(' ');
int x = std::stoi(req.substr(0, it));
int y = std::stoi(req.substr(it + 1));
state.pointerWarp->sendWarpPointer(state.surf->resource(), state.pointer->resource(), wl_fixed_from_int(x), wl_fixed_from_int(y), state.enterSerial);
// sync the request then reply
wl_display_roundtrip(state.display);
clientLog("parsed request to move to x:{}, y:{}", x, y);
}
int main(int argc, char** argv) {
if (argc != 1 && argc != 2)
clientLog("Only the \"--debug\" switch is allowed, it turns on debug logs.");
if (argc == 2 && std::string{argv[1]} == "--debug")
debug = true;
SWlState state;
// WAYLAND_DISPLAY env should be set to the correct one
state.display = wl_display_connect(nullptr);
if (!state.display) {
clientLog("Failed to connect to wayland display");
return -1;
}
if (!bindRegistry(state) || !setupSeat(state) || !setupToplevel(state))
return -1;
std::array<char, 1024> readBuf;
readBuf.fill(0);
wl_display_flush(state.display);
struct pollfd fds[2] = {{.fd = wl_display_get_fd(state.display), .events = POLLIN | POLLOUT}, {.fd = STDIN_FILENO, .events = POLLIN}};
while (!shouldExit && poll(fds, 2, 0) != -1) {
if (fds[0].revents & POLLIN) {
wl_display_flush(state.display);
if (wl_display_prepare_read(state.display) == 0) {
wl_display_read_events(state.display);
wl_display_dispatch_pending(state.display);
} else
wl_display_dispatch(state.display);
int ret = 0;
do {
ret = wl_display_dispatch_pending(state.display);
wl_display_flush(state.display);
} while (ret > 0);
}
if (fds[1].revents & POLLIN) {
ssize_t bytesRead = read(fds[1].fd, readBuf.data(), 1023);
if (bytesRead == -1)
continue;
readBuf[bytesRead] = 0;
parseRequest(state, std::string{readBuf.data()});
}
}
wl_display* display = state.display;
state = {};
wl_display_disconnect(display);
return 0;
}

2
hyprtester/protocols/.gitignore vendored Normal file
View File

@ -0,0 +1,2 @@
*
!.gitignore

9
hyprtester/src/main.cpp
View File

@ -17,6 +17,7 @@
#include "shared.hpp"
#include "hyprctlCompat.hpp"
#include "tests/main/tests.hpp"
#include "tests/clients/tests.hpp"
#include "tests/plugin/plugin.hpp"
#include <filesystem>
@ -227,10 +228,18 @@ int main(int argc, char** argv, char** envp) {
NLog::log("{}Loaded plugin", Colors::YELLOW);
NLog::log("{}Running main tests", Colors::YELLOW);
for (const auto& fn : testFns) {
EXPECT(fn(), true);
}
NLog::log("{}Running protocol client tests", Colors::YELLOW);
for (const auto& fn : clientTestFns) {
EXPECT(fn(), true);
}
NLog::log("{}running plugin test", Colors::YELLOW);
EXPECT(testPlugin(), true);

1
hyprtester/src/tests/clients/.gitignore vendored Normal file
View File

@ -0,0 +1 @@
build.hpp

180
hyprtester/src/tests/clients/pointer-warp.cpp Normal file
View File

@ -0,0 +1,180 @@
#include "../../shared.hpp"
#include "../../hyprctlCompat.hpp"
#include "../shared.hpp"
#include "tests.hpp"
#include "build.hpp"
#include <hyprutils/os/FileDescriptor.hpp>
#include <hyprutils/os/Process.hpp>
#include <sys/poll.h>
#include <csignal>
#include <thread>
using namespace Hyprutils::OS;
using namespace Hyprutils::Memory;
#define SP CSharedPointer
struct SClient {
SP<CProcess> proc;
std::array<char, 1024> readBuf;
CFileDescriptor readFd, writeFd;
struct pollfd fds;
};
static int ret;
static bool startClient(SClient& client) {
client.proc = makeShared<CProcess>(binaryDir + "/pointer-warp", std::vector<std::string>{});
client.proc->addEnv("WAYLAND_DISPLAY", WLDISPLAY);
int pipeFds1[2], pipeFds2[2];
if (pipe(pipeFds1) != 0 || pipe(pipeFds2) != 0) {
NLog::log("{}Unable to open pipe to client", Colors::RED);
return false;
}
client.writeFd = CFileDescriptor(pipeFds1[1]);
client.proc->setStdinFD(pipeFds1[0]);
client.readFd = CFileDescriptor(pipeFds2[0]);
client.proc->setStdoutFD(pipeFds2[1]);
client.proc->runAsync();
close(pipeFds1[0]);
close(pipeFds2[1]);
client.fds = {.fd = client.readFd.get(), .events = POLLIN};
if (poll(&client.fds, 1, 1000) != 1 || !(client.fds.revents & POLLIN))
return false;
client.readBuf.fill(0);
if (read(client.readFd.get(), client.readBuf.data(), client.readBuf.size() - 1) == -1)
return false;
std::string ret = std::string{client.readBuf.data()};
if (ret.find("started") == std::string::npos) {
NLog::log("{}Failed to start pointer-warp client, read {}", Colors::RED, ret);
return false;
}
// wait for window to appear
std::this_thread::sleep_for(std::chrono::milliseconds(5000));
if (getFromSocket(std::format("/dispatch setprop pid:{} noanim 1", client.proc->pid())) != "ok") {
NLog::log("{}Failed to disable animations for client window", Colors::RED, ret);
return false;
}
if (getFromSocket(std::format("/dispatch focuswindow pid:{}", client.proc->pid())) != "ok") {
NLog::log("{}Failed to focus pointer-warp client", Colors::RED, ret);
return false;
}
NLog::log("{}Started pointer-warp client", Colors::YELLOW);
return true;
}
static void stopClient(SClient& client) {
std::string cmd = "exit\n";
write(client.writeFd.get(), cmd.c_str(), cmd.length());
kill(client.proc->pid(), SIGKILL);
client.proc.reset();
}
// format is like below
// "warp 20 20\n" would ask to warp cursor to x=20,y=20 in surface local coords
static bool sendWarp(SClient& client, int x, int y) {
std::string cmd = std::format("warp {} {}\n", x, y);
if ((size_t)write(client.writeFd.get(), cmd.c_str(), cmd.length()) != cmd.length())
return false;
if (poll(&client.fds, 1, 1500) != 1 || !(client.fds.revents & POLLIN))
return false;
ssize_t bytesRead = read(client.fds.fd, client.readBuf.data(), 1023);
if (bytesRead == -1)
return false;
client.readBuf[bytesRead] = 0;
std::string recieved = std::string{client.readBuf.data()};
recieved.pop_back();
return true;
}
static bool isCursorPos(int x, int y) {
// TODO: add a better way to do this using test plugin?
std::string res = getFromSocket("/cursorpos");
if (res == "error") {
NLog::log("{}Cursorpos err'd: {}", Colors::RED, res);
return false;
}
auto it = res.find_first_of(' ');
if (res.at(it - 1) != ',') {
NLog::log("{}Cursorpos err'd: {}", Colors::RED, res);
return false;
}
int cursorX = std::stoi(res.substr(0, it - 1));
int cursorY = std::stoi(res.substr(it + 1));
// somehow this is always gives 1 less than surfbox->pos()??
res = getFromSocket("/activewindow");
it = res.find("at: ") + 4;
res = res.substr(it, res.find_first_of('\n', it) - it);
it = res.find_first_of(',');
int clientX = cursorX - std::stoi(res.substr(0, it)) + 1;
int clientY = cursorY - std::stoi(res.substr(it + 1)) + 1;
return clientX == x && clientY == y;
}
static bool test() {
SClient client;
if (!startClient(client))
return false;
EXPECT(sendWarp(client, 100, 100), true);
EXPECT(isCursorPos(100, 100), true);
EXPECT(sendWarp(client, 0, 0), true);
EXPECT(isCursorPos(0, 0), true);
EXPECT(sendWarp(client, 200, 200), true);
EXPECT(isCursorPos(200, 200), true);
EXPECT(sendWarp(client, 100, -100), true);
EXPECT(isCursorPos(200, 200), true);
EXPECT(sendWarp(client, 234, 345), true);
EXPECT(isCursorPos(234, 345), true);
EXPECT(sendWarp(client, -1, -1), true);
EXPECT(isCursorPos(234, 345), true);
EXPECT(sendWarp(client, 1, -1), true);
EXPECT(isCursorPos(234, 345), true);
EXPECT(sendWarp(client, 13, 37), true);
EXPECT(isCursorPos(13, 37), true);
EXPECT(sendWarp(client, -100, 100), true);
EXPECT(isCursorPos(13, 37), true);
EXPECT(sendWarp(client, -1, 1), true);
EXPECT(isCursorPos(13, 37), true);
stopClient(client);
return true;
}
REGISTER_CLIENT_TEST_FN(test);

12
hyprtester/src/tests/clients/tests.hpp Normal file
View File

@ -0,0 +1,12 @@
#pragma once
#include <vector>
#include <functional>
inline std::vector<std::function<bool()>> clientTestFns;
#define REGISTER_CLIENT_TEST_FN(fn) \
static auto _register_fn = [] { \
clientTestFns.emplace_back(fn); \
return 1; \
}();

8
nix/hyprtester.nix
View File

@ -40,12 +40,20 @@ in
buildInputs = hyprland.buildInputs;
preConfigure = ''
substituteInPlace hyprtester/CMakeLists.txt --replace-fail \
"\''${CMAKE_CURRENT_BINARY_DIR}" \
"${placeholder "out"}/bin"
cmake -S . -B .
cmake --build . --target generate-protocol-headers -j`nproc 2>/dev/null || getconf NPROCESSORS_CONF`
cd hyprtester
'';
postInstall = ''
install pointer-warp -t $out/bin
'';
cmakeBuildType = "Debug";
cmakeFlags = [(cmakeBool "TESTS" true)];

3
protocols/meson.build
View File

@ -1,6 +1,6 @@
wayland_protos = dependency(
'wayland-protocols',
version: '>=1.43',
version: '>=1.45',
fallback: 'wayland-protocols',
default_options: ['tests=false'],
)
@ -77,6 +77,7 @@ protocols = [
wayland_protocol_dir / 'staging/xdg-system-bell/xdg-system-bell-v1.xml',
wayland_protocol_dir / 'staging/ext-workspace/ext-workspace-v1.xml',
wayland_protocol_dir / 'staging/ext-data-control/ext-data-control-v1.xml',
wayland_protocol_dir / 'staging/pointer-warp/pointer-warp-v1.xml',
]
wl_protocols = []

3
src/managers/ProtocolManager.cpp
View File

@ -64,6 +64,7 @@
#include "../protocols/XDGBell.hpp"
#include "../protocols/ExtWorkspace.hpp"
#include "../protocols/ExtDataDevice.hpp"
#include "../protocols/PointerWarp.hpp"
#include "../helpers/Monitor.hpp"
#include "../render/Renderer.hpp"
@ -192,6 +193,7 @@ CProtocolManager::CProtocolManager() {
PROTO::xdgBell = makeUnique<CXDGSystemBellProtocol>(&xdg_system_bell_v1_interface, 1, "XDGBell");
PROTO::extWorkspace = makeUnique<CExtWorkspaceProtocol>(&ext_workspace_manager_v1_interface, 1, "ExtWorkspace");
PROTO::extDataDevice = makeUnique<CExtDataDeviceProtocol>(&ext_data_control_manager_v1_interface, 1, "ExtDataDevice");
PROTO::pointerWarp = makeUnique<CPointerWarpProtocol>(&wp_pointer_warp_v1_interface, 1, "PointerWarp");
if (*PENABLECM)
PROTO::colorManagement = makeUnique<CColorManagementProtocol>(&wp_color_manager_v1_interface, 1, "ColorManagement", *PDEBUGCM);
@ -295,6 +297,7 @@ CProtocolManager::~CProtocolManager() {
PROTO::xdgBell.reset();
PROTO::extWorkspace.reset();
PROTO::extDataDevice.reset();
PROTO::pointerWarp.reset();
for (auto& [_, lease] : PROTO::lease) {
lease.reset();

5
src/managers/SeatManager.cpp
View File

@ -58,7 +58,7 @@ uint32_t CSeatManager::nextSerial(SP<CWLSeatResource> seatResource) {
return serial;
}
bool CSeatManager::serialValid(SP<CWLSeatResource> seatResource, uint32_t serial) {
bool CSeatManager::serialValid(SP<CWLSeatResource> seatResource, uint32_t serial, bool erase) {
if (!seatResource)
return false;
@ -68,7 +68,8 @@ bool CSeatManager::serialValid(SP<CWLSeatResource> seatResource, uint32_t serial
for (auto it = container->serials.begin(); it != container->serials.end(); ++it) {
if (*it == serial) {
container->serials.erase(it);
if (erase)
container->serials.erase(it);
return true;
}
}

2
src/managers/SeatManager.hpp
View File

@ -76,7 +76,7 @@ class CSeatManager {
uint32_t nextSerial(SP<CWLSeatResource> seatResource);
// pops the serial if it was valid, meaning it is consumed.
bool serialValid(SP<CWLSeatResource> seatResource, uint32_t serial);
bool serialValid(SP<CWLSeatResource> seatResource, uint32_t serial, bool erase = true);
void onSetCursor(SP<CWLSeatResource> seatResource, uint32_t serial, SP<CWLSurfaceResource> surf, const Vector2D& hotspot);

53
src/protocols/PointerWarp.cpp Normal file
View File

@ -0,0 +1,53 @@
#include "PointerWarp.hpp"
#include "core/Compositor.hpp"
#include "core/Seat.hpp"
#include "../desktop/WLSurface.hpp"
#include "../managers/SeatManager.hpp"
#include "../managers/PointerManager.hpp"
#include "../desktop/Window.hpp"
CPointerWarpProtocol::CPointerWarpProtocol(const wl_interface* iface, const int& ver, const std::string& name) : IWaylandProtocol(iface, ver, name) {
;
}
void CPointerWarpProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) {
const auto& RESOURCE = m_managers.emplace_back(makeUnique<CWpPointerWarpV1>(client, ver, id));
if UNLIKELY (!RESOURCE->resource()) {
wl_client_post_no_memory(client);
m_managers.pop_back();
return;
}
RESOURCE->setOnDestroy([this](CWpPointerWarpV1* pMgr) { destroyManager(pMgr); });
RESOURCE->setDestroy([this](CWpPointerWarpV1* pMgr) { destroyManager(pMgr); });
RESOURCE->setWarpPointer([](CWpPointerWarpV1* pMgr, wl_resource* surface, wl_resource* pointer, wl_fixed_t x, wl_fixed_t y, uint32_t serial) {
const auto PSURFACE = CWLSurfaceResource::fromResource(surface);
if (g_pSeatManager->m_state.pointerFocus != PSURFACE)
return;
auto SURFBOXV = CWLSurface::fromResource(PSURFACE)->getSurfaceBoxGlobal();
if (!SURFBOXV.has_value())
return;
const auto SURFBOX = SURFBOXV->expand(1);
const auto LOCALPOS = Vector2D{wl_fixed_to_double(x), wl_fixed_to_double(y)};
const auto GLOBALPOS = LOCALPOS + SURFBOX.pos();
if (!SURFBOX.containsPoint(GLOBALPOS))
return;
const auto PSEAT = CWLPointerResource::fromResource(pointer)->m_owner.lock();
if (!g_pSeatManager->serialValid(PSEAT, serial, false))
return;
LOGM(LOG, "warped pointer to {}", GLOBALPOS);
g_pPointerManager->warpTo(GLOBALPOS);
g_pSeatManager->sendPointerMotion(Time::millis(Time::steadyNow()), LOCALPOS);
});
}
void CPointerWarpProtocol::destroyManager(CWpPointerWarpV1* manager) {
std::erase_if(m_managers, [&](const UP<CWpPointerWarpV1>& resource) { return resource.get() == manager; });
}

21
src/protocols/PointerWarp.hpp Normal file
View File

@ -0,0 +1,21 @@
#pragma once
#include "WaylandProtocol.hpp"
#include "pointer-warp-v1.hpp"
class CPointerWarpProtocol : public IWaylandProtocol {
public:
CPointerWarpProtocol(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 destroyManager(CWpPointerWarpV1* manager);
//
std::vector<UP<CWpPointerWarpV1>> m_managers;
};
namespace PROTO {
inline UP<CPointerWarpProtocol> pointerWarp;
};

9
src/protocols/core/Seat.cpp
View File

@ -109,6 +109,8 @@ CWLPointerResource::CWLPointerResource(SP<CWlPointer> resource_, SP<CWLSeatResou
if UNLIKELY (!good())
return;
m_resource->setData(this);
m_resource->setRelease([this](CWlPointer* r) { PROTO::seat->destroyResource(this); });
m_resource->setOnDestroy([this](CWlPointer* r) { PROTO::seat->destroyResource(this); });
@ -145,6 +147,11 @@ bool CWLPointerResource::good() {
return m_resource->resource();
}
SP<CWLPointerResource> CWLPointerResource::fromResource(wl_resource* res) {
auto data = sc<CWLPointerResource*>(sc<CWlPointer*>(wl_resource_get_user_data(res))->data());
return data ? data->m_self.lock() : nullptr;
}
void CWLPointerResource::sendEnter(SP<CWLSurfaceResource> surface, const Vector2D& local) {
if (!m_owner || m_currentSurface == surface || !surface->getResource()->resource())
return;
@ -439,6 +446,8 @@ CWLSeatResource::CWLSeatResource(SP<CWlSeat> resource_) : m_resource(resource_)
return;
}
RESOURCE->m_self = RESOURCE;
m_pointers.emplace_back(RESOURCE);
});

6
src/protocols/core/Seat.hpp
View File

@ -88,15 +88,21 @@ class CWLPointerResource {
WP<CWLSeatResource> m_owner;
//
static SP<CWLPointerResource> fromResource(wl_resource* res);
private:
SP<CWlPointer> m_resource;
WP<CWLSurfaceResource> m_currentSurface;
WP<CWLPointerResource> m_self;
std::vector<uint32_t> m_pressedButtons;
struct {
CHyprSignalListener destroySurface;
} m_listeners;
friend class CWLSeatResource;
};
class CWLKeyboardResource {