public MainViewModel() { this.calculator1 = new CalculatorViewModel(false); this.calculator2 = new CalculatorViewModel(false); this.currentCalculator = ObservablePropertyFactory.Instance.CreateProperty(this.calculator1); }
protected override async ValueTask <bool> TryInvokeAsync(ObservablePropertyStateChangedArgs e) { if (consumer == null) { return(false); } if (!consumer.IsAlive()) { return(true); } IObservableProperty observableProperty = e.ObservableProperty; string propertyName = e.PropertyInfo.Name; if (observableContainers.TryGetValue(observableProperty, out IObservableContainer container)) { if (container.IsSubscribed(propertyName)) { await consumer.ForceUpdate(); return(true); } } return(false); }
protected virtual void OnKeyChanged() { if (this.value != null) { this.value.ValueChanged -= OnValueChanged; } if (!this.enabled || this.target == null || string.IsNullOrEmpty(key)) { return; } Localization localization = Localization.Current; this.value = localization.GetValue(key); //if (this.value == null) //{ // if (Application.isPlaying && log.IsErrorEnabled) // log.ErrorFormat("There is an invalid localization key \"{0}\" on the {1} object named \"{2}\".", key, typeof(T).Name, this.name); // return; //} this.value.ValueChanged += OnValueChanged; this.OnValueChanged(this.value, EventArgs.Empty); }
private void ProfileManager_OnPropertyUpdatedEvent(short key, IObservableProperty property) { if (key == (short)ObservablePropertyCodes.DisplayName) { DisplayName = $"{ property.Serialize()}"; } }
protected virtual void OnKeyChanged() { if (this.value != null) { this.value.ValueChanged -= OnValueChanged; } if (!this.enabled || this.target == null || string.IsNullOrEmpty(key)) { return; } Localization localization = Localization.Current; this.value = localization.Get <IObservableProperty>(key); if (this.value == null) { if (log.IsErrorEnabled) { log.ErrorFormat("There is an invalid localization key \"{0}\" on the {1} object named \"{2}\".", key, typeof(T).Name, this.name); } return; } this.value.ValueChanged += OnValueChanged; this.OnValueChanged(this.value, EventArgs.Empty); }
protected virtual void OnDisable() { if (this.value != null) { this.value.ValueChanged -= OnValueChanged; this.value = null; } }
public static IObservableProperty <T> InterceptSetterBefore <T>(this IObservableProperty <T> observableProperty, Action <T, T> interceptor) { if (interceptor == null) { throw new ArgumentNullException("interceptor"); } return(new ObservablePropertyBeforeSetterInterceptor <T>(observableProperty, interceptor)); }
public ViewModelPropertyInfo(IObservableProperty property, bool isElementProperty, bool isCollectionProperty, bool isEnum, bool isComputed = false) { Property = property; IsElementProperty = isElementProperty; IsCollectionProperty = isCollectionProperty; IsEnum = isEnum; IsComputed = isComputed; }
public static IObservableGetProperty <TSource> ToGetPropertyMask <TSource>(this IObservableProperty <TSource> source) { if (source == null) { throw new ArgumentNullException("source"); } return(new ObservableGetPropertyMask <TSource>(source)); }
protected override void OnDirtyProperty(IObservableProperty property) { base.OnDirtyProperty(property); if (OnModifiedInServerEvent != null) { OnModifiedInServerEvent.Invoke(this); } }
private DynamicPropertyProxy( IObservableProperty observableProperty, bool readOnly) { ObservableProperty = observableProperty; IsReadOnly = readOnly; observableFactory = observableProperty.CreateFactory(); Initialize(); }
public ObservableLiteralSourceProxy(IObservableProperty source) : base(source) { if (source == null) { throw new ArgumentNullException("source"); } this.observableProperty = source; this.observableProperty.ValueChanged += OnValueChanged; }
private TStore GetStore(IObservableProperty observableProperty) { if (!storeInstanceCache.TryGetValue(observableProperty, out TStore store)) { IPropertyProxy propertyProxy = propertyProxyFactory.Create(observableProperty); store = propertyProxyWrapper.WrapPropertyObservable <TStore>(propertyProxy); } return(store); }
public bool TryGetValue(string themeId, out IObservableProperty <T> value) { if (_values.TryGetValue(themeId, out var v)) { value = v; return(true); } value = null; return(false); }
void Awake() { Localization localization = Localization.Current; this.value = localization.Get <IObservableProperty>(key); this.text = this.GetComponent <Text>(); if (this.value != null) { this.value.ValueChanged += OnValueChanged; this.text.text = (string)Convert.ChangeType(this.value.Value, typeof(string)); } }
public RuntimeProxyManager( IObservableProperty observableProperty, MethodInterceptions methodInterceptions, bool readOnly) { ObservableProperty = observableProperty; this.methodInterceptions = methodInterceptions; IsReadOnly = readOnly; observableFactory = observableProperty.CreateFactory(); Initialize(); }
private object CreatePropertyObservable(IObservableProperty observableProperty) { DynamicPropertyProxy dynamicProxy = new DynamicPropertyProxy(observableProperty, IsReadOnly); object boxedItem = Box(dynamicProxy, observableProperty.ObservedType).Target; foreach (var subscriber in subscribers) { dynamicProxy.Subscribe(subscriber); } return(boxedItem); }
/// <summary> /// /// </summary> /// <param name="innerProperty"></param> /// <param name="action">Action to execute before the setter. First parameter is the old value, the second one is the new value.</param> public ObservablePropertyBeforeSetterInterceptor(IObservableProperty <T> innerProperty, Action <T, T> action) { if (innerProperty == null) { throw new ArgumentNullException("innerProperty"); } if (action == null) { throw new ArgumentNullException("action"); } _innerProperty = innerProperty; _action = action; }
public ObservablePropertyHolder( IPropertyProxyFactory propertyProxyFactory, IPropertyProxyWrapper propertyProxyWrapper, IObservableFactoryFactory observableFactoryFactory) { this.propertyProxyWrapper = propertyProxyWrapper; this.propertyProxyFactory = propertyProxyFactory; this.observableFactory = observableFactoryFactory.CreateFactory( OnPropertyStateChanged, OnCollectionItemsChanged); RootObservableProperty = observableFactory.CreateObservableProperty(typeof(T)); }
protected virtual ISourceProxy CreateProxy(LuaTable table, IPathNode node) { var indexedNode = node as IndexedNode; if (indexedNode != null) { if (indexedNode.Value is int) { return(new LuaIntTableNodeProxy(table, (int)indexedNode.Value)); } if (indexedNode.Value is string) { return(new LuaStringTableNodeProxy(table, (string)indexedNode.Value)); } return(null); } var memberNode = node as MemberNode; if (memberNode != null) { var obj = table.Get <object>(memberNode.Name); if (obj != null) { LuaFunction function = obj as LuaFunction; if (function != null) { return(new LuaMethodNodeProxy(table, function)); } IObservableProperty observableValue = obj as IObservableProperty; if (observableValue != null) { return(new ObservableNodeProxy(table, observableValue)); } IInteractionRequest request = obj as IInteractionRequest; if (request != null) { return(new InteractionNodeProxy(table, request)); } } return(new LuaStringTableNodeProxy(table, memberNode.Name)); } return(null); }
protected virtual void OnEnable() { this.target = this.GetComponent <T>(); if (this.target == null) { return; } Localization localization = Localization.Current; this.value = localization.Get <IObservableProperty>(key); if (this.value != null) { this.value.ValueChanged += OnValueChanged; this.OnValueChanged(this.value, EventArgs.Empty); } }
public void OverwriteFrom(IObservableProperty source, bool notify) { object newValue; foreach (var propertyName in allPropertiesByName.Keys) { if (!source.TryGetMember(propertyName, out newValue)) { throw new Exception($"Could not copy from source. Property name: {propertyName}"); } if (!TrySetMemberInternal(propertyName, newValue, notify)) { throw new Exception($"Could not copy to target. Property name: {propertyName}"); } } }
private T BoxItem(T item) { if (!(item != null && proxyWrapper.UnwrapPropertyObservable(item) is IPropertyProxy propertyProxy)) { IObservableProperty observableProperty = observableFactory.CreateObservableProperty(typeof(T)); if (item != null) { observableProperty.OverwriteFrom(item, true); } propertyProxy = proxyFactory.Create(observableProperty); } foreach (var subscriber in subscribers) { propertyProxy.Subscribe(subscriber); } return(proxyWrapper.WrapPropertyObservable <T>(propertyProxy)); }
private void Initialize() { var observedProperties = ObservableProperty.GetObservedProperties(); var observedCollections = ObservableProperty.GetObservedCollections(); foreach (var observedProperty in observedProperties) { IObservableProperty observableProperty = observedProperty.Value; runtimeProxies[observedProperty.Key] = (IRuntimeProxy)RuntimeProxyManagerHelper.CreateRuntimeManager(observableProperty, null, IsReadOnly).Implementation; } foreach (var observedCollection in observedCollections) { collectionProxies[observedCollection.Key] = CollectionProxy.Create( observedCollection.Value, proxyWrapper, proxyFactory, observableFactory); } }
public ITargetProxy CreateProxy(object target, BindingDescription description) { if (target == null || !(target is ILuaExtendable)) { return(null); } LuaTable metatable = (target as ILuaExtendable).GetMetatable(); if (metatable == null || !metatable.ContainsKey(description.TargetName)) { return(null); } var obj = metatable.Get <object>(description.TargetName); if (obj != null) { LuaFunction function = obj as LuaFunction; if (function != null) { return(new LuaMethodTargetProxy(target, function)); } IObservableProperty observableValue = obj as IObservableProperty; if (observableValue != null) { return(new ObservableTargetProxy(target, observableValue)); } IInteractionAction interactionAction = obj as IInteractionAction; if (interactionAction != null) { return(new InteractionTargetProxy(target, interactionAction)); } } return(new LuaTableTargetProxy(target, description.TargetName)); }
public MainViewModel() { this.text = ObservablePropertyFactory.Instance.CreateProperty(string.Empty); Random r = new Random(); this.calculated = ObservablePropertyFactory.Instance.CreateCancellableAsyncCalculatedPropertyWithContext( r, this.text, TimeSpan.FromSeconds(0.1), async (helper, context, text) => { int millisecondsToWait = context.Next(5000); await Task.Delay(millisecondsToWait, helper.Token).ConfigureAwait(false); await helper.CheckCancellationTokenAndYield().ConfigureAwait(false); return Tuple.Create(text + " [CALCULATED]", millisecondsToWait); }); this.calculatedText = ObservablePropertyFactory.Instance.CreateCalculatedProperty( this.calculated, calculated => calculated.Switch(v => v == null ? null : v.Item1, e => "[ERROR]")); this.calculatedTime = ObservablePropertyFactory.Instance.CreateCalculatedProperty( this.calculated, calculated => calculated.Switch(v => v == null ? 0 : v.Item2, e => -1)); }
private void ProfilesManager_OnPropertyUpdatedEvent(short key, IObservableProperty property) { if (key == (short)ObservablePropertiyCodes.DisplayName) { DisplayName = $"Name: {property.Serialize()}"; } else if (key == (short)ObservablePropertiyCodes.Avatar) { LoadAvatarImage(property.Serialize()); } else if (key == (short)ObservablePropertiyCodes.Level) { Level = $"Level: {property.CastTo<ObservableFloat>().GetValue().ToString("F2")}"; } else if (key == (short)ObservablePropertiyCodes.XP) { XP = $"XP: {property.CastTo<ObservableFloat>().GetValue().ToString("F2")}"; } else if (key == (short)ObservablePropertiyCodes.Gold) { Gold = $"Gold: {property.CastTo<ObservableFloat>().GetValue().ToString("F2")}"; } }
private void ProfilesManager_OnPropertyUpdatedEvent(short key, IObservableProperty property) { if (key == (short)ObservablePropertiyCodes.DisplayName) { DisplayName = property.CastTo <ObservableString>().GetValue(); } else if (key == (short)ObservablePropertiyCodes.Avatar) { LoadAvatarImage(property.Serialize()); } else if (key == (short)ObservablePropertiyCodes.Bronze) { Bronze = property.CastTo <ObservableFloat>().GetValue().ToString("F2"); } else if (key == (short)ObservablePropertiyCodes.Silver) { Silver = property.CastTo <ObservableFloat>().GetValue().ToString("F2"); } else if (key == (short)ObservablePropertiyCodes.Gold) { Gold = property.CastTo <ObservableFloat>().GetValue().ToString("F2"); } }
/// <summary> /// /// </summary> /// <param name="property"></param> protected override void OnDirtyPropertyEventHandler(IObservableProperty property) { base.OnDirtyPropertyEventHandler(property); OnModifiedInServerEvent?.Invoke(this); }
public SynchObservableAction(Action oxBodyAction, IObservableProperty <bool> isAllowedObservable, string commandName) : base(oxBodyAction, isAllowedObservable.GetValue, commandName) { _oxBodyAction = oxBodyAction; _Cached_IsExecutingPropertyDescription = PropertyDescription.FromExpression <ISynchAction, bool>(x => x.IsExecuting); }
private void OnPropertyUpdatedEventHandler(short key, IObservableProperty property) { OnPropertyUpdatedEvent?.Invoke(key, property); }
internal static void ValueAccessed(IObservableProperty observableProperty) { observableProperty.IsAccessed = true; if (BeingComputed.Count > 0) BeingComputed.Peek()(new PropertyAccessNotification(observableProperty)); observableProperty.IsAccessed = false; }
public CalculatorViewModel(bool supportsAsync) { this.updateInRealTimeItems = ObservablePropertyFactory.Instance.CreateReadOnlyProperty( ObservableCollectionFactory.Instance.CreateObservableCollection(new[] { true, false })); this.updateInRealTimeSelection = ObservablePropertyFactory.Instance.CreateProperty<bool?>(true); this.updateInRealTime = ObservablePropertyFactory.Instance.CreateCalculatedProperty( this.updateInRealTimeSelection, updateInRealTimeSelection => updateInRealTimeSelection.HasValue && updateInRealTimeSelection.Value); this.supportsAsync = ObservablePropertyFactory.Instance.CreateReadOnlyProperty(supportsAsync); this.simulateLatencyItems = ObservablePropertyFactory.Instance.CreateReadOnlyProperty( ObservableCollectionFactory.Instance.CreateObservableCollection(new[] { true, false })); this.simulateLatencySelection = ObservablePropertyFactory.Instance.CreateProperty<bool?>(true); this.simulateLatency = ObservablePropertyFactory.Instance.CreateCalculatedProperty( this.simulateLatencySelection, simulateLatencySelection => simulateLatencySelection.HasValue && simulateLatencySelection.Value); this.operators = ObservablePropertyFactory.Instance.CreateReadOnlyProperty( ObservableCollectionFactory.Instance.CreateObservableCollection( new[] { Operator.Add, Operator.Subtract, Operator.Multiply, Operator.Divide })); this.showMultiply = ObservablePropertyFactory.Instance.CreateCalculatedProperty( this.operators.MergeCollectionPropertyWithChanges(this.operators), c => c.Collection.Contains(Operator.Multiply)); this.showDivide = ObservablePropertyFactory.Instance.CreateCalculatedProperty( this.operators.MergeCollectionPropertyWithChanges(this.operators), c => c.Collection.Contains(Operator.Divide)); this.operand1 = ObservablePropertyFactory.Instance.CreateProperty<string>(null); this.selectedOperator = ObservablePropertyFactory.Instance.CreateProperty(Operator.Add); this.selectedOperatorString = ObservablePropertyFactory.Instance.CreateCalculatedProperty( this.selectedOperator, selectedOperator => { switch (selectedOperator) { case Operator.Add: return "+"; case Operator.Subtract: return "-"; case Operator.Multiply: return "*"; case Operator.Divide: return "/"; default: throw new NotSupportedException( "Unknown enumeration value " + selectedOperator + "."); } }); this.operand2 = ObservablePropertyFactory.Instance.CreateProperty<string>(null); this.result = ObservablePropertyFactory.Instance.CreateCalculatedProperty( this.Operand1, this.Operand2, this.SelectedOperator, (operand1, operand2, selectedOperator) => { Func<double?, double?, double?> function; switch (selectedOperator) { case Operator.Add: function = (x, y) => x + y; break; case Operator.Subtract: function = (x, y) => x - y; break; case Operator.Multiply: function = (x, y) => x * y; break; case Operator.Divide: function = (x, y) => x / y; break; default: throw new NotSupportedException("Unknown enumeration value " + selectedOperator + "."); } double operand1Value; double.TryParse(operand1, out operand1Value); double operand2Value; double.TryParse(operand2, out operand2Value); double? r = function(operand1Value, operand2Value); return r == null ? null : r.ToString(); }); }
/// <summary> /// Unbind this binding /// </summary> public virtual void Unbind() { IsBound = false; _modelProperty = null; }
///// <summary> ///// Constructor ///// </summary> ///// <param name="sourceView">The View that will own this binding.</param> ///// <param name="modelMemberName">The member of the ViewModel.</param> //protected Binding(ViewBase sourceView, string modelMemberName) //{ // Source = sourceView; // ModelMemberName = modelMemberName; //} /// <summary> /// Set-up the binding. This should almost always be implemented in a deriving class. /// </summary> public virtual void Bind() { IsBound = true; _modelProperty = null; }