private bool StartAnimatingPropertyVector3Int(object component, string strProp, Vector3Int src, Vector3Int targ, float durTime, PropertyUpdater <T> .GetValAtUpdate getValAtUpdate, List <UnityAction> callbacksStart, List <UnityAction> callbacksPause, List <UnityAction> callbacksResume, List <UnityAction> callbacksEnd) { return(StartAnimatingPeoperty <Vector3Int>(updatersVector3Int, component, strProp, src, targ, durTime, PropertyUpdater <Vector3Int> .GetValAtUpdateVector3Int, callbacksStart, callbacksPause, callbacksResume, callbacksEnd)); }
/// <summary> /// Refresh this cached object with a custom delegate. /// </summary> /// <param name="providedDelegate"></param> public T Refresh(PropertyUpdater <T> providedDelegate) { if (isStale) { updateDelegate = updateDelegate ?? providedDelegate; Refresh(); } return(value); }
/// <summary> /// Create a new cached property. /// </summary> /// <param name="updateDelegate">The delegate method which will perform future updates to this property.</param> /// <param name="refreshInterval">How often we should refresh this property.</param> /// <param name="backgroundRefresh">Whether we should continuously refresh this property in the background (on a background thread)</param> public CachedProperty(PropertyUpdater <T> updateDelegate, int refreshInterval = 1000, bool backgroundRefresh = false) { RefreshInterval = refreshInterval; this.updateDelegate = updateDelegate; Refresh(); if (backgroundRefresh) { scheduledDelegate = GameBase.BackgroundScheduler.AddDelayed(Refresh, refreshInterval, true); } }
protected void UpdateProperty <TValue, TEntity>(TEntity entity, Func <Expression <Func <TEntity, TValue> > > expressionGetter, TValue newValue) { var c = PropertyUpdater <TEntity, TValue> .GetPropertyUpdater(expressionGetter); var oldValue = c.UpdateValue(entity, newValue); if (!Equals(oldValue, newValue)) { PropertyChanging?.Invoke(ModelChangedEventArgs.PropertyChange(this, c.Name, oldValue, newValue)); PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(c.Name)); } }
private bool StartAnimatingPeoperty <T>(List <PropertyUpdater <T> > updaters, object component, string strProp, T src, T targ, float durTime, PropertyUpdater <T> .GetValAtUpdate getValAtUpdate) { if (FindAnimatingProperty <T>(updaters, component, strProp) != null) { Debug.LogWarning("Property is already in animating."); return(false); } PropertyWrapper <T> wrapper = new PropertyWrapper <T>(component, strProp); PropertyUpdater <T> updater = new PropertyUpdater <T>(wrapper, src, targ, durTime, getValAtUpdate); updaters.Add(updater); updater.Start(); return(true); }
private bool EndAnimatingProperty <T>(List <PropertyUpdater <T> > updaters, object component, string strProp, EndPropertyState endState) { PropertyUpdater <T> updater = FindAnimatingProperty <T>(updaters, component, strProp); if (updater == null) { return(false); } switch (endState) { case EndPropertyState.Src: updater.Pause(); updater.SetStartVal(); break; case EndPropertyState.Targ: updater.End(); break; case EndPropertyState.Keep: updater.Pause(); break; } updaters.Remove(updater); UnityEvent uevent; Tuple <object, string> key = new Tuple <object, string>(component, strProp); // Remove pausing event eventsDicPause.Remove(key); // Remove resuming event eventsDicResume.Remove(key); // Invoke endineventsDicPauseg event uevent = FindPropertyEvent <T>(eventsDicEnd, component, strProp); if (uevent != null) { uevent.Invoke(); } // Remove resuming event eventsDicEnd.Remove(key); return(true); }
private bool ResumeAnimatingProperty <T>(List <PropertyUpdater <T> > updaters, object component, string strProp) { PropertyUpdater <T> updater = FindAnimatingProperty <T>(updaters, component, strProp); if (updater == null) { return(false); } updater.Resume(); // Invoke resuming event UnityEvent uevent = FindPropertyEvent <T>(eventsDicResume, component, strProp); if (uevent != null) { uevent.Invoke(); } return(true); }
public void ReadLocalProperty () { PropertyUpdater data = new PropertyUpdater (); Rectangle rectangle = new Rectangle { Opacity = 0f }; Binding binding = new Binding { Path = new PropertyPath ("Opacity"), Mode = BindingMode.OneWay, Source = data }; Assert.AreEqual (0.0, (double) rectangle.ReadLocalValue (Rectangle.OpacityProperty), "#1"); rectangle.SetBinding (Rectangle.OpacityProperty, binding); Assert.IsTrue(rectangle.ReadLocalValue (Rectangle.OpacityProperty) is BindingExpressionBase, "#2"); }
public void TestOneWayBinding3 () { PropertyUpdater data = new PropertyUpdater { Opacity = 0.5f }; Rectangle rectangle = new Rectangle { Opacity = 1f , DataContext = data }; Binding binding = new Binding { Path = new PropertyPath ("Opacity"), Mode = BindingMode.OneWay, }; rectangle.SetBinding (Rectangle.OpacityProperty, binding); rectangle.DataContext = null; data.Opacity = 0.5f; Assert.AreEqual (1.0f, rectangle.Opacity, "#1"); rectangle.DataContext = data; Assert.AreEqual (0.5f, rectangle.Opacity, "#2"); }
public void TestOneWayBinding2 () { PropertyUpdater data = new PropertyUpdater { Opacity = 0.5f }; Rectangle rectangle = new Rectangle { Opacity = 0f }; Binding binding = new Binding { Path = new PropertyPath ("Opacity"), Mode = BindingMode.OneWay, Source = data }; rectangle.SetBinding (Rectangle.OpacityProperty, binding); Assert.AreEqual (data.Opacity, rectangle.Opacity); data.Opacity = 0.0f; Assert.AreEqual (data.Opacity, rectangle.Opacity); }
public void TestTwoWayBinding5 () { PropertyUpdater data = new PropertyUpdater { Opacity = 0.5f }; data.Reset (); TextBlock block = new TextBlock { Text = "Ted" }; block.SetBinding (TextBlock.TextProperty, new Binding { Path = new PropertyPath ("Opacity"), Source = data, Mode = BindingMode.TwoWay }); Assert.AreEqual ("0.5", block.Text, "#1"); Assert.IsTrue (data.Get, "#a"); Assert.IsFalse (data.Set, "#b"); data.Reset (); block.Text = "1"; Assert.AreEqual (1, data.Opacity, "#2"); Assert.IsTrue (data.Get, "#c"); Assert.IsTrue (data.Set, "#d"); data.Reset (); block.Text = "1"; Assert.IsFalse (data.Get, "#e"); Assert.IsFalse (data.Set, "#f"); }
public void TestTwoWayBinding4 () { PropertyUpdater data = new PropertyUpdater { Opacity = 0.5f }; TextBlock block = new TextBlock { Text = "Ted" }; block.SetBinding (TextBlock.TextProperty, new Binding { Path = new PropertyPath ("Opacity"), Source = data, Mode = BindingMode.TwoWay }); Assert.AreEqual ("0.5", block.Text, "#1"); block.Text = "1"; Assert.AreEqual (1, data.Opacity, "#2"); block.Text = "100"; Assert.AreEqual (100, data.Opacity, "#3"); block.Text = ""; Assert.AreEqual (100, data.Opacity, "#4"); }
public void TestTwoWayBinding3 () { PropertyUpdater data = new PropertyUpdater { Opacity = 0.5f }; Rectangle r = new Rectangle { Opacity = 0 }; r.SetBinding (Rectangle.OpacityProperty, new Binding { Path = new PropertyPath ("OpacityASDF"), Source = data, Mode = BindingMode.TwoWay }); Assert.AreEqual (1, r.Opacity, "#1"); Assert.AreEqual (0.5, data.Opacity, "#2"); data.Opacity = 0; Assert.AreEqual (1, r.Opacity, "#3"); r.Opacity = 0.5f; Assert.AreEqual (0, data.Opacity); }
public static PropertyUpdater <T> Update <T>(T objectToUpdate) { return(PropertyUpdater <T> .Update(objectToUpdate)); }
public void DataContext_ChangeParentOneWay () { Canvas canvas = new Canvas (); PropertyUpdater updater = new PropertyUpdater { Opacity = 0 }; Binding binding = new Binding ("Opacity"); Rectangle rectangle = new Rectangle { Name = "TED" }; canvas.DataContext = updater; canvas.Children.Add (rectangle); rectangle.SetBinding (Rectangle.OpacityProperty, binding); Assert.AreSame (rectangle.DataContext, canvas.DataContext, "#1"); updater.Opacity = 0; Assert.AreEqual (0, rectangle.Opacity, "#2"); canvas.DataContext = null; Assert.AreEqual (1, rectangle.Opacity, "#3"); updater.Opacity = 0.5f; Assert.AreEqual (1, rectangle.Opacity, "#4"); }
public ContainsPropertyUpdater () { Updater = new PropertyUpdater (); }
private bool StartAnimatingPeoperty <T>(List <PropertyUpdater <T> > updaters, object component, string strProp, T src, T targ, float durTime, PropertyUpdater <T> .GetValAtUpdate getValAtUpdate, List <UnityAction> callbacksStart, List <UnityAction> callbacksPause, List <UnityAction> callbacksResume, List <UnityAction> callbacksEnd) { if (!StartAnimatingPeoperty <T>(updaters, component, strProp, src, targ, durTime, getValAtUpdate)) { return(false); } Tuple <object, string> key = new Tuple <object, string>(component, strProp); UnityEvent uevent; //if (callbacksStart!=null && callbacksStart.Count > 0) //{ // uevent = new UnityEvent(); // foreach (var callback in callbacksStart) // { // uevent.AddListener(callback); // } // eventsDicStart.Add(key, uevent); //} if (callbacksPause != null && callbacksPause.Count > 0) { uevent = new UnityEvent(); foreach (var callback in callbacksPause) { uevent.AddListener(callback); } eventsDicPause.Add(key, uevent); } if (callbacksResume != null && callbacksResume.Count > 0) { uevent = new UnityEvent(); foreach (var callback in callbacksResume) { uevent.AddListener(callback); } eventsDicResume.Add(key, uevent); } if (callbacksEnd != null && callbacksEnd.Count > 0) { uevent = new UnityEvent(); foreach (var callback in callbacksEnd) { uevent.AddListener(callback); } eventsDicEnd.Add(key, uevent); } UnityEvent ueventStart = new UnityEvent(); foreach (var callback in callbacksStart) { ueventStart.AddListener(callback); } ueventStart.Invoke(); return(true); }
public void BindToText2 () { PropertyUpdater data = new PropertyUpdater { Opacity = 0 }; Binding binding = new Binding ("Opacity"); TextBox box = new TextBox (); box.DataContext = data; box.SetBinding (TextBox.TextProperty, binding); data.Opacity = 0.5f; Assert.AreEqual ("0.5", box.Text, "#1"); data.Opacity = 0.0f; Assert.AreEqual ("0", box.Text, "#2"); }
/// <summary> /// Create a new cached property. /// </summary> /// <param name="updateDelegate">The delegate method which will perform future updates to this property.</param> /// <param name="clock">The clock which will be used to decide whether we need a refresh.</param> /// <param name="refreshInterval">How often we should refresh this property. Set to -1 to never update. Set to 0 for once per frame.</param> public Cached(PropertyUpdater updateDelegate = null, IClock clock = null, int refreshInterval = -1) { RefreshInterval = refreshInterval; this.updateDelegate = updateDelegate; this.clock = clock; }
/// <summary> /// Refresh this cached object with a custom delegate. /// </summary> /// <param name="providedDelegate"></param> public T Refresh(PropertyUpdater providedDelegate) { updateDelegate = updateDelegate ?? providedDelegate; return(MakeValidOrDefault()); }
public void TestTwoWayBinding2() { PropertyUpdater data = new PropertyUpdater { Opacity = 0.5f }; Rectangle r = new Rectangle(); r.SetBinding(Rectangle.OpacityProperty, new Binding { Path = new PropertyPath("Opacity"), Source = data, Mode = BindingMode.TwoWay }); Assert.AreEqual(0.5, r.Opacity, "#1"); Assert.AreEqual(0.5, data.Opacity, "#2"); data.Opacity = 0; Assert.AreEqual(0.0, r.Opacity, "#3"); r.Opacity = 1; Assert.IsTrue(r.ReadLocalValue(Rectangle.OpacityProperty) is BindingExpressionBase, "#4"); Assert.AreEqual(1, r.Opacity, "#5"); Assert.AreEqual(1, data.Opacity, "#6"); r.ClearValue(Rectangle.OpacityProperty); r.Opacity = 0.5; Assert.AreEqual(1, data.Opacity, "#7"); }