cry/Hyprland
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

event: refactor HookSystem into a typed event bus (#13333)

Browse source 
Refactors the old HookSystem into a typed event bus with clear
separation,
discovery and types.
This commit is contained in:
Vaxry 2026-02-22 23:30:10 +00:00 • committed by GitHub
parent b4ee4674f9
commit b88813c7ef
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
58 changed files with 493 additions and 516 deletions
Download patch file Download diff file Expand all files Collapse all files

10
src/managers/ANRManager.cpp
View file

@ -3,13 +3,13 @@
#include "../helpers/fs/FsUtils.hpp"
#include "../debug/log/Logger.hpp"
#include "../macros.hpp"
#include "HookSystemManager.hpp"
#include "../Compositor.hpp"
#include "../protocols/XDGShell.hpp"
#include "./eventLoop/EventLoopManager.hpp"
#include "../config/ConfigValue.hpp"
#include "../xwayland/XSurface.hpp"
#include "../i18n/Engine.hpp"
#include "../event/EventBus.hpp"
using namespace Hyprutils::OS;
@ -26,9 +26,7 @@ CANRManager::CANRManager() {
m_active = true;
static auto P = g_pHookSystem->hookDynamic("openWindow", [this](void* self, SCallbackInfo& info, std::any data) {
auto window = std::any_cast<PHLWINDOW>(data);
static auto P = Event::bus()->m_events.window.open.listen([this](PHLWINDOW window) {
for (const auto& d : m_data) {
// Window is ANR dialog
if (d->isRunning() && d->dialogBox->getPID() == window->getPID())
@ -41,9 +39,7 @@ CANRManager::CANRManager() {
m_data.emplace_back(makeShared<SANRData>(window));
});
static auto P1 = g_pHookSystem->hookDynamic("closeWindow", [this](void* self, SCallbackInfo& info, std::any data) {
auto window = std::any_cast<PHLWINDOW>(data);
static auto P1 = Event::bus()->m_events.window.close.listen([this](PHLWINDOW window) {
for (const auto& d : m_data) {
if (!d->fitsWindow(window))
continue;

4
src/managers/CursorManager.cpp
View file

@ -3,8 +3,8 @@
#include "../config/ConfigValue.hpp"
#include "PointerManager.hpp"
#include "../xwayland/XWayland.hpp"
#include "../managers/HookSystemManager.hpp"
#include "../helpers/Monitor.hpp"
#include "../event/EventBus.hpp"
static int cursorAnimTimer(SP<CEventLoopTimer> self, void* data) {
const auto cursorMgr = sc<CCursorManager*>(data);
@ -111,7 +111,7 @@ CCursorManager::CCursorManager() {
updateTheme();
static auto P = g_pHookSystem->hookDynamic("monitorLayoutChanged", [this](void* self, SCallbackInfo& info, std::any param) { this->updateTheme(); });
static auto P = Event::bus()->m_events.monitor.layoutChanged.listen([this] { this->updateTheme(); });
}
CCursorManager::~CCursorManager() {

83
src/managers/HookSystemManager.cpp
View file

@ -1,83 +0,0 @@
#include "HookSystemManager.hpp"
#include "../plugins/PluginSystem.hpp"
CHookSystemManager::CHookSystemManager() {
; //
}
// returns the pointer to the function
SP<HOOK_CALLBACK_FN> CHookSystemManager::hookDynamic(const std::string& event, HOOK_CALLBACK_FN fn, HANDLE handle) {
SP<HOOK_CALLBACK_FN> hookFN = makeShared<HOOK_CALLBACK_FN>(fn);
m_registeredHooks[event].emplace_back(SCallbackFNPtr{.fn = hookFN, .handle = handle});
return hookFN;
}
void CHookSystemManager::unhook(SP<HOOK_CALLBACK_FN> fn) {
for (auto& [k, v] : m_registeredHooks) {
std::erase_if(v, [&](const auto& other) {
SP<HOOK_CALLBACK_FN> fn_ = other.fn.lock();
return fn_.get() == fn.get();
});
}
}
void CHookSystemManager::emit(std::vector<SCallbackFNPtr>* const callbacks, SCallbackInfo& info, std::any data) {
if (callbacks->empty())
return;
std::vector<HANDLE> faultyHandles;
volatile bool needsDeadCleanup = false;
for (auto const& cb : *callbacks) {
m_currentEventPlugin = false;
if (!cb.handle) {
// we don't guard hl hooks
if (SP<HOOK_CALLBACK_FN> fn = cb.fn.lock())
(*fn)(fn.get(), info, data);
else
needsDeadCleanup = true;
continue;
}
m_currentEventPlugin = true;
if (std::ranges::find(faultyHandles, cb.handle) != faultyHandles.end())
continue;
try {
if (!setjmp(m_hookFaultJumpBuf)) {
if (SP<HOOK_CALLBACK_FN> fn = cb.fn.lock())
(*fn)(fn.get(), info, data);
else
needsDeadCleanup = true;
} else {
// this module crashed.
throw std::exception();
}
} catch (std::exception& e) {
// TODO: this works only once...?
faultyHandles.push_back(cb.handle);
Log::logger->log(Log::ERR, "[hookSystem] Hook from plugin {:x} caused a SIGSEGV, queueing for unloading.", rc<uintptr_t>(cb.handle));
}
}
if (needsDeadCleanup)
std::erase_if(*callbacks, [](const auto& fn) { return !fn.fn.lock(); });
if (!faultyHandles.empty()) {
for (auto const& h : faultyHandles)
g_pPluginSystem->unloadPlugin(g_pPluginSystem->getPluginByHandle(h), true);
}
}
std::vector<SCallbackFNPtr>* CHookSystemManager::getVecForEvent(const std::string& event) {
if (!m_registeredHooks.contains(event))
Log::logger->log(Log::DEBUG, "[hookSystem] New hook event registered: {}", event);
return &m_registeredHooks[event];
}

60
src/managers/HookSystemManager.hpp
View file

@ -1,60 +0,0 @@
#pragma once
#include "../defines.hpp"
#include <unordered_map>
#include <any>
#include <array>
#include <list>
#include <csetjmp>
#define HANDLE void*
// global type alias for hooked functions. Passes itself as a ptr when called, and `data` additionally.
using HOOK_CALLBACK_FN = std::function<void(void*, SCallbackInfo& info, std::any data)>;
struct SCallbackFNPtr {
WP<HOOK_CALLBACK_FN> fn;
HANDLE handle = nullptr;
};
#define EMIT_HOOK_EVENT(name, param) \
{ \
static auto* const PEVENTVEC = g_pHookSystem->getVecForEvent(name); \
SCallbackInfo info; \
g_pHookSystem->emit(PEVENTVEC, info, param); \
}
#define EMIT_HOOK_EVENT_CANCELLABLE(name, param) \
{ \
static auto* const PEVENTVEC = g_pHookSystem->getVecForEvent(name); \
SCallbackInfo info; \
g_pHookSystem->emit(PEVENTVEC, info, param); \
if (info.cancelled) \
return; \
}
class CHookSystemManager {
public:
CHookSystemManager();
// returns the pointer to the function.
// losing this pointer (letting it get destroyed)
// will equal to unregistering the callback.
[[nodiscard("Losing this pointer instantly unregisters the callback")]] SP<HOOK_CALLBACK_FN> hookDynamic(const std::string& event, HOOK_CALLBACK_FN fn,
HANDLE handle = nullptr);
void unhook(SP<HOOK_CALLBACK_FN> fn);
void emit(std::vector<SCallbackFNPtr>* const callbacks, SCallbackInfo& info, std::any data = 0);
std::vector<SCallbackFNPtr>* getVecForEvent(const std::string& event);
bool m_currentEventPlugin = false;
jmp_buf m_hookFaultJumpBuf;
private:
std::unordered_map<std::string, std::vector<SCallbackFNPtr>> m_registeredHooks;
};
inline UP<CHookSystemManager> g_pHookSystem;

11
src/managers/KeybindManager.cpp
View file

@ -16,7 +16,6 @@
#include "TokenManager.hpp"
#include "eventLoop/EventLoopManager.hpp"
#include "debug/log/Logger.hpp"
#include "../managers/HookSystemManager.hpp"
#include "../managers/input/InputManager.hpp"
#include "../managers/animation/DesktopAnimationManager.hpp"
#include "../managers/EventManager.hpp"
@ -32,6 +31,7 @@
#include "../layout/algorithm/Algorithm.hpp"
#include "../layout/algorithm/tiled/master/MasterAlgorithm.hpp"
#include "../layout/algorithm/tiled/monocle/MonocleAlgorithm.hpp"
#include "../event/EventBus.hpp"
#include <optional>
#include <iterator>
@ -203,8 +203,7 @@ CKeybindManager::CKeybindManager() {
g_pEventLoopManager->addTimer(m_repeatKeyTimer);
}
static auto P = g_pHookSystem->hookDynamic("configReloaded", [this](void* hk, SCallbackInfo& info, std::any param) {
// clear cuz realloc'd
static auto P = Event::bus()->m_events.config.reloaded.listen([this] {
m_activeKeybinds.clear();
m_lastLongPressKeybind.reset();
m_pressedSpecialBinds.clear();
@ -2215,7 +2214,7 @@ SDispatchResult CKeybindManager::setSubmap(std::string submap) {
m_currentSelectedSubmap.name = "";
Log::logger->log(Log::DEBUG, "Reset active submap to the default one.");
g_pEventManager->postEvent(SHyprIPCEvent{"submap", ""});
EMIT_HOOK_EVENT("submap", m_currentSelectedSubmap.name);
Event::bus()->m_events.keybinds.submap.emit(m_currentSelectedSubmap.name);
return {};
}
@ -2224,7 +2223,7 @@ SDispatchResult CKeybindManager::setSubmap(std::string submap) {
m_currentSelectedSubmap.name = submap;
Log::logger->log(Log::DEBUG, "Changed keybind submap to {}", submap);
g_pEventManager->postEvent(SHyprIPCEvent{"submap", submap});
EMIT_HOOK_EVENT("submap", m_currentSelectedSubmap.name);
Event::bus()->m_events.keybinds.submap.emit(m_currentSelectedSubmap.name);
return {};
}
}
@ -2584,7 +2583,7 @@ SDispatchResult CKeybindManager::pinActive(std::string args) {
g_pCompositor->vectorToWindowUnified(g_pInputManager->getMouseCoordsInternal(), Desktop::View::RESERVED_EXTENTS | Desktop::View::INPUT_EXTENTS);
g_pEventManager->postEvent(SHyprIPCEvent{"pin", std::format("{:x},{}", rc<uintptr_t>(PWINDOW.get()), sc<int>(PWINDOW->m_pinned))});
EMIT_HOOK_EVENT("pin", PWINDOW);
Event::bus()->m_events.window.pin.emit(PWINDOW);
g_pHyprRenderer->damageWindow(PWINDOW, true);

16
src/managers/PointerManager.cpp
View file

@ -11,13 +11,13 @@
#include "eventLoop/EventLoopManager.hpp"
#include "../render/pass/TexPassElement.hpp"
#include "../managers/input/InputManager.hpp"
#include "../managers/HookSystemManager.hpp"
#include "../render/Renderer.hpp"
#include "../render/OpenGL.hpp"
#include "../desktop/state/FocusState.hpp"
#include "SeatManager.hpp"
#include "../helpers/time/Time.hpp"
#include "../helpers/Drm.hpp"
#include "../event/EventBus.hpp"
#include <cstring>
#include <gbm.h>
#include <cairo/cairo.h>
@ -26,21 +26,19 @@
using namespace Hyprutils::Utils;
CPointerManager::CPointerManager() {
m_hooks.monitorAdded = g_pHookSystem->hookDynamic("monitorAdded", [this](void* self, SCallbackInfo& info, std::any data) {
auto PMONITOR = std::any_cast<PHLMONITOR>(data);
m_hooks.monitorAdded = Event::bus()->m_events.monitor.added.listen([this](PHLMONITOR monitor) {
onMonitorLayoutChange();
PMONITOR->m_events.modeChanged.listenStatic([this] { g_pEventLoopManager->doLater([this]() { onMonitorLayoutChange(); }); });
PMONITOR->m_events.disconnect.listenStatic([this] { g_pEventLoopManager->doLater([this]() { onMonitorLayoutChange(); }); });
PMONITOR->m_events.destroy.listenStatic([this] {
monitor->m_events.modeChanged.listenStatic([this] { g_pEventLoopManager->doLater([this]() { onMonitorLayoutChange(); }); });
monitor->m_events.disconnect.listenStatic([this] { g_pEventLoopManager->doLater([this]() { onMonitorLayoutChange(); }); });
monitor->m_events.destroy.listenStatic([this] {
if (g_pCompositor && !g_pCompositor->m_isShuttingDown)
std::erase_if(m_monitorStates, [](const auto& other) { return other->monitor.expired(); });
});
});
m_hooks.monitorPreRender = g_pHookSystem->hookDynamic("preMonitorCommit", [this](void* self, SCallbackInfo& info, std::any data) {
auto state = stateFor(std::any_cast<PHLMONITOR>(data));
m_hooks.monitorPreRender = Event::bus()->m_events.monitor.preCommit.listen([this](PHLMONITOR monitor) {
auto state = stateFor(monitor);
if (!state)
return;

5
src/managers/PointerManager.hpp
View file

@ -7,6 +7,7 @@
#include "../desktop/view/WLSurface.hpp"
#include "../helpers/sync/SyncTimeline.hpp"
#include "../helpers/time/Time.hpp"
#include "../helpers/signal/Signal.hpp"
#include <tuple>
class CMonitor;
@ -184,8 +185,8 @@ class CPointerManager {
bool setHWCursorBuffer(SP<SMonitorPointerState> state, SP<Aquamarine::IBuffer> buf);
struct {
SP<HOOK_CALLBACK_FN> monitorAdded;
SP<HOOK_CALLBACK_FN> monitorPreRender;
CHyprSignalListener monitorAdded;
CHyprSignalListener monitorPreRender;
} m_hooks;
};

9
src/managers/ProtocolManager.cpp
View file

@ -67,9 +67,9 @@
#include "../protocols/PointerWarp.hpp"
#include "../protocols/Fifo.hpp"
#include "../protocols/CommitTiming.hpp"
#include "HookSystemManager.hpp"
#include "../helpers/Monitor.hpp"
#include "../event/EventBus.hpp"
#include "../render/Renderer.hpp"
#include "../Compositor.hpp"
#include "content-type-v1.hpp"
@ -113,9 +113,7 @@ CProtocolManager::CProtocolManager() {
static const auto PENABLECT = CConfigValue<Hyprlang::INT>("render:commit_timing_enabled");
// Outputs are a bit dumb, we have to agree.
static auto P = g_pHookSystem->hookDynamic("monitorAdded", [this](void* self, SCallbackInfo& info, std::any param) {
auto M = std::any_cast<PHLMONITOR>(param);
static auto P = Event::bus()->m_events.monitor.added.listen([this](PHLMONITOR M) {
// ignore mirrored outputs. I don't think this will ever be hit as mirrors are applied after
// this event is emitted iirc.
// also ignore the fallback
@ -132,8 +130,7 @@ CProtocolManager::CProtocolManager() {
m_modeChangeListeners[M->m_name] = M->m_events.modeChanged.listen([this, M] { onMonitorModeChange(M); });
});
static auto P2 = g_pHookSystem->hookDynamic("monitorRemoved", [this](void* self, SCallbackInfo& info, std::any param) {
auto M = std::any_cast<PHLMONITOR>(param);
static auto P2 = Event::bus()->m_events.monitor.removed.listen([this](PHLMONITOR M) {
if (!PROTO::outputs.contains(M->m_name))
return;
PROTO::outputs.at(M->m_name)->remove();

1
src/managers/SeatManager.cpp
View file

@ -11,7 +11,6 @@
#include "../devices/IKeyboard.hpp"
#include "../desktop/view/LayerSurface.hpp"
#include "../managers/input/InputManager.hpp"
#include "../managers/HookSystemManager.hpp"
#include "wlr-layer-shell-unstable-v1.hpp"
#include <algorithm>
#include <hyprutils/utils/ScopeGuard.hpp>

6
src/managers/animation/AnimationManager.cpp
View file

@ -1,6 +1,5 @@
#include "AnimationManager.hpp"
#include "../../Compositor.hpp"
#include "../HookSystemManager.hpp"
#include "../../config/ConfigManager.hpp"
#include "../../desktop/DesktopTypes.hpp"
#include "../../helpers/AnimatedVariable.hpp"
@ -11,6 +10,7 @@
#include "../eventLoop/EventLoopManager.hpp"
#include "../../helpers/varlist/VarList.hpp"
#include "../../render/Renderer.hpp"
#include "../../event/EventBus.hpp"
#include <hyprgraphics/color/Color.hpp>
#include <hyprutils/animation/AnimatedVariable.hpp>
@ -252,7 +252,7 @@ void CHyprAnimationManager::frameTick() {
if (!shouldTickForNext())
return;
if UNLIKELY (!g_pCompositor->m_sessionActive || !g_pHookSystem || g_pCompositor->m_unsafeState ||
if UNLIKELY (!g_pCompositor->m_sessionActive || g_pCompositor->m_unsafeState ||
!std::ranges::any_of(g_pCompositor->m_monitors, [](const auto& mon) { return mon->m_enabled && mon->m_output; }))
return;
@ -261,7 +261,7 @@ void CHyprAnimationManager::frameTick() {
m_lastTickValid = true;
tick();
EMIT_HOOK_EVENT("tick", nullptr);
Event::bus()->m_events.tick.emit();
}
if (shouldTickForNext())

69
src/managers/input/InputManager.cpp
View file

@ -35,7 +35,6 @@
#include "../../managers/SeatManager.hpp"
#include "../../managers/KeybindManager.hpp"
#include "../../render/Renderer.hpp"
#include "../../managers/HookSystemManager.hpp"
#include "../../managers/EventManager.hpp"
#include "../../managers/permissions/DynamicPermissionManager.hpp"
@ -44,6 +43,8 @@
#include "../../layout/LayoutManager.hpp"
#include "../../event/EventBus.hpp"
#include "trackpad/TrackpadGestures.hpp"
#include "../cursor/CursorShapeOverrideController.hpp"
@ -233,7 +234,10 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus, bool mouse, st
PHLLS pFoundLayerSurface;
const auto FOCUS_REASON = refocus ? Desktop::FOCUS_REASON_CLICK : Desktop::FOCUS_REASON_FFM;
EMIT_HOOK_EVENT_CANCELLABLE("mouseMove", MOUSECOORDSFLOORED);
Event::SCallbackInfo info;
Event::bus()->m_events.input.mouse.move.emit(MOUSECOORDSFLOORED, info);
if (info.cancelled)
return;
m_lastCursorPosFloored = MOUSECOORDSFLOORED;
@ -644,7 +648,10 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus, bool mouse, st
}
void CInputManager::onMouseButton(IPointer::SButtonEvent e) {
EMIT_HOOK_EVENT_CANCELLABLE("mouseButton", e);
Event::SCallbackInfo info;
Event::bus()->m_events.input.mouse.button.emit(e, info);
if (info.cancelled)
return;
if (e.mouse)
recheckMouseWarpOnMouseInput();
@ -866,8 +873,10 @@ void CInputManager::onMouseWheel(IPointer::SAxisEvent e, SP<IPointer> pointer) {
if (pointer && pointer->m_scrollFactor.has_value())
factor = *pointer->m_scrollFactor;
const auto EMAP = std::unordered_map<std::string, std::any>{{"event", e}};
EMIT_HOOK_EVENT_CANCELLABLE("mouseAxis", EMAP);
Event::SCallbackInfo info;
Event::bus()->m_events.input.mouse.axis.emit(e, info);
if (info.cancelled)
return;
if (e.mouse)
recheckMouseWarpOnMouseInput();
@ -1056,7 +1065,7 @@ void CInputManager::setupKeyboard(SP<IKeyboard> keeb) {
}
g_pEventManager->postEvent(SHyprIPCEvent{"activelayout", PKEEB->m_hlName + "," + LAYOUT});
EMIT_HOOK_EVENT("activeLayout", (std::vector<std::any>{PKEEB, LAYOUT}));
Event::bus()->m_events.input.keyboard.layout.emit(PKEEB, LAYOUT);
});
disableAllKeyboards(false);
@ -1153,7 +1162,7 @@ void CInputManager::applyConfigToKeyboard(SP<IKeyboard> pKeyboard) {
const auto LAYOUTSTR = pKeyboard->getActiveLayout();
g_pEventManager->postEvent(SHyprIPCEvent{"activelayout", pKeyboard->m_hlName + "," + LAYOUTSTR});
EMIT_HOOK_EVENT("activeLayout", (std::vector<std::any>{pKeyboard, LAYOUTSTR}));
Event::bus()->m_events.input.keyboard.layout.emit(pKeyboard, LAYOUTSTR);
Log::logger->log(Log::DEBUG, "Set the keyboard layout to {} and variant to {} for keyboard \"{}\"", pKeyboard->m_currentRules.layout, pKeyboard->m_currentRules.variant,
pKeyboard->m_hlName);
@ -1475,14 +1484,16 @@ void CInputManager::onKeyboardKey(const IKeyboard::SKeyEvent& event, SP<IKeyboar
if (!pKeyboard->m_enabled || !pKeyboard->m_allowed)
return;
const bool DISALLOWACTION = pKeyboard->isVirtual() && shouldIgnoreVirtualKeyboard(pKeyboard);
const bool DISALLOWACTION = pKeyboard->isVirtual() && shouldIgnoreVirtualKeyboard(pKeyboard);
const auto IME = m_relay.m_inputMethod.lock();
const bool HASIME = IME && IME->hasGrab();
const bool USEIME = HASIME && !DISALLOWACTION;
const auto IME = m_relay.m_inputMethod.lock();
const bool HASIME = IME && IME->hasGrab();
const bool USEIME = HASIME && !DISALLOWACTION;
const auto EMAP = std::unordered_map<std::string, std::any>{{"keyboard", pKeyboard}, {"event", event}};
EMIT_HOOK_EVENT_CANCELLABLE("keyPress", EMAP);
Event::SCallbackInfo info;
Event::bus()->m_events.input.keyboard.key.emit(event, info);
if (info.cancelled)
return;
bool passEvent = DISALLOWACTION;
@ -1571,7 +1582,7 @@ void CInputManager::onKeyboardMod(SP<IKeyboard> pKeyboard) {
Log::logger->log(Log::DEBUG, "LAYOUT CHANGED TO {} GROUP {}", LAYOUT, MODS.group);
g_pEventManager->postEvent(SHyprIPCEvent{"activelayout", pKeyboard->m_hlName + "," + LAYOUT});
EMIT_HOOK_EVENT("activeLayout", (std::vector<std::any>{pKeyboard, LAYOUT}));
Event::bus()->m_events.input.keyboard.layout.emit(pKeyboard, LAYOUT);
}
}
@ -2039,7 +2050,10 @@ void CInputManager::recheckMouseWarpOnMouseInput() {
}
void CInputManager::onSwipeBegin(IPointer::SSwipeBeginEvent e) {
EMIT_HOOK_EVENT_CANCELLABLE("swipeBegin", e);
Event::SCallbackInfo info;
Event::bus()->m_events.gesture.swipe.begin.emit(e, info);
if (info.cancelled)
return;
g_pTrackpadGestures->gestureBegin(e);
@ -2047,7 +2061,10 @@ void CInputManager::onSwipeBegin(IPointer::SSwipeBeginEvent e) {
}
void CInputManager::onSwipeUpdate(IPointer::SSwipeUpdateEvent e) {
EMIT_HOOK_EVENT_CANCELLABLE("swipeUpdate", e);
Event::SCallbackInfo info;
Event::bus()->m_events.gesture.swipe.update.emit(e, info);
if (info.cancelled)
return;
g_pTrackpadGestures->gestureUpdate(e);
@ -2055,7 +2072,10 @@ void CInputManager::onSwipeUpdate(IPointer::SSwipeUpdateEvent e) {
}
void CInputManager::onSwipeEnd(IPointer::SSwipeEndEvent e) {
EMIT_HOOK_EVENT_CANCELLABLE("swipeEnd", e);
Event::SCallbackInfo info;
Event::bus()->m_events.gesture.swipe.end.emit(e, info);
if (info.cancelled)
return;
g_pTrackpadGestures->gestureEnd(e);
@ -2063,7 +2083,10 @@ void CInputManager::onSwipeEnd(IPointer::SSwipeEndEvent e) {
}
void CInputManager::onPinchBegin(IPointer::SPinchBeginEvent e) {
EMIT_HOOK_EVENT_CANCELLABLE("pinchBegin", e);
Event::SCallbackInfo info;
Event::bus()->m_events.gesture.pinch.begin.emit(e, info);
if (info.cancelled)
return;
g_pTrackpadGestures->gestureBegin(e);
@ -2071,7 +2094,10 @@ void CInputManager::onPinchBegin(IPointer::SPinchBeginEvent e) {
}
void CInputManager::onPinchUpdate(IPointer::SPinchUpdateEvent e) {
EMIT_HOOK_EVENT_CANCELLABLE("pinchUpdate", e);
Event::SCallbackInfo info;
Event::bus()->m_events.gesture.pinch.update.emit(e, info);
if (info.cancelled)
return;
g_pTrackpadGestures->gestureUpdate(e);
@ -2079,7 +2105,10 @@ void CInputManager::onPinchUpdate(IPointer::SPinchUpdateEvent e) {
}
void CInputManager::onPinchEnd(IPointer::SPinchEndEvent e) {
EMIT_HOOK_EVENT_CANCELLABLE("pinchEnd", e);
Event::SCallbackInfo info;
Event::bus()->m_events.gesture.pinch.end.emit(e, info);
if (info.cancelled)
return;
g_pTrackpadGestures->gestureEnd(e);

5
src/managers/input/InputMethodRelay.cpp
View file

@ -1,14 +1,13 @@
#include "InputMethodRelay.hpp"
#include "../../desktop/state/FocusState.hpp"
#include "../../event/EventBus.hpp"
#include "../../protocols/TextInputV3.hpp"
#include "../../protocols/TextInputV1.hpp"
#include "../../protocols/InputMethodV2.hpp"
#include "../../protocols/core/Compositor.hpp"
#include "../../managers/HookSystemManager.hpp"
CInputMethodRelay::CInputMethodRelay() {
static auto P =
g_pHookSystem->hookDynamic("keyboardFocus", [&](void* self, SCallbackInfo& info, std::any param) { onKeyboardFocus(std::any_cast<SP<CWLSurfaceResource>>(param)); });
static auto P = Event::bus()->m_events.input.keyboard.focus.listen([&](SP<CWLSurfaceResource> surf) { onKeyboardFocus(surf); });
m_listeners.newTIV3 = PROTO::textInputV3->m_events.newTextInput.listen([this](const auto& input) { onNewTextInput(input); });
m_listeners.newTIV1 = PROTO::textInputV1->m_events.newTextInput.listen([this](const auto& input) { onNewTextInput(input); });

22
src/managers/input/Tablets.cpp
View file

@ -2,11 +2,11 @@
#include "../../desktop/view/Window.hpp"
#include "../../protocols/Tablet.hpp"
#include "../../devices/Tablet.hpp"
#include "../../managers/HookSystemManager.hpp"
#include "../../managers/PointerManager.hpp"
#include "../../managers/SeatManager.hpp"
#include "../../protocols/PointerConstraints.hpp"
#include "../../protocols/core/DataDevice.hpp"
#include "../../event/EventBus.hpp"
static void unfocusTool(SP<CTabletTool> tool) {
if (!tool->getSurface())
@ -107,6 +107,11 @@ static Vector2D transformToActiveRegion(const Vector2D pos, const CBox activeAre
}
void CInputManager::onTabletAxis(CTablet::SAxisEvent e) {
Event::SCallbackInfo info;
Event::bus()->m_events.input.tablet.axis.emit(e, info);
if (info.cancelled)
return;
const auto PTAB = e.tablet;
const auto PTOOL = ensureTabletToolPresent(e.tool);
@ -171,7 +176,10 @@ void CInputManager::onTabletAxis(CTablet::SAxisEvent e) {
}
void CInputManager::onTabletTip(CTablet::STipEvent e) {
EMIT_HOOK_EVENT_CANCELLABLE("tabletTip", e);
Event::SCallbackInfo info;
Event::bus()->m_events.input.tablet.tip.emit(e, info);
if (info.cancelled)
return;
const auto PTAB = e.tablet;
const auto PTOOL = ensureTabletToolPresent(e.tool);
@ -196,6 +204,11 @@ void CInputManager::onTabletTip(CTablet::STipEvent e) {
}
void CInputManager::onTabletButton(CTablet::SButtonEvent e) {
Event::SCallbackInfo info;
Event::bus()->m_events.input.tablet.button.emit(e, info);
if (info.cancelled)
return;
const auto PTOOL = ensureTabletToolPresent(e.tool);
if (e.down)
@ -210,6 +223,11 @@ void CInputManager::onTabletButton(CTablet::SButtonEvent e) {
}
void CInputManager::onTabletProximity(CTablet::SProximityEvent e) {
Event::SCallbackInfo info;
Event::bus()->m_events.input.tablet.proximity.emit(e, info);
if (info.cancelled)
return;
const auto PTAB = e.tablet;
const auto PTOOL = ensureTabletToolPresent(e.tool);

26
src/managers/input/Touch.cpp
View file

@ -7,8 +7,8 @@
#include "../../config/ConfigValue.hpp"
#include "../../helpers/Monitor.hpp"
#include "../../devices/ITouch.hpp"
#include "../../event/EventBus.hpp"
#include "../SeatManager.hpp"
#include "../HookSystemManager.hpp"
#include "debug/log/Logger.hpp"
#include "UnifiedWorkspaceSwipeGesture.hpp"
@ -19,10 +19,14 @@ void CInputManager::onTouchDown(ITouch::SDownEvent e) {
static auto PGAPSOUTDATA = CConfigValue<Hyprlang::CUSTOMTYPE>("general:gaps_out");
auto* const PGAPSOUT = sc<CCssGapData*>((PGAPSOUTDATA.ptr())->getData());
// TODO: WORKSPACERULE.gapsOut.value_or()
auto gapsOut = *PGAPSOUT;
static auto PBORDERSIZE = CConfigValue<Hyprlang::INT>("general:border_size");
static auto PSWIPEINVR = CConfigValue<Hyprlang::INT>("gestures:workspace_swipe_touch_invert");
EMIT_HOOK_EVENT_CANCELLABLE("touchDown", e);
auto gapsOut = *PGAPSOUT;
static auto PBORDERSIZE = CConfigValue<Hyprlang::INT>("general:border_size");
static auto PSWIPEINVR = CConfigValue<Hyprlang::INT>("gestures:workspace_swipe_touch_invert");
Event::SCallbackInfo info;
Event::bus()->m_events.input.touch.down.emit(e, info);
if (info.cancelled)
return;
auto PMONITOR = g_pCompositor->getMonitorFromName(!e.device->m_boundOutput.empty() ? e.device->m_boundOutput : "");
@ -109,7 +113,11 @@ void CInputManager::onTouchDown(ITouch::SDownEvent e) {
void CInputManager::onTouchUp(ITouch::SUpEvent e) {
m_lastInputTouch = true;
EMIT_HOOK_EVENT_CANCELLABLE("touchUp", e);
Event::SCallbackInfo info;
Event::bus()->m_events.input.touch.up.emit(e, info);
if (info.cancelled)
return;
if (g_pUnifiedWorkspaceSwipe->isGestureInProgress()) {
// If there was a swipe from this finger, end it.
if (e.touchID == g_pUnifiedWorkspaceSwipe->m_touchID)
@ -126,7 +134,11 @@ void CInputManager::onTouchMove(ITouch::SMotionEvent e) {
m_lastCursorMovement.reset();
EMIT_HOOK_EVENT_CANCELLABLE("touchMove", e);
Event::SCallbackInfo info;
Event::bus()->m_events.input.touch.motion.emit(e, info);
if (info.cancelled)
return;
if (g_pUnifiedWorkspaceSwipe->isGestureInProgress()) {
// Do nothing if this is using a different finger.
if (e.touchID != g_pUnifiedWorkspaceSwipe->m_touchID)

10
src/managers/screenshare/ScreenshareSession.cpp
View file

@ -2,9 +2,9 @@
#include "../../render/OpenGL.hpp"
#include "../../Compositor.hpp"
#include "../../render/Renderer.hpp"
#include "../HookSystemManager.hpp"
#include "../EventManager.hpp"
#include "../eventLoop/EventLoopManager.hpp"
#include "../../event/EventBus.hpp"
using namespace Screenshare;
@ -119,18 +119,18 @@ void CScreenshareSession::calculateConstraints() {
void CScreenshareSession::screenshareEvents(bool startSharing) {
if (startSharing && !m_sharing) {
m_sharing = true;
EMIT_HOOK_EVENT("screencast", (std::vector<std::any>{1, m_type}));
g_pEventManager->postEvent(SHyprIPCEvent{.event = "screencast", .data = std::format("1,{}", m_type)});
EMIT_HOOK_EVENT("screencastv2", (std::vector<std::any>{1, m_type, m_name}));
g_pEventManager->postEvent(SHyprIPCEvent{.event = "screencastv2", .data = std::format("1,{},{}", m_type, m_name)});
LOGM(Log::INFO, "New screenshare session for ({}): {}", m_type, m_name);
Event::bus()->m_events.screenshare.state.emit(true, m_type, m_name);
} else if (!startSharing && m_sharing) {
m_sharing = false;
EMIT_HOOK_EVENT("screencast", (std::vector<std::any>{0, m_type}));
g_pEventManager->postEvent(SHyprIPCEvent{.event = "screencast", .data = std::format("0,{}", m_type)});
EMIT_HOOK_EVENT("screencastv2", (std::vector<std::any>{0, m_type, m_name}));
g_pEventManager->postEvent(SHyprIPCEvent{.event = "screencastv2", .data = std::format("0,{},{}", m_type, m_name)});
LOGM(Log::INFO, "Stopped screenshare session for ({}): {}", m_type, m_name);
Event::bus()->m_events.screenshare.state.emit(false, m_type, m_name);
}
}