animation: only store a single WP to animationmgr signals

hyprwm · Jan 26, 2025 · 9885c95 · 9885c95
1 parent 27d35e8
commit 9885c95
Show file tree

Hide file tree

Showing 4 changed files with 28 additions and 35 deletions.
diff --git a/include/hyprutils/animation/AnimatedVariable.hpp b/include/hyprutils/animation/AnimatedVariable.hpp
@@ -12,6 +12,12 @@ namespace Hyprutils {
     namespace Animation {
         class CAnimationManager;
 
+        struct SAnimVarEvents {
+            Signal::CSignal connect;
+            Signal::CSignal forceDisconnect;
+            Signal::CSignal lazyDisconnect;
+        };
+
         /* A base class for animated variables. */
         class CBaseAnimatedVariable {
           public:
@@ -94,12 +100,6 @@ namespace Hyprutils {
 
             Memory::CWeakPointer<CBaseAnimatedVariable> m_pSelf;
 
-            struct {
-                Memory::CWeakPointer<Signal::CSignal> connect;
-                Memory::CWeakPointer<Signal::CSignal> forceDisconnect;
-                Memory::CWeakPointer<Signal::CSignal> lazyDisconnect;
-            } m_sEvents;
-
           private:
             Memory::CWeakPointer<SAnimationPropertyConfig> m_pConfig;
 
@@ -109,14 +109,16 @@ namespace Hyprutils {
 
             // TODO: remove this pointer. We still need it for getBezier in getCurveValue.
             // getCurveValue is only used once in Hyprland. So either remove it or just pass pAnimationManager as a param.
-            CAnimationManager* m_pAnimationManager = nullptr;
+            CAnimationManager*                   m_pAnimationManager = nullptr;
+
+            Memory::CWeakPointer<SAnimVarEvents> m_events;
 
-            bool               m_bRemoveEndAfterRan   = true;
-            bool               m_bRemoveBeginAfterRan = true;
+            bool                                 m_bRemoveEndAfterRan   = true;
+            bool                                 m_bRemoveBeginAfterRan = true;
 
-            CallbackFun        m_fEndCallback;
-            CallbackFun        m_fBeginCallback;
-            CallbackFun        m_fUpdateCallback;
+            CallbackFun                          m_fEndCallback;
+            CallbackFun                          m_fBeginCallback;
+            CallbackFun                          m_fUpdateCallback;
         };
 
         /* This concept represents the minimum requirement for a type to be used with CGenericAnimatedVariable */

diff --git a/include/hyprutils/animation/AnimationManager.hpp b/include/hyprutils/animation/AnimationManager.hpp
@@ -51,12 +51,7 @@ namespace Hyprutils {
                 Signal::CHyprSignalListener lazyDisconnect;
             } m_sListeners;
 
-            struct {
-                // Those events are shared between animated vars
-                Memory::CSharedPointer<Signal::CSignal> connect;
-                Memory::CSharedPointer<Signal::CSignal> forceDisconnect;
-                Memory::CSharedPointer<Signal::CSignal> lazyDisconnect;
-            } m_sEvents;
+            Memory::CSharedPointer<SAnimVarEvents> m_events;
 
             friend class CBaseAnimatedVariable;
         };

diff --git a/src/animation/AnimatedVariable.cpp b/src/animation/AnimatedVariable.cpp
@@ -13,9 +13,7 @@ void CBaseAnimatedVariable::create(Hyprutils::Animation::CAnimationManager* pAni
     m_Type              = typeInfo;
     m_pSelf             = pSelf;
 
-    m_sEvents.connect         = pAnimationManager->m_sEvents.connect;
-    m_sEvents.forceDisconnect = pAnimationManager->m_sEvents.forceDisconnect;
-    m_sEvents.lazyDisconnect  = pAnimationManager->m_sEvents.lazyDisconnect;
+    m_events = pAnimationManager->m_events;
 
     m_bDummy = false;
 }
@@ -24,15 +22,15 @@ void CBaseAnimatedVariable::connectToActive() {
     if (m_bDummy || m_bIsConnectedToActive)
         return;
 
-    if (const auto CONNECT = m_sEvents.connect.lock()) {
-        CONNECT->emit(m_pSelf.lock());
+    if (const auto PEVENTS = m_events.lock()) {
+        PEVENTS->connect.emit(m_pSelf.lock());
         m_bIsConnectedToActive = true;
     }
 }
 
 void CBaseAnimatedVariable::disconnectFromActive() {
-    if (const auto DISCONNECT = m_sEvents.forceDisconnect.lock())
-        DISCONNECT->emit(static_cast<void*>(this));
+    if (const auto PEVENTS = m_events.lock())
+        PEVENTS->forceDisconnect.emit(static_cast<void*>(this));
 
     m_bIsConnectedToActive = false;
 }
@@ -85,7 +83,7 @@ float CBaseAnimatedVariable::getCurveValue() const {
 
     // Guard against m_pAnimationManager being deleted
     // TODO: Remove this and m_pAnimationManager
-    if (m_sEvents.connect.expired()) {
+    if (m_events.expired()) {
         return 1.f;
     }
 
@@ -108,7 +106,7 @@ float CBaseAnimatedVariable::getCurveValue() const {
 }
 
 bool CBaseAnimatedVariable::ok() const {
-    return m_pConfig && !m_bDummy;
+    return m_pConfig && !m_bDummy && !m_events.expired();
 }
 
 void CBaseAnimatedVariable::onUpdate() {
@@ -144,8 +142,8 @@ void CBaseAnimatedVariable::resetAllCallbacks() {
 void CBaseAnimatedVariable::onAnimationEnd() {
     m_bIsBeingAnimated = false;
     /* lazy disconnect, since this animvar is atill alive */
-    if (const auto DISCONNECT = m_sEvents.lazyDisconnect.lock())
-        DISCONNECT->emit(static_cast<void*>(this));
+    if (const auto PEVENTS = m_events.lock())
+        PEVENTS->lazyDisconnect.emit(static_cast<void*>(this));
 
     if (m_fEndCallback) {
         /* loading m_bRemoveEndAfterRan before calling the callback allows the callback to delete this animation safely if it is false. */

diff --git a/src/animation/AnimationManager.cpp b/src/animation/AnimationManager.cpp
@@ -14,13 +14,11 @@ CAnimationManager::CAnimationManager() {
     BEZIER->setup(DEFAULTBEZIERPOINTS);
     m_mBezierCurves["default"] = BEZIER;
 
-    m_sEvents.connect         = makeShared<CSignal>();
-    m_sEvents.forceDisconnect = makeShared<CSignal>();
-    m_sEvents.lazyDisconnect  = makeShared<CSignal>();
+    m_events = makeShared<SAnimVarEvents>();
 
-    m_sListeners.connect         = m_sEvents.connect->registerListener([this](std::any data) { connectListener(data); });
-    m_sListeners.forceDisconnect = m_sEvents.forceDisconnect->registerListener([this](std::any data) { forceDisconnectListener(data); });
-    m_sListeners.lazyDisconnect  = m_sEvents.lazyDisconnect->registerListener([this](std::any data) { lazyDisconnectListener(data); });
+    m_sListeners.connect         = m_events->connect.registerListener([this](std::any data) { connectListener(data); });
+    m_sListeners.forceDisconnect = m_events->forceDisconnect.registerListener([this](std::any data) { forceDisconnectListener(data); });
+    m_sListeners.lazyDisconnect  = m_events->lazyDisconnect.registerListener([this](std::any data) { lazyDisconnectListener(data); });
 }
 
 void CAnimationManager::connectListener(std::any data) {