Make ValueChanged give an EventArgs

osu.Framework.Tests/Bindables/BindableBindingTest.cs

@@ -338,6 +338,35 @@ public void TestUnbindFrom()
             Assert.AreNotEqual(bindable1.Value, bindable2.Value);
         }
 
+        [Test]
+        public void TestEventArgs()
+        {
+            var bindable1 = new Bindable<int>();
+            var bindable2 = new Bindable<int>();
+
+            bindable2.BindTo(bindable1);
+
+            ValueChangedEvent<int> event1 = null;
+            ValueChangedEvent<int> event2 = null;
+
+            bindable1.BindValueChanged(e => event1 = e);
+            bindable2.BindValueChanged(e => event2 = e);
+
+            bindable1.Value = 1;
+
+            Assert.AreEqual(0, event1.OldValue);
+            Assert.AreEqual(1, event1.NewValue);
+            Assert.AreEqual(0, event2.OldValue);
+            Assert.AreEqual(1, event2.NewValue);
+
+            bindable1.Value = 2;
+
+            Assert.AreEqual(1, event1.OldValue);
+            Assert.AreEqual(2, event1.NewValue);
+            Assert.AreEqual(1, event2.OldValue);
+            Assert.AreEqual(2, event2.NewValue);
+        }
+
         private class TestDrawable : Drawable
         {
             public bool ValueChanged;

osu.Framework.Tests/Dependencies/CachedModelDependenciesTest.cs

@@ -141,7 +141,7 @@ private class CrossDependentFieldModel
 
             public CrossDependentFieldModel()
             {
-                Bindable.BindValueChanged(v => BindableTwo.Value = v);
+                Bindable.BindValueChanged(args => BindableTwo.Value = args.NewValue);
             }
         }
 

osu.Framework.Tests/Visual/TestCaseBindableNumbers.cs

@@ -225,7 +225,7 @@ public BindableDisplayContainer(BindableNumber<T> bindable)
                     }
                 };
 
-                bindable.ValueChanged += v => valueText.Text = v.ToString(CultureInfo.InvariantCulture);
+                bindable.ValueChanged += args => valueText.Text = args.NewValue.ToString(CultureInfo.InvariantCulture);
             }
         }
     }

osu.Framework.Tests/Visual/TestCaseContainer/TestCaseSafeArea.cs

@@ -66,7 +66,7 @@ private void load(GameHost host)
 
             if (window == null) return;
 
-            safeAreaPadding.ValueChanged += updatePadding;
+            safeAreaPadding.ValueChanged += args => updatePadding(args.NewValue);
             safeAreaPadding.BindTo(window.SafeAreaPadding);
             updatePadding(window.SafeAreaPadding.Value);
         }

osu.Framework.Tests/Visual/TestCaseContainerExtensions/TestCaseFillFlowContainer.cs

@@ -102,7 +102,7 @@ private void reset()
                 }
             };
 
-            selectionDropdown.Current.ValueChanged += changeTest;
+            selectionDropdown.Current.ValueChanged += args => changeTest(args.NewValue);
             buildTest();
             selectionDropdown.Current.Value = FlowTestCase.Full;
             changeTest(FlowTestCase.Full);

osu.Framework.Tests/Visual/TestCaseContainerExtensions/TestCaseSearchContainer.cs

@@ -118,7 +118,7 @@ public TestCaseSearchContainer()
                 AddAssert("Visible end-children: " + term.Value, () => term.Value == search.Children.SelectMany(container => container.Children.Cast<Container>()).SelectMany(container => container.Children).Count(drawable => drawable.IsPresent));
             });
 
-            textBox.Current.ValueChanged += newValue => search.SearchTerm = newValue;
+            textBox.Current.ValueChanged += args => search.SearchTerm = args.NewValue;
         }
 
         private class HeaderContainer : Container, IHasFilterableChildren

osu.Framework.Tests/Visual/TestCaseUserInterface/TestCaseCheckboxes.cs

@@ -48,7 +48,7 @@ public class ActionsTestCheckbox : BasicCheckbox
     {
         public ActionsTestCheckbox()
         {
-            Current.ValueChanged += v => this.RotateTo(v ? 45 : 0, 100);
+            Current.ValueChanged += args => this.RotateTo(args.NewValue ? 45 : 0, 100);
         }
     }
 }

osu.Framework.Tests/Visual/TestCaseUserInterface/TestCaseSliderbar.cs

@@ -111,9 +111,9 @@ public void Basic() {
             AddAssert("Value == 6", () => sliderBarValue == 6);
         }
 
-        private void sliderBarValueChanged(double newValue)
+        private void sliderBarValueChanged(ValueChangedEvent<double> args)
         {
-            sliderbarText.Text = $"Selected value: {newValue:N}";
+            sliderbarText.Text = $"Selected value: {args.NewValue:N}";
         }
     }
 }

osu.Framework.Tests/Visual/TestCaseUserInterface/TestCaseWaveform.cs

@@ -99,7 +99,7 @@ private void load(Game game, AudioManager audio)
             for (int i = 1; i <= 16; i *= 2)
                 flow.Add(new TestWaveform(track, 1f / i) { Waveform = waveform });
 
-            zoom.ValueChanged += v => flow.Width = track_width * v;
+            zoom.ValueChanged += args => flow.Width = track_width * args.NewValue;
         }
 
         private void startStop()

osu.Framework/Allocation/CachedModelDependencyContainer.cs

@@ -42,11 +42,11 @@ public CachedModelDependencyContainer(IReadOnlyDependencyContainer parent)
 
             shadowDependencies = DependencyActivator.MergeDependencies(shadowModel, null, new CacheInfo(parent: typeof(TModel)));
 
-            Model.BindValueChanged(newModel =>
+            Model.BindValueChanged(args =>
             {
                 // When setting a null model, we actually want to reset the shadow model to a default state
                 // rather than leaving the current state on-going
-                newModel = newModel ?? new TModel();
+                var newModel = args.NewValue ?? new TModel();
 
                 updateShadowModel(shadowModel, currentModel, newModel);
 

osu.Framework/Audio/AdjustableAudioComponent.cs

@@ -53,9 +53,9 @@ public class AdjustableAudioComponent : AudioComponent
 
         protected AdjustableAudioComponent()
         {
-            Volume.ValueChanged += InvalidateState;
-            Balance.ValueChanged += InvalidateState;
-            Frequency.ValueChanged += InvalidateState;
+            Volume.ValueChanged += args => InvalidateState(args.NewValue);
+            Balance.ValueChanged += args => InvalidateState(args.NewValue);
+            Frequency.ValueChanged += args => InvalidateState(args.NewValue);
         }
 
         internal void InvalidateState(double newValue = 0) => EnqueueAction(OnStateChanged);

osu.Framework/Audio/AudioManager.cs

@@ -135,9 +135,9 @@ protected override void Dispose(bool disposing)
             base.Dispose(disposing);
         }
 
-        private void onDeviceChanged(string newDevice)
+        private void onDeviceChanged(ValueChangedEvent<string> args)
         {
-            scheduler.Add(() => setAudioDevice(string.IsNullOrEmpty(newDevice) ? null : newDevice));
+            scheduler.Add(() => setAudioDevice(string.IsNullOrEmpty(args.NewValue) ? null : args.NewValue));
         }
 
         /// <summary>
@@ -162,7 +162,7 @@ public TrackManager GetTrackManager(IResourceStore<byte[]> store = null)
             TrackManager tm = new TrackManager(store);
             AddItem(tm);
             tm.AddAdjustment(AdjustableProperty.Volume, VolumeTrack);
-            VolumeTrack.ValueChanged += tm.InvalidateState;
+            VolumeTrack.ValueChanged += args => tm.InvalidateState(args.NewValue);
 
             return tm;
         }
@@ -179,7 +179,7 @@ public SampleManager GetSampleManager(IResourceStore<byte[]> store = null)
             SampleManager sm = new SampleManager(store);
             AddItem(sm);
             sm.AddAdjustment(AdjustableProperty.Volume, VolumeSample);
-            VolumeSample.ValueChanged += sm.InvalidateState;
+            VolumeSample.ValueChanged += args => sm.InvalidateState(args.NewValue);
 
             return sm;
         }

osu.Framework/Audio/Track/Track.cs

@@ -38,7 +38,7 @@ public abstract class Track : AdjustableAudioComponent, IAdjustableClock
 
         protected Track()
         {
-            Tempo.ValueChanged += InvalidateState;
+            Tempo.ValueChanged += args => InvalidateState(args.NewValue);
         }
 
         /// <summary>

osu.Framework/Configuration/Bindable.cs

@@ -21,7 +21,7 @@ public class Bindable<T> : IBindable<T>, ISerializableBindable
         /// <summary>
         /// An event which is raised when <see cref="Value"/> has changed (or manually via <see cref="TriggerValueChange"/>).
         /// </summary>
-        public event Action<T> ValueChanged;
+        public event Action<ValueChangedEvent<T>> ValueChanged;
 
         /// <summary>
         /// An event which is raised when <see cref="Disabled"/>'s state has changed (or manually via <see cref="TriggerDisabledChange"/>).
@@ -89,14 +89,14 @@ public virtual T Value
 
                 if (EqualityComparer<T>.Default.Equals(this.value, value)) return;
 
-                SetValue(value);
+                SetValue(this.value, value);
             }
         }
 
-        internal void SetValue(T value, bool bypassChecks = false, Bindable<T> source = null)
+        internal void SetValue(T previousValue, T value, bool bypassChecks = false, Bindable<T> source = null)
         {
             this.value = value;
-            TriggerValueChange(source ?? this, true, bypassChecks);
+            TriggerValueChange(previousValue, source ?? this, true, bypassChecks);
         }
 
         private Cached<WeakReference<Bindable<T>>> weakReferenceCache;
@@ -159,11 +159,11 @@ public virtual void BindTo(Bindable<T> them)
         /// </summary>
         /// <param name="onChange">The action to perform when <see cref="Value"/> changes.</param>
         /// <param name="runOnceImmediately">Whether the action provided in <see cref="onChange"/> should be run once immediately.</param>
-        public void BindValueChanged(Action<T> onChange, bool runOnceImmediately = false)
+        public void BindValueChanged(Action<ValueChangedEvent<T>> onChange, bool runOnceImmediately = false)
         {
             ValueChanged += onChange;
             if (runOnceImmediately)
-                onChange(Value);
+                onChange(new ValueChangedEvent<T>(Value, Value));
         }
 
         /// <summary>
@@ -216,22 +216,22 @@ public virtual void Parse(object input)
         /// </summary>
         public virtual void TriggerChange()
         {
-            TriggerValueChange(this, false);
+            TriggerValueChange(value, this, false);
             TriggerDisabledChange(this, false);
         }
 
-        protected void TriggerValueChange(Bindable<T> source, bool propagateToBindings = true, bool bypassChecks = false)
+        protected void TriggerValueChange(T previousValue, Bindable<T> source, bool propagateToBindings = true, bool bypassChecks = false)
         {
             // check a bound bindable hasn't changed the value again (it will fire its own event)
             T beforePropagation = value;
             if (propagateToBindings)
                 Bindings?.ForEachAlive(b =>
                 {
                     if (b == source) return;
-                    b.SetValue(value, bypassChecks, this);
+                    b.SetValue(previousValue, value, bypassChecks, this);
                 });
             if (EqualityComparer<T>.Default.Equals(beforePropagation, value))
-                ValueChanged?.Invoke(value);
+                ValueChanged?.Invoke(new ValueChangedEvent<T>(previousValue, value));
         }
 
         protected void TriggerDisabledChange(Bindable<T> source, bool propagateToBindings = true, bool bypassChecks = false)

osu.Framework/Configuration/IBindable.cs

@@ -34,7 +34,7 @@ public interface IBindable<T> : IBindable
         /// <summary>
         /// An event which is raised when <see cref="Value"/> has changed.
         /// </summary>
-        event Action<T> ValueChanged;
+        event Action<ValueChangedEvent<T>> ValueChanged;
 
         /// <summary>
         /// The current value of this bindable.
@@ -57,7 +57,7 @@ public interface IBindable<T> : IBindable
         /// </summary>
         /// <param name="onChange">The action to perform when <see cref="Value"/> changes.</param>
         /// <param name="runOnceImmediately">Whether the action provided in <see cref="onChange"/> should be run once immediately.</param>
-        void BindValueChanged(Action<T> onChange, bool runOnceImmediately = false);
+        void BindValueChanged(Action<ValueChangedEvent<T>> onChange, bool runOnceImmediately = false);
 
         /// <summary>
         /// Retrieve a new bindable instance weakly bound to the configuration backing.

osu.Framework/Configuration/LeasedBindable.cs

@@ -68,7 +68,8 @@ public override T Value
                     checkValid();
 
                 if (EqualityComparer<T>.Default.Equals(Value, value)) return;
-                SetValue(value, true);
+
+                SetValue(base.Value, value, true);
             }
         }
 

osu.Framework/Configuration/Tracking/TrackedSetting.cs

@@ -41,6 +41,6 @@ public void Unload()
             bindable.ValueChanged -= displaySetting;
         }
 
-        private void displaySetting(U value) => SettingChanged?.Invoke(generateDescription(value));
+        private void displaySetting(ValueChangedEvent<U> args) => SettingChanged?.Invoke(generateDescription(args.NewValue));
     }
 }

osu.Framework/Configuration/ValueChangedEvent.cs

@@ -0,0 +1,24 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+namespace osu.Framework.Configuration
+{
+    public class ValueChangedEvent<T>
+    {
+        /// <summary>
+        /// The old value.
+        /// </summary>
+        public readonly T OldValue;
+
+        /// <summary>
+        /// The new (and current) value.
+        /// </summary>
+        public readonly T NewValue;
+
+        public ValueChangedEvent(T oldValue, T newValue)
+        {
+            OldValue = oldValue;
+            NewValue = newValue;
+        }
+    }
+}

osu.Framework/Graphics/Sprites/SpriteText.cs

@@ -40,16 +40,16 @@ public partial class SpriteText : Drawable, IHasLineBaseHeight, IHasText, IHasFi
 
         public SpriteText()
         {
-            current.BindValueChanged(v => Text = v);
+            current.BindValueChanged(args => Text = args.NewValue);
         }
 
         [BackgroundDependencyLoader]
         private void load(ShaderManager shaders)
         {
             localisedText = localisation.GetLocalisedString(text);
-            localisedText.BindValueChanged(t =>
+            localisedText.BindValueChanged(args =>
             {
-                if (string.IsNullOrEmpty(t))
+                if (string.IsNullOrEmpty(args.NewValue))
                 {
                     // We'll become not present and won't update the characters to set the size to 0, so do it manually
                     if (requiresAutoSizedWidth)

osu.Framework/Graphics/UserInterface/BasicCheckbox.cs

@@ -73,7 +73,7 @@ public BasicCheckbox()
                 }
             };
 
-            Current.ValueChanged += c => box.FadeColour(c ? CheckedColor : UncheckedColor, FadeDuration);
+            Current.ValueChanged += args => box.FadeColour(args.NewValue ? CheckedColor : UncheckedColor, FadeDuration);
             Current.TriggerChange();
         }
     }

osu.Framework/Graphics/UserInterface/Dropdown.cs

@@ -170,16 +170,16 @@ protected override void LoadComplete()
             Header.Label = SelectedItem?.Text.Value;
         }
 
-        private void selectionChanged(T newSelection = default)
+        private void selectionChanged(ValueChangedEvent<T> args)
         {
             // refresh if SelectedItem and SelectedValue mismatched
             // null is not a valid value for Dictionary, so neither here
-            if ((SelectedItem == null || !EqualityComparer<T>.Default.Equals(SelectedItem.Value, newSelection))
-                && newSelection != null)
+            if ((SelectedItem == null || !EqualityComparer<T>.Default.Equals(SelectedItem.Value, args.NewValue))
+                && args.NewValue != null)
             {
-                if (!itemMap.TryGetValue(newSelection, out selectedItem))
+                if (!itemMap.TryGetValue(args.NewValue, out selectedItem))
                 {
-                    selectedItem = new DropdownMenuItem<T>(GenerateItemText(newSelection), newSelection);
+                    selectedItem = new DropdownMenuItem<T>(GenerateItemText(args.NewValue), args.NewValue);
                 }
             }
 

osu.Framework/Graphics/UserInterface/Menu.cs

@@ -590,7 +590,7 @@ public DrawableMenuItem(MenuItem item)
                 if (Content is IHasText textContent)
                 {
                     textContent.Text = item.Text;
-                    Item.Text.ValueChanged += newText => textContent.Text = newText;
+                    Item.Text.ValueChanged += args => textContent.Text = args.NewValue;
                 }
             }
 

osu.Framework/Graphics/UserInterface/SliderBar.cs

@@ -69,18 +69,18 @@ protected SliderBar()
 
             currentNumberInstantaneous = CurrentNumber.GetUnboundCopy();
 
-            CurrentNumber.ValueChanged += v => currentNumberInstantaneous.Value = v;
+            CurrentNumber.ValueChanged += args => currentNumberInstantaneous.Value = args.NewValue;
             CurrentNumber.MinValueChanged += v => currentNumberInstantaneous.MinValue = v;
             CurrentNumber.MaxValueChanged += v => currentNumberInstantaneous.MaxValue = v;
             CurrentNumber.PrecisionChanged += v => currentNumberInstantaneous.Precision = v;
             CurrentNumber.DisabledChanged += v => currentNumberInstantaneous.Disabled = v;
 
-            currentNumberInstantaneous.ValueChanged += v =>
+            currentNumberInstantaneous.ValueChanged += args =>
             {
                 if (TransferValueOnCommit)
                     uncommittedChanges = true;
                 else
-                    CurrentNumber.Value = v;
+                    CurrentNumber.Value = args.NewValue;
             };
         }
 

osu.Framework/Graphics/UserInterface/TabItem.cs

@@ -40,9 +40,9 @@ protected TabItem(T value)
             Active.ValueChanged += active_ValueChanged;
         }
 
-        private void active_ValueChanged(bool newValue)
+        private void active_ValueChanged(ValueChangedEvent<bool> args)
         {
-            if (newValue)
+            if (args.NewValue)
                 OnActivated();
             else
                 OnDeactivated();