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);
}
}
