From 78812df43633092962f09bb96aca1b7e96eddc21 Mon Sep 17 00:00:00 2001
From: "instance.id" <dan@instance.id>
Date: Fri, 30 Jul 2021 19:46:52 -0500
Subject: [PATCH] Fixed some bugs that could occur in some situations

---
 Editor/EATKEditor.cs                          |   2 +-
 ...ance.elementanimationtoolkit.Editor.asmdef |   4 +-
 README.md                                     |  98 +++++++++++--
 Runtime/Animations/AnimationExtensions.cs     |   4 +-
 Runtime/Animations/AnimationSequences.cs      |  43 +++++-
 Runtime/Animations/ContinuousAnimations.cs    |  35 +++--
 Runtime/Animations/HoverAnimations.cs         | 135 +++++++++++-------
 .../Animations/VisualElementBaseAnimation.cs  |  61 +++++++-
 .../AnimatedFoldout/AnimatedFoldout.cs        |  26 +++-
 .../AnimatedFoldout/UIElementExpander.cs      |  10 +-
 .../Extensions/DataTypes/AnimatedItems.cs     |  10 ++
 .../Extensions/VisualElementExtension.cs      |  35 ++++-
 Runtime/Util/ColorUtil.cs                     |   2 +-
 ...id.instance.elementanimationtoolkit.asmdef |   5 +-
 14 files changed, 362 insertions(+), 108 deletions(-)

diff --git a/Editor/EATKEditor.cs b/Editor/EATKEditor.cs
index 4a9f454..d216b12 100644
--- a/Editor/EATKEditor.cs
+++ b/Editor/EATKEditor.cs
@@ -834,7 +834,7 @@ void ButtonCascade()
                 buttonContainerDictionary.ForEach(x =>
                 {
                     // -- Then query for each button within the row ------
-                    // -- Set default button cascase delay and counters --
+                    // -- Set default button cascade delay and counters --
                     var buttons = x.Value.Query<Button>().ToList();
                     var buttonCascade = 100;
                     var buttonCount = buttons.Count;
diff --git a/Editor/id.instance.elementanimationtoolkit.Editor.asmdef b/Editor/id.instance.elementanimationtoolkit.Editor.asmdef
index 5e2e47c..5a2b508 100644
--- a/Editor/id.instance.elementanimationtoolkit.Editor.asmdef
+++ b/Editor/id.instance.elementanimationtoolkit.Editor.asmdef
@@ -2,9 +2,7 @@
     "name": "id.instance.elementanimationtoolkit.Editor",
     "rootNamespace": "",
     "references": [
-        "id.instance.elementanimationtoolkit",
-        "id.instance.extensions",
-        "id.instance.extensions.Editor"
+        "id.instance.elementanimationtoolkit"
     ],
     "includePlatforms": [
         "Editor"
diff --git a/README.md b/README.md
index dc429ff..fc39d23 100644
--- a/README.md
+++ b/README.md
@@ -1,29 +1,99 @@
 
 # ElementAnimationToolkit
 
-### A collection of Unity UIElements animation extension methods, new animated elements, and examples.
+### A collection of Unity UIToolkit/UIElements chainable animation extension methods, premade animated elements, and examples. <!-- omit in toc -->
 ![](Documentation/media/intro_animation.gif)
 
+<br>
+
+- [ElementAnimationToolkit](#elementanimationtoolkit)
+    - [Recent Features or Changes](#recent-features-or-changes)
+  - [Documentation](#documentation)
+    - [Installation](#installation)
+      - [Install via OpenUPM](#install-via-openupm)
+      - [Unity Package Manager](#unity-package-manager)
+    - [Animations and Features](#animations-and-features)
+    - [Usage / Examples:](#usage--examples)
+      - [Background Color Fade-In](#background-color-fade-in)
+      - [Hover Border Pulse](#hover-border-pulse)
+      - [Fade-in sequence](#fade-in-sequence)
+
+<br>
+
+### Recent Features or Changes
+| New Animation types: |                       |
+| -------------------- | --------------------- |
+| Sequences            |                       |
+|                      | ShowForDuration       |
+| Base Annimations     |                       |
+|                      | AnimateOpacityDelayed |
+
 ## [Documentation]("https://docs.instance.id/elementanimationtoolkit/")
 
-### Note: UIElements Animations are listed as Experimental by Unity - API subject to change. Also, since Element Animation Toolkit is currently underactive development, it is possible for API changes in this library as well
+---
+
+### Note: UIElements Animations are listed as Experimental by Unity - API subject to change. Also, since Element Animation Toolkit is currently underactive development, it is possible for API changes in this library as well <!-- omit in toc -->
+
+<br>
 
-#### The intent of this package is to help asset developers more easily create their own animation sequences via code.
+#### The intent of this package is to help asset developers more easily create their own animation sequences via code.<!-- omit in toc -->
 Though, I have been adding some new "ready to go" UIElement types, such as the "AnimatedFoldout", which you just use as you would a a typical foldout comes animated with no additional coding, minus some exposed properties to adjust the animation to your liking. I do intend to add more of these as I go along.
 
+<br>
+
 This package began simply as a small collection of helpers methods I created across my last few projects to make animating editor elements much easier and finally put into a single place. I continue to add to it as I go along but decided to put together several examples and wanted to share them.
 
-### [Install via OpenUPM](https://openupm.com/packages/id.instance.elementanimationtoolkit)
+<br>
+
+### Installation
+
+---
+
+#### [Install via OpenUPM](https://openupm.com/packages/id.instance.elementanimationtoolkit)
 ```openupm add id.instance.elementanimationtoolkit```
 
-### [Unity Package Manager](https://github.com/instance-id/ElementAnimationToolkit/tree/upm)
+#### [Unity Package Manager](https://github.com/instance-id/ElementAnimationToolkit/tree/upm)
 ```github.com/instance-id/elementanimationtoolkit.git#upm```
 
-### Usage:
+<br>
+
+### Animations and Features
+
+---
+| Animation types:   | Method                 |
+| ------------------ | ---------------------- |
+| Sequences:         |                        |
+|                    | AnimCharacterSequence  |
+|                    | AnimFadeInSequence     |
+|                    | ShowForDuration        |
+| Continuous:        |                        |
+|                    | AnimBorderPulse        |
+| Hover:             |                        |
+|                    | HoverBorderPulse       |
+| Base Annimations:  |                        |
+|                    | AnimateBackgroundColor |
+|                    | AnimateBorderColor     |
+|                    | AnimateColor           |
+|                    | AnimateImageTintColor  |
+|                    | AnimateOpacity         |
+|                    | AnimateOpacityDelayed  |
+|                    | AnimateWidth           |
+|                    | AnimateHeight          |
+| Extensions/Helpers |                        |
+|                    | AutoToggleAfter        |
+|                    | ApplyPrivacyMask       |
+|                    | SetDisplay             |
+|                    | GetDisplay             |
+|                    | SetOpacity             |
+|                    | GetDisplay             |
+|                    | SetText                |
+|                    | OpenURL                |
+
+### Usage / Examples:
 
 Examples: Tools > instance.id > Element Animation Toolkit
 
-Note: The code is pretty ~~heavily~~ excessively documented and currently most method summaries for extension methods have examples in them. Be sure to check the comments for additional details!  
+Note: The code is pretty ~~heavily~~ excessively documented and currently most method summaries for extension methods have examples in them. Be sure to check the comments for additional details!
 
 ![](https://i.imgur.com/hY3DGDA.png)
 
@@ -48,8 +118,8 @@ Note: The code is pretty ~~heavily~~ excessively documented and currently most m
 
 There are several fairly basic base animation helper methods which can easily be used on their own, but are also the basis of the more complex animation sequences:
 
-### Background Color Fade-In
-![](Documentation/media/background_fade_example.gif)  
+#### Background Color Fade-In
+![](Documentation/media/background_fade_example.gif)
 (The initial fade from gray to blue)
 
 <details>
@@ -71,7 +141,7 @@ visualElement.AnimateBackgroundColor(originalColor, fadeColor, durationOfFade);
 
 ---
 
-### Hover Border Pulse
+#### Hover Border Pulse
 ![](Documentation/media/hoverborderpulse_example.gif)
 <details>
 <summary>Example hover animation: HoverBorderPulse()</summary>
@@ -87,7 +157,7 @@ visualElement.HoverBorderPulse(pulseStartColor: GetColor.FromHex("#7F3B3A"), pul
 
 ---
 
-### Fade-in sequence
+#### Fade-in sequence
 ![](Documentation/media/fade_example.gif)
 
 <details>
@@ -118,7 +188,7 @@ Additionally there are many helper methods relating to many different Types from
 <summary>Example color helper method: GetColor.FromHex()</summary>
 
 Usage:
-```cs 
+```cs
 Color color = GetColor.FromHex("#CCCCCC");
 ```
 
@@ -139,7 +209,7 @@ public static Color FromHex(this string color)
 <summary>Example creating an external url link : OpenURL() </summary>
 
 Usage:
-```cs 
+```cs
 VisualElement visualElement = new VisualElement();
 visualElement.OpenURL("https://github.com/instance-id/ElementAnimationToolkit");
 ```
@@ -184,7 +254,7 @@ Lastly is the USS button, which takes you to the USS stylesheet and the location
 
 The animations without a row of buttons have a right-click context menu implemented which has similar options to jump directly into
 the code at the proper location for the animation. (The methods I have created for jumping straight to the proper lines of code
-are of course included and you are welcome to take advantage of them for your own needs.)  
+are of course included and you are welcome to take advantage of them for your own needs.)
 ![](Documentation/media/jumptomenu.png)
 
 
diff --git a/Runtime/Animations/AnimationExtensions.cs b/Runtime/Animations/AnimationExtensions.cs
index 1ff1d11..6de6cd7 100644
--- a/Runtime/Animations/AnimationExtensions.cs
+++ b/Runtime/Animations/AnimationExtensions.cs
@@ -42,7 +42,7 @@ public static void ExecuteIn(this Action action, VisualElement element, long del
         /// <param name="includeChildren">Register child elements in addition to the target element</param>
         /// <typeparam name="TEventType">The event callback type in which to register</typeparam>
         /// <returns>The target element</returns>
-        public static VisualElement RegisterCallback<TEventType>(this VisualElement element, EventCallback<TEventType> callback, bool includeChildren)
+        public static VisualElement RegisterCallback<TEventType>(this VisualElement element, EventCallback<TEventType> callback, bool includeChildren, TrickleDown useTrickleDown = TrickleDown.NoTrickleDown)
             where TEventType : EventBase<TEventType>, new()
         {
             element.RegisterCallback(callback);
@@ -60,7 +60,7 @@ public static VisualElement RegisterCallback<TEventType>(this VisualElement elem
         /// <param name="includeChildren">Register child elements in addition to the target element</param>
         /// <typeparam name="TEventType">The event callback type in which to register</typeparam>
         /// <returns>The target element</returns>
-        public static void UnregisterCallback<TEventType>(this VisualElement element, EventCallback<TEventType> callback, bool includeChildren)
+        public static void UnregisterCallback<TEventType>(this VisualElement element, EventCallback<TEventType> callback, bool includeChildren, TrickleDown useTrickleDown = TrickleDown.NoTrickleDown)
             where TEventType : EventBase<TEventType>, new()
         {
             element.UnregisterCallback(callback);
diff --git a/Runtime/Animations/AnimationSequences.cs b/Runtime/Animations/AnimationSequences.cs
index d808733..3d031f2 100644
--- a/Runtime/Animations/AnimationSequences.cs
+++ b/Runtime/Animations/AnimationSequences.cs
@@ -1,4 +1,4 @@
-// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // -- Project : https://github.com/instance-id/ElementAnimationToolkit       --
 // -- instance.id 2020 | http://github.com/instance-id | http://instance.id  --
 // ----------------------------------------------------------------------------
@@ -7,13 +7,10 @@
 
 #if UNITY_EDITOR
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using instance.id.EATK.Extensions;
-// using instance.id.Extensions;
-// using instance.id.Extensions;
 using UnityEngine;
 using UnityEngine.UIElements;
+using System.Collections.Generic;
+using instance.id.EATK.Extensions;
 using UnityEngine.UIElements.Experimental;
 
 namespace instance.id.EATK
@@ -263,6 +260,40 @@ private static ValueAnimation<StyleValues> DoFadeOut(VisualElement elementToFade
         }
 
         #endregion
+
+        // ----------------------------------------------- ShowForDuration
+        // --| ShowForDuration -------------------------------------------
+
+        #region ShowForDuration
+
+        /// <summary>
+        /// Show a hidden VisualElement by fading it's opacity for a specified duration and then hide it again when duration completes
+        /// </summary>
+        /// <param name="element">The element in which to display</param>
+        /// <param name="fadeDurationMs">The amount of time in milliseconds it should take to fade from one opacity extent to the other</param>
+        /// <param name="displayDurationMs">The amount of time in milliseconds to display the element before fading opacity back to 0</param>
+        /// <param name="callback">A callback to be executed upon completion of the animation sequence</param>
+        /// <param name="easing">The easing transition type to use for the animated values</param>
+        /// <returns>A list containing the ValueAnimation objects for each phase of the animation sequence</returns>
+        /// <remarks>Upon completion of the animation, the elements DisplayStyle will be set back to it's original value</remarks>
+        public static List<ValueAnimation<StyleValues>> ShowForDuration(this VisualElement element, int fadeDurationMs, int displayDurationMs, Action callback = null, Func<float, float> easing = null)
+        {
+            bool isDisplayed; // @formatter:off
+            List<ValueAnimation<StyleValues>> anims = new List<ValueAnimation<StyleValues>>(); 
+            if ((isDisplayed = element.GetDisplay()) == false) element.SetDisplay(true);
+            
+            anims.Add(element.SetOpacity(0.Zero()).AnimateOpacity(0.Zero(), 1, fadeDurationMs, () =>
+            {
+                anims.Add(element.AnimateOpacityDelayed(1, 0.Zero(), 500, displayDurationMs, () =>
+                {
+                   if (!isDisplayed) element.SetDisplay(false);
+                }));
+            }));
+            
+            return anims;
+        } // @formatter:on
+
+        #endregion
     }
 }
 #endif
diff --git a/Runtime/Animations/ContinuousAnimations.cs b/Runtime/Animations/ContinuousAnimations.cs
index cf879f0..2817bb6 100644
--- a/Runtime/Animations/ContinuousAnimations.cs
+++ b/Runtime/Animations/ContinuousAnimations.cs
@@ -2,6 +2,7 @@
 // -- Project : https://github.com/instance-id/ElementAnimationToolkit       --
 // -- instance.id 2020 | http://github.com/instance-id | http://instance.id  --
 // ----------------------------------------------------------------------------
+
 #if UNITY_EDITOR
 using System;
 using instance.id.EATK.Extensions;
@@ -36,12 +37,14 @@ public static class ContinuousAnimations
         /// <param name="borderSelection">The parameters of the Vector4(1-4) represent which borders should have their colors changed: 1(x) = left, 2(y) = top, 3(z) = right, 4(w) = bottom.
         /// If only the top and bottom borders are desired to pulse, you would pass new Vector4(0, 1, 0, 1)</param>
         public static IVisualElementScheduledItem AnimBorderPulse(this VisualElement element, Color color1, Color color2, Color original = default,
-            int color1DurationMs = 1000,
-            int color2DurationMs = 1000,
-            bool addBorder = false,
-            Vector2 borderStartEndWidth = default,
-            Action callback = null,
-            Vector4 borderSelection = default)
+        int color1DurationMs = 1000,
+        int color2DurationMs = 1000,
+        bool addBorder = false,
+        Vector2 borderStartEndWidth = default,
+        Action callback = null,
+        Vector4 borderSelection = default,
+        IVisualElementScheduledItem repeatedAnim = default
+        )
         {
             if (borderStartEndWidth == default)
                 borderStartEndWidth = new Vector2(1, 0);
@@ -49,7 +52,10 @@ public static IVisualElementScheduledItem AnimBorderPulse(this VisualElement ele
             bool doBorderPulse;
             var pulseIn = new ValueAnimation<StyleValues>();
             var pulseOut = new ValueAnimation<StyleValues>();
-            IVisualElementScheduledItem repeatedAnim = null;
+            pulseIn.autoRecycle = true;
+            pulseOut.autoRecycle = true;
+            pulseIn.KeepAlive();
+            pulseOut.KeepAlive();
 
             doBorderPulse = true;
             if (addBorder) element.SetBorderWidth(borderStartEndWidth.x);
@@ -131,12 +137,13 @@ void DoCleanup()
             {
                 if (pulseOut.isRunning) pulseOut.Stop();
                 if (pulseIn.isRunning) pulseIn.Stop();
+
                 element.SetBorderColor();
-                callback?.Invoke();
                 if (addBorder) element.SetBorderWidth(borderStartEndWidth.y);
                 if (borderSelection != default) ReplaceBorderValues();
+                callback?.Invoke();
             } // @formatter:off
-
+            
             // -- Pulse color will fade original => desired color   --
             // -- via the AnimateTo local function. Once completed  --
             // -- the AnimateFrom function is called animating back --
@@ -146,31 +153,31 @@ void PulseIn(IVisualElementScheduledItem repeated)
             {
                 if (!repeated.isActive) { DoCleanup(); return; }
                 if (pulseOut.isRunning) pulseOut.Stop();
-                callback?.Invoke();
                 pulseIn = element.AnimateBorderColor(
                     color1,
                     color2,
                     color1DurationMs,
-                    () => PulseOut(repeated));
+                    () => PulseOut(repeated)).KeepAlive();
             }
 
             void PulseOut(IVisualElementScheduledItem repeated)
             {
                 if (!repeated.isActive) { DoCleanup(); return; }
                 if (pulseIn.isRunning) pulseIn.Stop();
-                callback?.Invoke();
                 pulseOut = element.AnimateBorderColor(
                     color2,
                     color1,
-                    color2DurationMs);
+                    color2DurationMs, () => { if(!repeated.isActive) DoCleanup();}).KeepAlive();
             } // @formatter:on
 
             var recurring = color1DurationMs + color2DurationMs + 20;
+
             repeatedAnim = element.schedule
-                .Execute(() => PulseIn(repeatedAnim))
+                .Execute(() => { PulseIn(repeatedAnim); })
                 .StartingIn(0)
                 .Every(recurring)
                 .Until(() => !doBorderPulse);
+
             return repeatedAnim;
         }
     }
diff --git a/Runtime/Animations/HoverAnimations.cs b/Runtime/Animations/HoverAnimations.cs
index 750ad06..69c9c52 100644
--- a/Runtime/Animations/HoverAnimations.cs
+++ b/Runtime/Animations/HoverAnimations.cs
@@ -6,6 +6,7 @@
 #if UNITY_EDITOR
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using UnityEngine;
 using UnityEngine.UIElements;
 using UnityEngine.UIElements.Experimental;
@@ -211,32 +212,34 @@ public static void HoverBorder(this VisualElement target, Color original, Color
 
         // -------------------------------------------------- @HoverBorder
         // ---------------------------------------------------------------
-        /// <summary>
-        /// Adds background hover capability that will not be lost like CSS:hover when programatically setting background color
-        /// 
-        /// ** To help combat your element shifting position slightly when a border is applied on hover,
-        /// it is a good idea to add a border to your element before hand and just set color to 'initial'
-        /// so that it is transparent, then keep 'addBorder' parameter as false.
-        /// </summary>
-        /// <param name="target">The element in which this function will be applied</param>
-        /// <param name="pulseStartColor">The first color</param>
-        /// <param name="pulseEndColor">The second color</param>
-        /// <param name="original">The original color of the element being changed. Can be obtained and passed via 'visualElement.style.backgroundColor.value'</param>
-        /// <param name="addBorder">Adds a border if the element does not have one already</param>
-        /// <param name="borderStartEndWidth">The width in which the borders should be when displaying</param>
-        /// <param name="colorDuration">The duration of each colors cycle</param>
-        /// <param name="includeChildren">Register child elements for the hover event</param>
-        /// <param name="stopPropagation">Stop event from propagating further </param>
-        /// <returns>Tuple of type (EventCallback&lt;MouseOverEvent&gt; mouseOverEvent, EventCallback&lt;MouseOutEvent&gt; mouseOutEvent) which can be used for manually invoking or unregistering the events when no longer needed</returns>
-        /// <example>
-        ///<code>
-        /// var myHoverEvents = myVisualElement.HoverBorderPulse("#2F569C".FromHex(), "#D2A00C".FromHex(), includeChildren: true);
-        /// ...
-        /// myVisualElement.UnregisterCallback(myHoverEvents.mouseOverEvent, true);
-        /// myVisualElement.UnregisterCallback(myHoverEvents.mouseOutEvent, true);
-        /// </code>
-        /// </example>
-        public static AnimatedItems<MouseOverEvent,MouseOutEvent>
+        ///  <summary>
+        ///  Adds background hover capability that will not be lost like CSS:hover when programatically setting background color
+        ///  
+        ///  ** To help combat your element shifting position slightly when a border is applied on hover,
+        ///  it is a good idea to add a border to your element before hand and just set color to 'initial'
+        ///  so that it is transparent, then keep 'addBorder' parameter as false.
+        ///  </summary>
+        ///  <param name="target">The element in which this function will be applied</param>
+        ///  <param name="pulseStartColor">The first color</param>
+        ///  <param name="pulseEndColor">The second color</param>
+        ///  <param name="original">The original color of the element being changed. Can be obtained and passed via 'visualElement.style.backgroundColor.value'</param>
+        ///  <param name="addBorder">Adds a border if the element does not have one already</param>
+        ///  <param name="borderStartEndWidth">The width in which the borders should be when displaying</param>
+        ///  <param name="colorDuration">The duration of each colors cycle</param>
+        ///  <param name="includeChildren">Register child elements for the hover event</param>
+        ///  <param name="stopPropagation">Stop event from propagating further </param>
+        ///  <param name="useTrickleDown"><see cref="TrickleDown"/></param>
+        ///  <param name="animRunCheck">If any external ValueAnimation&lt;StyleValues&gt; items are passed, their current animation status will be checked, if any are currently running, this animation will not start until it is completed</param>
+        ///  <returns>Tuple of type (EventCallback&lt;MouseOverEvent&gt; mouseOverEvent, EventCallback&lt;MouseOutEvent&gt; mouseOutEvent) which can be used for manually invoking or unregistering the events when no longer needed</returns>
+        ///  <example>
+        /// <code>
+        ///  var myHoverEvents = myVisualElement.HoverBorderPulse("#2F569C".FromHex(), "#D2A00C".FromHex(), includeChildren: true);
+        ///  ...
+        ///  myVisualElement.UnregisterCallback(myHoverEvents.mouseOverEvent, true);
+        ///  myVisualElement.UnregisterCallback(myHoverEvents.mouseOutEvent, true);
+        ///  </code>
+        ///  </example>
+        public static AnimatedItems<MouseOverEvent, MouseOutEvent>
             HoverBorderPulse(
             this VisualElement target,
             Color pulseStartColor,
@@ -246,18 +249,30 @@ public static AnimatedItems<MouseOverEvent,MouseOutEvent>
             Vector2 borderStartEndWidth = default,
             int colorDuration = 1000,
             bool includeChildren = true,
-            bool stopPropagation = true)
+            bool stopPropagation = true,
+            TrickleDown useTrickleDown = TrickleDown.NoTrickleDown,
+            AnimatedItems<MouseOverEvent, MouseOutEvent> animatedItems = null,
+            params ValueAnimation<StyleValues>[] animRunCheck)
         {
             if (borderStartEndWidth == default)
                 borderStartEndWidth = new Vector2(1, 0);
 
+            var doHover = false;
             var pulseIn = new ValueAnimation<StyleValues>();
             var pulseOut = new ValueAnimation<StyleValues>();
             IVisualElementScheduledItem repeatedAnim = null;
-            var doHover = false;
+
+            if (animatedItems == null)
+                animatedItems = new AnimatedItems<MouseOverEvent, MouseOutEvent>(target);
 
             EventCallback<MouseOverEvent> mouseOverEvent = evt =>
             {
+                if (animRunCheck.Length > 0)
+                    if (animRunCheck.Any(t => t.isRunning))
+                        return;
+
+                if (!animatedItems.AllowRun) return;
+
                 repeatedAnim = null;
                 doHover = true;
                 if (addBorder)
@@ -294,10 +309,11 @@ void PulseOut(in ValueAnimation<StyleValues> pulse)
 
             EventCallback<MouseOutEvent> mouseOutEvent = evt =>
             {
+                if (!animatedItems.AllowRun) return;
                 doHover = false;
                 if (pulseIn.isRunning) pulseIn?.Stop();
                 if (pulseOut.isRunning) pulseOut?.Stop();
-                if (repeatedAnim.isActive)
+                if (repeatedAnim != null && repeatedAnim.isActive)
                 {
                     repeatedAnim.Pause();
                 }
@@ -320,20 +336,23 @@ void PulseOut(in ValueAnimation<StyleValues> pulse)
                 if (stopPropagation) evt.StopPropagation();
             };
 
-            target.RegisterCallback(mouseOverEvent, includeChildren);
-            target.RegisterCallback(mouseOutEvent, includeChildren);
+            target.RegisterCallback(mouseOverEvent, includeChildren, useTrickleDown);
+            target.RegisterCallback(mouseOutEvent, includeChildren, useTrickleDown);
 
-            return new AnimatedItems<MouseOverEvent,MouseOutEvent>(target)
-            {
-                AnimatedItemList = new List<ValueAnimation<StyleValues>> { pulseIn, pulseOut }, 
-                EventCallbacks = (mouseOverEvent, mouseOutEvent) 
-            };
+            animatedItems.AnimatedItemList = new List<ValueAnimation<StyleValues>> { pulseIn, pulseOut };
+            animatedItems.EventCallbacks = (mouseOverEvent, mouseOutEvent);
+            return animatedItems;
         }
 
         #region Unregister
 
-        public static void HoverBorderPulseUnregister(this VisualElement target, Color pulseStartColor, Color pulseEndColor, Color original = default, bool addBorder = false,
-        Vector2 borderStartEndWidth = default, int colorDuration = 1000, bool includeChildren = true, bool stopPropagation = true)
+        public static void HoverBorderPulseUnregister(
+        this VisualElement target, Color pulseStartColor, Color pulseEndColor, Color original = default, bool addBorder = false,
+        Vector2 borderStartEndWidth = default,
+        int colorDuration = 1000,
+        bool includeChildren = true,
+        bool stopPropagation = true,
+        TrickleDown useTrickleDown = TrickleDown.NoTrickleDown)
         {
             if (borderStartEndWidth == default)
                 borderStartEndWidth = new Vector2(1, 0);
@@ -414,11 +433,13 @@ void PulseOut(in ValueAnimation<StyleValues> pulse)
         // -------------------------------------------------------- @HoverWidth
         // -- Animate the width of target element to desired value on hover  --
         // --------------------------------------------------------------------
-        public static AnimatedItems HoverWidth(this VisualElement target, float initialWidth = 0f, float desiredWidth = 100f, int duration = 1000, Action hoverCallback = null,
+        public static AnimatedItems<MouseOverEvent, MouseOutEvent> HoverWidth(
+        this VisualElement target, float initialWidth = 0f, float desiredWidth = 100f, int duration = 1000, Action hoverCallback = null,
         Action leaveCallback = null,
         bool afterAnimation = false,
         bool includeChildren = true,
-        bool stopPropagation = true)
+        bool stopPropagation = true,
+        TrickleDown useTrickleDown = TrickleDown.NoTrickleDown)
         {
             initialWidth = initialWidth == 0f ? target.resolvedStyle.width : initialWidth;
             var enterAnim = new ValueAnimation<StyleValues>();
@@ -438,14 +459,15 @@ void MouseEnter()
             } // @formatter:off
             void MouseLeave() { leaveAnim.Start(); } // @formatter:on
 
-            EventCallback<MouseOverEvent> mouseOverEvent = evt => { 
+            EventCallback<MouseOverEvent> mouseOverEvent = evt =>
+            {
                 if (enterAnim.isRunning) enterAnim.Stop();
                 if (leaveAnim.isRunning) leaveAnim.Stop();
                 MouseEnter();
                 if (!afterAnimation) hoverCallback?.Invoke();
-                if (stopPropagation) evt.StopPropagation(); 
+                if (stopPropagation) evt.StopPropagation();
             };
-            
+
             EventCallback<MouseOutEvent> mouseOutEvent = evt =>
             {
                 if (enterAnim.isRunning) enterAnim.Stop();
@@ -455,20 +477,25 @@ void MouseEnter()
                 target.schedule.Execute(leaveCallback).StartingIn(duration);
             };
 
-            target.RegisterCallback(mouseOverEvent, includeChildren);
-            target.RegisterCallback(mouseOutEvent, includeChildren);
+            target.RegisterCallback(mouseOverEvent, includeChildren, useTrickleDown);
+            target.RegisterCallback(mouseOutEvent, includeChildren, useTrickleDown);
 
-            return new AnimatedItems<MouseOverEvent,MouseOutEvent>(target)
+            return new AnimatedItems<MouseOverEvent, MouseOutEvent>(target)
             {
-                AnimatedItemList = new List<ValueAnimation<StyleValues>> { enterAnim, leaveAnim }, 
-                EventCallbacks =  (mouseOverEvent, mouseOutEvent)
+                AnimatedItemList = new List<ValueAnimation<StyleValues>> { enterAnim, leaveAnim },
+                EventCallbacks = (mouseOverEvent, mouseOutEvent)
             };
         }
 
         // ------------------------------------------------------- @HoverHeight
         // -- Animate the Height of target element to desired value on hover --
         // --------------------------------------------------------------------
-        public static AnimatedItems HoverHeight(this VisualElement target, float initialHeight = 0f, float desiredHeight = 100f, int duration = 1000, Action hoverCallback = null,
+        public static AnimatedItems<MouseOverEvent, MouseOutEvent> HoverHeight(
+        this VisualElement target,
+        float initialHeight = 0f,
+        float desiredHeight = 100f,
+        int duration = 1000,
+        Action hoverCallback = null,
         Action leaveCallback = null,
         bool afterAnimation = false)
         {
@@ -492,7 +519,7 @@ void MouseEnter()
                 if (!afterAnimation) hoverCallback?.Invoke();
                 evt.StopPropagation();
             };
-            
+
             EventCallback<MouseOutEvent> mouseOutEvent = evt =>
             {
                 if (enterAnim.isRunning) enterAnim.Stop();
@@ -504,11 +531,11 @@ void MouseEnter()
 
             target.RegisterCallback(mouseOverEvent);
             target.RegisterCallback(mouseOutEvent);
-            
-            return new AnimatedItems<MouseOverEvent,MouseOutEvent>(target)
+
+            return new AnimatedItems<MouseOverEvent, MouseOutEvent>(target)
             {
-                AnimatedItemList = new List<ValueAnimation<StyleValues>> { enterAnim, leaveAnim }, 
-                EventCallbacks = (mouseOverEvent, mouseOutEvent) 
+                AnimatedItemList = new List<ValueAnimation<StyleValues>> { enterAnim, leaveAnim },
+                EventCallbacks = (mouseOverEvent, mouseOutEvent)
             };
         }
 
diff --git a/Runtime/Animations/VisualElementBaseAnimation.cs b/Runtime/Animations/VisualElementBaseAnimation.cs
index ce09361..4e6fe47 100644
--- a/Runtime/Animations/VisualElementBaseAnimation.cs
+++ b/Runtime/Animations/VisualElementBaseAnimation.cs
@@ -2,6 +2,7 @@
 // -- Project : https://github.com/instance-id/ElementAnimationToolkit       --
 // -- instance.id 2020 | http://github.com/instance-id | http://instance.id  --
 // ----------------------------------------------------------------------------
+
 #if UNITY_EDITOR
 using System;
 using instance.id.EATK.Extensions;
@@ -35,7 +36,33 @@ public static ValueAnimation<StyleValues> AnimateBackgroundColor(this VisualElem
                 .Ease(easing)
                 .OnCompleted(callback);
         }
-        
+
+        /// <summary>
+        /// Animate the background color of target element to desired value after delay
+        /// </summary>
+        /// <param name="target">VisualElement to animate</param>
+        /// <param name="startColor">Initial color of element</param>
+        /// <param name="endColor">The desired end result color which to animate</param>
+        /// <param name="durationMs">The length of time in milliseconds in which the animation will occur</param>
+        /// <param name="delayMs">The length of time in milliseconds to wait before starting animation</param>
+        /// <param name="callback">Function that can be called when the animation is completed</param>
+        /// <param name="easing">Controls the animation timing curve mathematically</param>
+        public static ValueAnimation<StyleValues> AnimateBackgroundColorDelayed(this VisualElement target, Color startColor, Color endColor, int durationMs = 500, int delayMs = 0, Action callback = null,
+        Func<float, float> easing = null)
+        {
+            ValueAnimation<StyleValues> anim = new ValueAnimation<StyleValues>();
+
+            if (easing == null) easing = Easy.EaseInOutQuint;
+            target.parent.schedule.Execute(() =>
+            {
+                anim = target.experimental.animation
+                    .Start(new StyleValues { backgroundColor = startColor }, new StyleValues { backgroundColor = endColor }, durationMs)
+                    .Ease(easing)
+                    .OnCompleted(callback);
+            }).StartingIn(delayMs);
+            return anim;
+        }
+
         /// <summary>
         /// Animate the background color of target element to desired value
         /// </summary>
@@ -137,7 +164,7 @@ public static ValueAnimation<StyleValues> AnimateImageTintColor(this VisualEleme
                 .Ease(easing)
                 .OnCompleted(callback);
         }
-        
+
         /// <summary>
         /// Animate the background color of target element to desired value
         /// </summary>
@@ -175,6 +202,36 @@ public static ValueAnimation<StyleValues> AnimateOpacity(this VisualElement targ
                 .OnCompleted(callback);
         }
 
+        // ----------------------------------------------- @AnimateOpacity
+        // ---------------------------------------------------------------
+        /// <summary>
+        /// Animate the opacity of target element to desired value after waiting for specified delay
+        /// </summary>
+        /// <param name="target">VisualElement to animate</param>
+        /// <param name="startOpacity">Initial opacity of element</param>
+        /// <param name="endOpacity">The desired end result opacity which to animate</param>
+        /// <param name="durationMs">The length of time in which the animation will occur(in milliseconds)</param>
+        /// <param name="callback">Function that can be called when the animation is completed</param>
+        /// <param name="easing">Controls the animation timing curve mathematically</param>
+        public static ValueAnimation<StyleValues> AnimateOpacityDelayed(this VisualElement target, float startOpacity, float endOpacity, int durationMs, int delayMs, Action callback = null,
+        Func<float, float> easing = null)
+        {
+            ValueAnimation<StyleValues> anim = new ValueAnimation<StyleValues>();
+            if (startOpacity == 0) startOpacity = 0.Zero();
+            if (endOpacity == 0) endOpacity = 0.Zero();
+
+            if (easing == null) easing = Easy.EaseInOutQuint;
+            target.parent.schedule.Execute(() =>
+            {
+                anim = target.experimental.animation
+                    .Start(new StyleValues { opacity = startOpacity }, new StyleValues { opacity = endOpacity }, durationMs)
+                    .Ease(easing)
+                    .OnCompleted(callback);
+            }).StartingIn(delayMs);
+
+            return anim;
+        }
+
         // ------------------------------------------------- @AnimateWidth
         // ---------------------------------------------------------------
         /// <summary>
diff --git a/Runtime/Elements/AnimatedFoldout/AnimatedFoldout.cs b/Runtime/Elements/AnimatedFoldout/AnimatedFoldout.cs
index aa4f373..6c9411a 100644
--- a/Runtime/Elements/AnimatedFoldout/AnimatedFoldout.cs
+++ b/Runtime/Elements/AnimatedFoldout/AnimatedFoldout.cs
@@ -3,6 +3,7 @@
 // -- instance.id 2020 | http://github.com/instance-id | http://instance.id  --
 // ----------------------------------------------------------------------------
 #if UNITY_EDITOR
+using System;
 using instance.id.EATK.Extensions;
 using UnityEngine.UIElements;
 
@@ -20,6 +21,7 @@ public class AnimatedFoldout : BindableElement, INotifyValueChanged<bool>
         public Expander expander;
         private bool m_Value;
         private bool isAnimating;
+        public Action stateChange = () => {};
 
         /// <summary>
         ///   <para>USS class name of elements of this type.</para>
@@ -40,7 +42,10 @@ public class AnimatedFoldout : BindableElement, INotifyValueChanged<bool>
         ///   <para>USS class name of expander element in a AnimatedFoldout.</para>
         /// </summary>
         public static readonly string expanderUssClassName = ussClassName + "__expander";
-
+       
+        /// <summary>
+        /// The container element that holds the AnimatedFoldout's child objects
+        /// </summary>
         public override VisualElement contentContainer => m_Container;
 
         public string text
@@ -64,6 +69,7 @@ public bool value
                     SetValueWithoutNotify(value);
                     SendEvent(pooled);
                 }
+                stateChange.Invoke();
             }
         }
 
@@ -93,7 +99,6 @@ public AnimatedFoldout()
             hierarchy.Add(expander);
             RegisterCallback(new EventCallback<AttachToPanelEvent>(OnAttachToPanel));
             RegisterCallback<GeometryChangedEvent>(DeferredExecution);
-            // expander.AnimationStatus += SetPickingMode;
         }
 
         private void DeferredExecution(GeometryChangedEvent evt)
@@ -111,6 +116,23 @@ private void SetPickingMode(bool animating)
             m_Toggle.SetEnabled(!animating);
         }
 
+        public void Expand(bool expandValue) => value = expandValue;
+        public void Expand() => value = !value;
+
+        /// <summary>
+        /// Manually trigger expansion or collapse of the expansion group via parameter
+        /// </summary>
+        /// <param name="rootElement">The root visual element of the binding object</param>
+        public void ActivateOnStart(VisualElement rootElement) => 
+            rootElement.RegisterCallback<GeometryChangedEvent>(evt => DoActivationOnStart(evt, rootElement));
+
+        // -- Callback will call this once the editor is ready, but just before displaying, so there is no visual "pop"
+        private void DoActivationOnStart(GeometryChangedEvent evt, VisualElement visualElement)
+        {
+            visualElement.UnregisterCallback<GeometryChangedEvent>(e => DoActivationOnStart(evt, visualElement));
+            value = true;
+        }
+
         private void OnAttachToPanel(AttachToPanelEvent evt)
         {
             int num = 0;
diff --git a/Runtime/Elements/AnimatedFoldout/UIElementExpander.cs b/Runtime/Elements/AnimatedFoldout/UIElementExpander.cs
index 711d320..00ed314 100644
--- a/Runtime/Elements/AnimatedFoldout/UIElementExpander.cs
+++ b/Runtime/Elements/AnimatedFoldout/UIElementExpander.cs
@@ -42,13 +42,13 @@ public int animationTime
 
         public Expander()
         {
-            expandToggle = new Toggle {style = {display = DisplayStyle.None}, name = "ExpandToggle"};
+            expandToggle = new Toggle { style = { display = DisplayStyle.None }, name = "ExpandToggle" };
             expandToggle.RegisterValueChangedCallback(ExpandContainerValueChanges);
 
             expandContainerItems = new VisualElement
             {
                 name = "expandContainer",
-                style = {overflow = Overflow.Hidden}
+                style = { overflow = Overflow.Hidden }
             };
             expandContainerItems.AddToClassList("expandContainer");
             expandContainerItems.Add(shownItem);
@@ -144,7 +144,7 @@ void HideContents()
                     expandContainerItems.experimental.animation.Start(new StyleValues
                         {
                             height = expandContainerItems.layout.height
-                        }, new StyleValues {height = 0}, animationTime)
+                        }, new StyleValues { height = 0 }, animationTime)
                         .Ease(Easy.EaseInOutQuint)
                         .OnCompleted(HideContents);
                 foldoutAnimation.KeepAlive();
@@ -172,7 +172,7 @@ private void ExpandContainerValueChanges(bool evt)
                 IsAnimating = true;
                 foldoutAnimation =
                     expandContainerItems.experimental.animation
-                        .Start(new StyleValues {height = expandContainerItems.layout.height}, new StyleValues {height = 0}, firstStart ? tmpAnimTime : m_AnimationTime)
+                        .Start(new StyleValues { height = expandContainerItems.layout.height }, new StyleValues { height = 0 }, firstStart ? tmpAnimTime : m_AnimationTime)
                         .Ease(Easy.EaseInOutQuint)
                         .OnCompleted(AnimationComplete);
                 foldoutAnimation.KeepAlive();
@@ -184,7 +184,7 @@ private void OnGeometryChangedEvent(GeometryChangedEvent evt)
             IsAnimating = true;
             foldoutAnimation =
                 expandContainerItems.experimental.animation
-                    .Start(new StyleValues {height = evt.oldRect.height}, new StyleValues {height = evt.newRect.height}, firstStart ? tmpAnimTime : m_AnimationTime)
+                    .Start(new StyleValues { height = evt.oldRect.height }, new StyleValues { height = evt.newRect.height }, firstStart ? tmpAnimTime : m_AnimationTime)
                     .Ease(Easy.EaseInOutQuint)
                     .OnCompleted(AnimationComplete);
 
diff --git a/Runtime/Scripts/Extensions/DataTypes/AnimatedItems.cs b/Runtime/Scripts/Extensions/DataTypes/AnimatedItems.cs
index b28c394..54dea73 100644
--- a/Runtime/Scripts/Extensions/DataTypes/AnimatedItems.cs
+++ b/Runtime/Scripts/Extensions/DataTypes/AnimatedItems.cs
@@ -16,6 +16,10 @@ public class AnimatedItems
         private List<ValueAnimation<StyleValues>> animatedItemList;
         private ValueAnimation<StyleValues>[] animatedItemArray;
 
+        // -- Default to allowing the animation to run, but allows for manually   
+        // -- setting false to prevent animation from running until set back to true
+        private bool allowRun = true;
+
         // --------------------------------------------------- Constructor
         // ---------------------------------------------------------------
         public AnimatedItems(VisualElement ele)
@@ -52,6 +56,12 @@ public ValueAnimation<StyleValues>[] AnimatedItemArray
             get => animatedItemArray;
             set => animatedItemArray = value;
         }
+        
+        public bool AllowRun
+        {
+            get => allowRun;
+            set => allowRun = value;
+        }
     }
     
     public class AnimatedItems<TEventType> : AnimatedItems
diff --git a/Runtime/Scripts/Extensions/VisualElementExtension.cs b/Runtime/Scripts/Extensions/VisualElementExtension.cs
index 3f0e599..efafa51 100644
--- a/Runtime/Scripts/Extensions/VisualElementExtension.cs
+++ b/Runtime/Scripts/Extensions/VisualElementExtension.cs
@@ -619,16 +619,49 @@ void DoSetBorderColor()
             return DoSetBorderColor;
         }
 
+        
+        // --------------------------------- Base Style Elements
+        /// <summary>
+        /// Set <see cref="Label"/> element text value 
+        /// </summary>
+        /// <param name="element">The element in which to set the text</param>
+        /// <param name="value">String value in which ot set the text</param>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
+        public static T SetText<T>(this T element, string value) where T : Label
+        {
+            element.text = value;
+            return element;
+        }
+        
+        public static T SetDisplay<T>(this T element, bool value) where T : VisualElement
+        {
+            element.style.display = value ? DisplayStyle.Flex : DisplayStyle.None;
+            return element;
+        }
+        
+        /// <summary>
+        /// Get element current display value
+        /// </summary>
+        /// <param name="element">The element in which to get display status</param>
+        /// <typeparam name="T">VisualElement</typeparam>
+        /// <returns>Bool value of element display status</returns>
+        public static bool GetDisplay<T>(this T element) where T : VisualElement
+        {
+            return element.resolvedStyle.display == DisplayStyle.Flex ;
+        }
+        
         /// <summary>
         /// Adds a border to all sides of the VisualElement
         /// </summary>
         /// <param name="element">The target element to add a border</param>
         /// <param name="opacity">The value in which to set the border thickness</param>
         /// <typeparam name="T">VisualElement</typeparam>
-        public static void SetOpacity<T>(this T element, float opacity = 0) where T : VisualElement
+        public static T SetOpacity<T>(this T element, float opacity = 0) where T : VisualElement
         {
             if (opacity == 0) opacity = opacity.Zero();
             element.style.opacity = opacity;
+            return element;
         }
 
         #endregion
diff --git a/Runtime/Util/ColorUtil.cs b/Runtime/Util/ColorUtil.cs
index bc40426..c56b4f9 100644
--- a/Runtime/Util/ColorUtil.cs
+++ b/Runtime/Util/ColorUtil.cs
@@ -25,7 +25,7 @@ public static string EnsureHex(this string color)
         /// <summary>
         /// Converts a hexadecimal color string to a Unity RGBA Color value
         /// </summary>
-        /// <example><code>var color = GetColor.FromHex("#CCCCCC");</code></example>
+        /// <example><code>var color = ColorUtil.FromHex("#CCCCCC");</code></example>
         /// <param name="color">The string parameter must be a hexadecimal string, can beginning with #</param>
         /// <returns>Returns a Unity Color parameter converted from a HTML/hexadecimal color string</returns>
         /// <remarks>The string parameter must be a hexadecimal string beginning with #</remarks>
diff --git a/Runtime/id.instance.elementanimationtoolkit.asmdef b/Runtime/id.instance.elementanimationtoolkit.asmdef
index 76e2722..67dce49 100644
--- a/Runtime/id.instance.elementanimationtoolkit.asmdef
+++ b/Runtime/id.instance.elementanimationtoolkit.asmdef
@@ -1,8 +1,7 @@
 {
     "name": "id.instance.elementanimationtoolkit",
-    "references": [
-        "id.instance.extensions"
-    ],
+    "rootNamespace": "",
+    "references": [],
     "includePlatforms": [],
     "excludePlatforms": [],
     "allowUnsafeCode": false,