public static void SynchronizeProxiedForLifetime(this IObservableObject obj, ConsoleApp app, string propertyName, Action handler, ILifetimeManager manager) { obj.SynchronizeForLifetime(propertyName, () => { app.QueueAction(handler); }, manager); }
public void UnbindData(IObservableObject observableObject, IObserver observer) { if (ObserveList.ContainsKey(observableObject) && ObserveList[observableObject].Contains(observer)) { ObserveList[observableObject].Remove(observer); } }
public AverageTemperatureDisplay(IObservableObject weatherData) { _weatherData = weatherData; _weatherData.AddObserver(this); _historicalTempuratures = new List <float>(); _currentTemperature = 0; }
/// <summary> /// Creates a new bag and optionally sets the notifier object. /// </summary> public ObservableObject(IObservableObject proxy = null) { SuppressEqualChanges = true; subscribers = new Dictionary <string, List <PropertyChangedSubscription> >(); values = new Dictionary <string, object>(); DeepObservableRoot = proxy; }
public static IDisposable SynchronizeProxiedUnmanaged(this IObservableObject obj, ConsoleApp app, string propertyName, Action handler) { return(obj.SynchronizeUnmanaged(propertyName, () => { app.QueueAction(handler); })); }
public SuspendNotificationContext(IObservableObject observableObject) { _ObservableObjects = new List <IObservableObject>() { observableObject }; observableObject.BeginInit(); }
/// <summary> /// Creates an ObservableDocument given a root observable. The ObservableDocument will /// immiediately attach to the root object and all child observables. /// </summary> /// <param name="root">the root object to observe</param> public ObservableDocument(IObservableObject root) { Watch(root); this.Changed.SubscribeForLifetime(() => undoRedoPending = false, this); this.OnDisposed(() => { trackedObservables.Clear(); }); }
public void PropertyChange(IObservableObject observableObject, string propertyName, object value) { if (ObserveList.ContainsKey(observableObject)) { foreach (IObserver observer in ObserveList[observableObject]) { observer.PropertyChanged(propertyName, value); } } }
internal static T GetPropertyValue <T>( this IObservableObject propertyModel, uint propertyId) { object value = propertyModel.GetProperty(propertyId); if (typeof(T).GetTypeInfo().IsEnum) { return((T)Enum.ToObject(typeof(T), value)); } return(value.AssertCast <T>()); }
public void BindingData(IObservableObject observableObject, IObserver observer) { if (!ObserveList.ContainsKey(observableObject)) { ObserveList.Add(observableObject, new List <IObserver>() { observer }); } else if (!ObserveList[observableObject].Contains(observer)) { ObserveList[observableObject].Add(observer); } }
public SectionProxy(IObservableObject <ISectionObservable, INode> target) : base(target) { }
public static TInterface ActAs <TInterface>(this IObservableObject observable, params Type[] otherInterfaces) where TInterface : class { return(observable.ActLike <TInterface>(otherInterfaces)); }
public OutlineProxy(IObservableObject <IOutlineObservable, INode> target) : base(target) { }
public ObjectProxy(IObservableObject <IObjectObservable, INode> target) : base(target) { }
public AppStateProxy(IObservableObject <IAppState, INode> target) : base(target) { }
public View1() { INPC = new ObservableObject(); }
public ShapeProxy(IObservableObject <IShape, INode> target) : base(target) { }
public MetaProxy(IObservableObject <T, INode> target) : base(target) { }
public SuspendNotificationContext(IObservableObject observableObject) { _ObservableObjects = new List<IObservableObject>() { observableObject }; observableObject.BeginInit(); }
public FlightSegmentProxy(IObservableObject <IFlightSegment, INode> target) : base(target) { }
public ItineraryProxy(IObservableObject <IItinerary, INode> target) : base(target) { }
public ArrayProxy(IObservableObject <IArrayObservable, INode> target) : base(target) { }
public TodoStoreProxy(IObservableObject <ITodoStore, INode> target) : base(target) { }
public CounterProxy(IObservableObject <ICounter, INode> target) : base(target) { }
private IDisposable DeepSubscribeInternal(string path, Action handler, Lifetime rootLifetime = null) { rootLifetime = rootLifetime ?? new Lifetime(); var observableRoot = DeepObservableRoot ?? this; IObservableObject currentObservable = observableRoot; var pathExpression = ObjectPathExpression.Parse(path); List <IObjectPathElement> currentPath = new List <IObjectPathElement>(); var anyChangeLifetime = new Lifetime(); for (int i = 0; i < pathExpression.Elements.Count; i++) { var propertyElement = pathExpression.Elements[i] as PropertyPathElement; if (propertyElement == null) { throw new NotSupportedException("Indexers are not supported for deep observability"); } currentPath.Add(propertyElement); ObjectPathExpression.TraceNode eval; if (i == pathExpression.Elements.Count - 1 && propertyElement.PropertyName == ObservableObject.AnyProperty) { eval = new ObjectPathExpression.TraceNode() { Value = null }; } else { eval = new ObjectPathExpression(currentPath).EvaluateAndTraceInfo(observableRoot).Last(); if (i != pathExpression.Elements.Count - 1 && (eval.MemberInfo as PropertyInfo).PropertyType.GetInterfaces().Contains(typeof(IObservableObject)) == false) { throw new NotSupportedException($"element {eval.MemberInfo.Name} is not observable"); } } currentObservable.SubscribeForLifetime(propertyElement.PropertyName, () => { handler(); if (anyChangeLifetime.IsExpired == false) { anyChangeLifetime.Dispose(); } if (rootLifetime.IsExpired == false) { DeepSubscribeInternal(path, handler, rootLifetime); } }, EarliestOf(anyChangeLifetime, rootLifetime).LifetimeManager); currentObservable = eval.Value as IObservableObject; if (currentObservable == null) { break; } } return(rootLifetime); }
public OrderProxy(IObservableObject <IOrder, INode> target) : base(target) { }
public ItemProxy(IObservableObject <IITem, INode> target) : base(target) { }
public static TInterface ActAsProxy <TInterface>(this IObservableObject observable) where TInterface : class { return(observable.ActAs <TInterface>(typeof(IObservableObject <TInterface, INode>))); }
public FormProxy(IObservableObject <IFormObservable, INode> target) : base(target) { }
public NullProxy(IObservableObject <INullObservable, INode> target) : base(target) { }
public ModelProxy(IObservableObject <IModel, INode> target) : base(target) { }
private void Watch(IObservableObject obj, string path = "root") { foreach (var existingTrackedProperty in trackedObservables.Where(o => o.Path.StartsWith(path)).ToList()) { trackedObservables.Remove(existingTrackedProperty); } var trackedObservable = new TrackedObservable() { PropertyValue = obj, Path = path }; trackedObservables.Add(trackedObservable); var trackingLifetime = trackedObservables.GetMembershipLifetime(trackedObservable); foreach (var property in obj.GetType().GetProperties()) { if (obj is IObservableCollection && property.Name == "Item") { continue; } bool isSyncing = true; obj.SynchronizeForLifetime(property.Name, () => { var myProp = property; var val = myProp.GetValue(obj); if (val is IObservableObject) { Watch(val as IObservableObject, path + "." + myProp.Name); } if (isSyncing) { isSyncing = false; } else { if (undoRedoPending == false) { undoRedoStack.Do(new PropertyAssignmentAction(obj, myProp, obj.GetPrevious(myProp.Name))); } Changed.Fire(); } }, trackingLifetime); } if (obj is IObservableCollection) { var collection = obj as IObservableCollection; collection .WhereAs <IObservableObject>() .ForEach(child => Watch(child as IObservableObject, path + "[" + Guid.NewGuid() + "]")); collection.Added.SubscribeForLifetime((o) => { if (undoRedoPending == false) { undoRedoStack.Do(new AddToCollectionAction(collection, o, collection.LastModifiedIndex)); } if (o is IObservableObject) { Watch(o as IObservableObject, path + "[" + Guid.NewGuid() + "]"); } Changed.Fire(); }, trackingLifetime); collection.Removed.SubscribeForLifetime((o) => { if (undoRedoPending == false) { undoRedoStack.Do(new RemovedFromCollectionAction(collection, o, collection.LastModifiedIndex)); } if (o is IObservableObject) { var tracked = trackedObservables.Where(to => to.PropertyValue == o).Single(); foreach (var related in trackedObservables.Where(t => t.Path.StartsWith(tracked.Path)).ToList()) { trackedObservables.Remove(related); } } Changed.Fire(); }, trackingLifetime); collection.AssignedToIndex.SubscribeForLifetime((args) => throw new NotSupportedException("Index assignments are not supported by observable documents"), trackingLifetime); } }