/// <summary>
/// Initializes a new instance of the <see cref="ObjectObserver"/> class.
/// </summary>
/// <param name="propertyChanged">The property changed.</param>
/// <param name="tag">The tag.</param>
/// <param name="mementoService">The memento service. If <c>null</c>, the service will be retrieved from the <see cref="IServiceLocator"/>.</param>
/// <exception cref="ArgumentNullException">The <paramref name="propertyChanged"/> is <c>null</c>.</exception>
public ObjectObserver(INotifyPropertyChanged propertyChanged, object tag = null, IMementoService mementoService = null)
: base(tag, mementoService)
{
Argument.IsNotNull("propertyChanged", propertyChanged);
Log.Debug("Initializing ObjectObserver for type '{0}'", propertyChanged.GetType().Name);
_weakEventListener = this.SubscribeToWeakPropertyChangedEvent(propertyChanged, OnPropertyChanged);
InitializeDefaultValues(propertyChanged);
Log.Debug("Initialized ObjectObserver for type '{0}'", propertyChanged.GetType().Name);
}
public void BindViewModel(INotifyPropertyChanged viewModel, BrowserBridge browser)
{
ViewModelDefinition definition = GetViewModelDefinition(viewModel.GetType());
if (definition == null)
{
definition = new ViewModelDefinition(viewModel.GetType(), viewModel.GetType().Name);
StringBuilder sb = new StringBuilder();
List<ViewModelDefinition> allDefs = new List<ViewModelDefinition>();
definition.CollectViewModelDefinitions(allDefs);
foreach (ViewModelDefinition child in allDefs)
child.DefineInBrowser(sb);
InjectFramework(sb);
browser.InsertScript(sb.ToString());
}
}
public ValidationTemplate(INotifyPropertyChanged target)
{
this.target = target;
validator = GetValidator(target.GetType());
validationResult = validator.Validate(target);
target.PropertyChanged += Validate;
}
public ValidationTemplate(INotifyPropertyChanged target)
{
this.target = target;
validator = GetValidator(target.GetType());
validationResult = validator.Validate(target);
target.PropertyChanged += Validate;
}
public NotifyPropertyChangedSnapshot(DirtyModelDetector modelDetector, INotifyPropertyChanged snapshotValue)
: base(modelDetector, snapshotValue)
{
if (snapshotValue == null)
{
throw new ArgumentNullException("snapshotValue");
}
foreach (var propertyInfo in snapshotValue.GetType().GetProperties(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public))
{
var getMethod = propertyInfo.GetGetMethod();
if (getMethod != null && getMethod.GetParameters().Any())
{
continue;
}
var attributes = propertyInfo.GetCustomAttributes(typeof(IsSerialized), true);
if (attributes.Length <= 0)
{
continue;
}
var snapshot = SnaphotFactory.Create(modelDetector, propertyInfo.GetValue(snapshotValue, null));
var keyValuePair = new KeyValuePair<PropertyInfo, SnapshotElement>(propertyInfo, snapshot);
_propertiesSnapshots.Add(propertyInfo.Name, keyValuePair);
}
_listenedNotifyPropertyChanged = snapshotValue;
_listenedNotifyPropertyChanged.PropertyChanged += OnPropertyChanged;
}
/// <summary>
/// Locates the dialog type representing the specified view model in a user interface.
/// </summary>
/// <param name="viewModel">The view model to find the dialog type for.</param>
/// <returns>
/// The dialog type representing the specified view model in a user interface.
/// </returns>
internal static Type LocateDialogType(INotifyPropertyChanged viewModel)
{
if (viewModel == null)
throw new ArgumentNullException("viewModel");
Type viewModelType = viewModel.GetType();
Type dialogType = Cache.Get(viewModelType);
if (dialogType != null)
{
return dialogType;
}
string dialogName = GetDialogName(viewModelType);
string dialogAssemblyName = GetAssemblyFullName(viewModelType);
string dialogFullName = "{0}, {1}".InvariantFormat(
dialogName,
dialogAssemblyName);
dialogType = Type.GetType(dialogFullName);
if (dialogType == null)
throw new Exception(Resources.DialogTypeMissing.CurrentFormat(dialogFullName));
Cache.Add(viewModelType, dialogType);
return dialogType;
}
/// <summary>
/// Asserts that property changed is called for the specified property when the value of the property is set
/// to the specified value.
/// </summary>
/// <param name="observableObject">The object that will be observed.</param>
/// <param name="propertyName">The name of the property that will be observed.</param>
/// <param name="value">The value to which the property should be set.</param>
/// <param name="isRaised">Determines wether property changed should be called or not.</param>
private static void PropertyChangedIsCalled(
INotifyPropertyChanged observableObject,
string propertyName,
object value,
bool isRaised)
{
var propertyFound = false;
var propertyChangedCalled = false;
observableObject.PropertyChanged += (sender, args) =>
{
if (args.PropertyName == propertyName)
{
propertyChangedCalled = true;
}
};
var properties = observableObject.GetType().GetProperties();
foreach (var propertyInfo in properties)
{
if (propertyInfo.Name == propertyName)
{
propertyInfo.SetValue(observableObject, value, null);
propertyFound = true;
break;
}
}
Assert.IsTrue(
propertyFound,
string.Format("The property {0} could not be found on object {1}.", propertyName, observableObject));
Assert.AreEqual(isRaised, propertyChangedCalled);
}
public static void Notify <TMember>(
this INotifyPropertyChanged sender,
PropertyChangedEventHandler handler,
Expression <Func <TMember> > expression)
{
if (sender is null)
{
throw new ArgumentNullException("sender");
}
if (expression is null)
{
throw new ArgumentNullException("expression");
}
var body = expression.Body as MemberExpression;
if (body is null)
{
throw new ArgumentException("The expression must target a property or field.", "expression");
}
var propertyName = GetPropertyName(body, sender.GetType());
NotifyCore(sender, handler, propertyName);
}
public MenuItemViewModel(string nameKey, INotifyPropertyChanged nameSource, ICommand command, INotifyPropertyChanged commandParameterSource, string commandParameterName)
: this("name", new ObservableCollection<IMenuItemViewModel>())
{
m_nameKey = nameKey;
m_nameSource = nameSource;
m_command = command;
m_commandParameterSource = commandParameterSource;
m_commandParameterName = commandParameterName;
if (m_commandParameterSource != null && m_commandParameterName != null)
{
m_commandPropertyInfo = m_commandParameterSource.GetType().GetProperty(m_commandParameterName);
if (m_commandPropertyInfo != null)
{
m_commandParameter = m_commandPropertyInfo.GetValue(m_commandParameterSource);
m_commandParameterSource.PropertyChanged += CommandParameterSourceOnPropertyChanged;
}
}
if (nameSource != null && nameKey != null)
{
m_namePropertyInfo = nameSource.GetType().GetProperty(nameKey);
if (m_namePropertyInfo != null)
{
m_name = m_namePropertyInfo.GetValue(nameSource) as string;
nameSource.PropertyChanged += NameSourceOnPropertyChanged;
}
}
}
/// <summary>
/// Clears the property binding.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="target">The target.</param>
/// <param name="sourceProp">The source prop.</param>
/// <param name="targetProp">The target prop.</param>
public static void ClearPropertyBinding(Object source, INotifyPropertyChanged target, string sourceProp, string targetProp)
{
WeakEntry entry = new WeakEntry(source.GetType(), target.GetType(), sourceProp, targetProp);
Delegate setAction = GetExpressionAction(entry, source, true);
WeakSource.UnRegister(source, setAction, targetProp);
}
internal NotifyPropertyChangedRecordedElement(IUndoRedoService undoRedoService, INotifyPropertyChanged objAsNotifyPropertyChanged)
: base(objAsNotifyPropertyChanged)
{
if (undoRedoService == null) { throw new ArgumentNullException("undoRedoService"); }
if (objAsNotifyPropertyChanged == null) { throw new ArgumentNullException("objAsNotifyPropertyChanged"); }
_objAsNotifyPropertyChanged = objAsNotifyPropertyChanged;
_objAsNotifyPropertyChanged.PropertyChanged += OnPropertyChanged;
foreach (var propertyInfo in objAsNotifyPropertyChanged.GetType().GetProperties(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public))
{
var getMethod = propertyInfo.GetGetMethod();
if (getMethod != null && getMethod.GetParameters().Any())
{
continue;
}
var attributes = propertyInfo.GetCustomAttributes(typeof(IsRecordableAttribute), true);
if (attributes.Length <= 0)
{
continue;
}
var property = PropertyFactory.Create(undoRedoService, objAsNotifyPropertyChanged, (IsRecordableAttribute)attributes[0], propertyInfo);
_properties.Add(property.Name, property);
}
}
public PropertyBoundCommand(CommandExecute execute, INotifyPropertyChanged boundTo, string propertyName)
{
if (execute == null)
throw new ArgumentNullException("execute");
this.execute = execute;
if (boundTo == null)
throw new ArgumentNullException("boundTo");
this.boundTo = boundTo;
property = boundTo.GetType().GetProperty(propertyName);
if (property == null)
throw new ArgumentException("Bad propertyName");
if (property.PropertyType != typeof(bool))
throw new ArgumentException("Bad property type");
propertyGetMethod = property.GetGetMethod();
if (propertyGetMethod == null)
throw new ArgumentException("No public get-method found.");
this.propertyName = propertyName;
boundTo.PropertyChanged += new PropertyChangedEventHandler(boundTo_PropertyChanged);
}
public static void TestNotifyPropertyChanged(INotifyPropertyChanged obj, string propertyName, object newValue)
{
List <string> actualProperties = new List <string>();
obj.PropertyChanged += (s, e) => actualProperties.Add(e.PropertyName);
// Test for change
obj.GetType().GetProperty(propertyName).SetValue(obj, newValue);
CollectionAssert.Contains(actualProperties, propertyName, "Event call");
Assert.AreEqual(newValue, obj.GetType().GetProperty(propertyName).GetValue(obj), "Property change");
// Test for no change
actualProperties.Clear();
obj.GetType().GetProperty(propertyName).SetValue(obj, newValue);
CollectionAssert.DoesNotContain(actualProperties, propertyName, "No event call");
Assert.AreEqual(newValue, obj.GetType().GetProperty(propertyName).GetValue(obj), "No property change");
}
public static void RaisePropertyChanged(this INotifyPropertyChanged @this, [CallerMemberName] string propertyName = null)
{
var declaringType = @this.GetType().GetEvent(nameof(INotifyPropertyChanged.PropertyChanged)).DeclaringType;
var propertyChangedFieldInfo = declaringType.GetField(nameof(INotifyPropertyChanged.PropertyChanged), BindingFlags.Instance | BindingFlags.NonPublic);
var propertyChangedEventHandler = propertyChangedFieldInfo.GetValue(@this) as PropertyChangedEventHandler;
propertyChangedEventHandler?.Invoke(@this, new PropertyChangedEventArgs(propertyName));
}
internal Resetter(INotifyPropertyChanged settings)
: base(settings)
{
_type = settings.GetType();
var constructor = _type.GetConstructor(Type.EmptyTypes);
_defaultSettings = constructor.Invoke(new object[0]);
}
public InstanceInspector(INotifyPropertyChanged inpc)
{
_type = inpc.GetType();
var properties = GetAllProperties(inpc);
Properties.AddRange(properties.Select(pi => new PropertyInspector(pi, inpc)));
}
/// <summary>
/// Prefer other overloads with x => x.PropertyName for refactor friendliness.
/// This is faster though.
/// </summary>
/// <param name="source"> The source instance to track changes for. </param>
/// <param name="propertyName"> The name of the property to track. Note that nested properties are not allowed. </param>
/// <param name="signalInitial"> If true OnNext is called immediately on subscribe. </param>
public static IObservable <EventPattern <PropertyChangedEventArgs> > ObservePropertyChanged(
this INotifyPropertyChanged source,
string propertyName,
bool signalInitial = true)
{
Ensure.NotNull(source, nameof(source));
Ensure.NotNullOrEmpty(propertyName, nameof(propertyName));
if (source.GetType().GetProperty(propertyName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) == null)
{
throw new ArgumentException($"The type {source.GetType()} does not have a property named {propertyName}", propertyName);
}
return(ObservePropertyChangedCore(
source,
propertyName,
(sender, args) => new EventPattern <PropertyChangedEventArgs>(sender, args),
signalInitial));
}
public ChangeTracker(INotifyPropertyChanged source, PropertiesSettings settings)
{
Ensure.NotNull(source, nameof(source));
Ensure.NotNull(settings, nameof(settings));
Track.Verify.CanTrackType(source.GetType(), settings);
this.Settings = settings;
this.node = ChangeTrackerNode.GetOrCreate(source, settings, true);
this.node.Value.Changed += this.OnNodeChange;
}
/// <summary>
/// Get properties which have the <see cref="BlockingPropertyAttribute"/>
/// </summary>
/// <param name="self">Class instance that contains the properties</param>
/// <returns>Collection of Properties that are decorated with the attribute</returns>
private static IEnumerable <PropertyInfo> GetBlockingProperties(this INotifyPropertyChanged self)
{
var properties = self
.GetType()
.GetProperties(BindingFlags.Instance | BindingFlags.Public)
.Where(t => t.GetCustomAttributes(typeof(BlockingPropertyAttribute), false).Length > 0).ToList();
return(properties);
}
public Type Locate(INotifyPropertyChanged viewModel)
{
if (viewModel.GetType() == typeof(ChildViewModel))
{
return(typeof(ChildWindow));
}
throw new ArgumentException("Unrecognised view model", nameof(viewModel));
}
public TwoColumnViewModel(string name, INotifyPropertyChanged attachObject, string property, string format = "", string unit = "")
{
Name = name;
_format = format;
_unit = unit;
_attachObject = attachObject;
_attachProperty = attachObject.GetType().GetProperty(property);
_attachObject.PropertyChanged += _attachObject_PropertyChanged;
}
ValueNudgerFactory NameAssociationNonFactory(INotifyPropertyChanged container, string propertyName, string description)
{
var containerType = container.GetType();
var property = containerType.GetProperty(propertyName + "Nudger");
var nudgerOb = property.GetValue(container);
var nudger = (IValueNudger)nudgerOb;
return(() => nudger);
}
public ChildChangeListener(INotifyPropertyChanged instance)
{
Requires.NotNull(instance, "instance");
m_value = instance;
m_type = m_value.GetType();
Subscribe();
}
public static void AssertRaisesPropertyChangedFor(this INotifyPropertyChanged obj, string propertyName, object propertyValue)
{
using (PropertyChangedEventListener listener = new PropertyChangedEventListener(obj, propertyName))
{
Type MainType = obj.GetType();
PropertyInfo info = MainType.GetProperty(propertyName);
info.SetValue(obj, propertyValue, null);
}
}
public ChangeTracker(INotifyPropertyChanged source, PropertiesSettings settings)
{
Ensure.NotNull(source, nameof(source));
Ensure.NotNull(settings, nameof(settings));
Track.Verify.CanTrackType(source.GetType(), settings);
this.Settings = settings;
this.node = ChangeTrackerNode.GetOrCreate(source, settings, true);
this.node.Value.Changed += this.OnNodeChange;
}
public ObservableSource(INotifyPropertyChanged itRaisesPropChanged, string pathElement, PathConnectorTypeEnum pathConnectorType, string binderName)
: this(pathElement, pathConnectorType, false, binderName)
{
SourceKind = SourceKindEnum.PropertyObject;
Data = itRaisesPropChanged ?? throw new ArgumentNullException($"{nameof(itRaisesPropChanged)} was null when constructing Observable Source.");
Type = itRaisesPropChanged.GetType();
Status = ObservableSourceStatusEnum.Ready;
}
public ValidationTemplate([NotNull] INotifyPropertyChanged target)
{
this.target = target;
validator = GetValidator(target.GetType());
var context = new ValidationContext <object>(target);
validationResult = validator.Validate(context);
target.PropertyChanged += Validate;
}
/// <summary>
/// Sets the property binding.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="target">The target.</param>
/// <param name="sourceProp">The source prop.</param>
/// <param name="targetProp">The target prop.</param>
/// <param name="notify">if set to <c>true</c> update immediately.</param>
/// <param name="converter">The converter.</param>
/// <param name="parameter">The converter parameter.</param>
public static void SetPropertyBinding(Object source, INotifyPropertyChanged target, string sourceProp, string targetProp, bool notify = true, IDataConverter converter = null, object parameter = null)
{
WeakEntry entry = new WeakEntry(source.GetType(), target.GetType(), sourceProp, targetProp);
Delegate setAction = GetExpressionAction(entry, source, true, converter);
WeakSource wSource = WeakSource.Register(source, target, setAction, targetProp, converter, parameter);
if (notify)
{
wSource.NotifyPropertyChanged(target, targetProp);
}
}
protected virtual void Trigger(INotifyPropertyChanged inpc, PropertyInfo prop)
{
foreach (var handler in inpc.GetType()
.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
.Where(f => f.FieldType == typeof(PropertyChangedEventHandler))
.Select(f => (PropertyChangedEventHandler)f.GetValue(inpc)).Where(x => x != null))
{
handler(inpc, new PropertyChangedEventArgs(prop.Name));
}
}
/// <summary>
/// Detaches the event source.
/// </summary>
/// <param name="item">The item to detach.</param>
protected void DetachEventSource([NotNull] INotifyPropertyChanged item)
{
var sourceType = item.GetType();
if (EventSources.TryGetValue(sourceType, out var oldListener) && oldListener.TryGetTarget(out var target))
{
target.PropertyChanged -= RelaySource_PropertyChanged;
EventSources.Remove(sourceType);
}
}
/// <summary> Invokes the specified handler when a property on a property changes, or when the source changes,
/// and, if the current value differs from the specified default value, at the end of this call. </summary>
/// <param name="propertyName"> The name of the property on the source. </param>
/// <param name="propertyOnPropertyName"> The name of the property on the property on the source. </param>
/// <param name="handler"> The handler to be invoked at the moments listed above. </param>
/// <param name="defaultValue"> The value that is the default of the property on the property (used as old value when the property containing that property is null).
/// For value types, you can specify null to indicate the default of the value type. </param>
public static void Bind(this INotifyPropertyChanged source, string propertyName, string propertyOnPropertyName, PropertyChangedEventHandler handler, object defaultValue)
{
Contract.Requires(source != null);
Contract.Requires(source.GetType().GetProperty(propertyName) != null);
var sourcePropertyType = source.GetType().GetProperty(propertyName).PropertyType;
Type propertyOnPropertyType = GetPropertyType(sourcePropertyType, propertyOnPropertyName);
if (ReferenceEquals(defaultValue, null))
{
defaultValue = propertyOnPropertyType.GetDefault();
}
else
{
Contract.Requires(propertyOnPropertyType.IsInstanceOfType(defaultValue));
}
Bind(source, propertyName, propertyOnPropertyName, handler, defaultValue, propertyOnPropertyType);
}
public static void VerifyPropertyNamesOnChange(this INotifyPropertyChanged element)
{
Contract.Requires(element != null);
var myType = element.GetType();
element.PropertyChanged += (sender, args) =>
{
Util.ThrowUnless <InvalidOperationException>(myType.HasPublicInstanceProperty(args.PropertyName), "The object '{0}' of type '{1}' raised a property change for '{2}' which isn't a public property on the type.".DoFormat(element, myType, args.PropertyName));
};
}
public POCOBinding(INotifyPropertyChanged source, string sourcePropertyName, INotifyPropertyChanged target, string targetPropertyName)
{
_source = source;
_sourceProperty = source.GetType().GetProperty(sourcePropertyName);
_target = target;
_targetProperty = target.GetType().GetProperty(targetPropertyName);
_source.PropertyChanged += SourcePropertyChanged;
_target.PropertyChanged += TargetPropertyChanged;
}
public BindableSource(INotifyPropertyChanged source, string propertyName, BindingMode mode)
{
_source = source;
_propertyInfo = _source.GetType().GetProperty(propertyName);
if (mode == BindingMode.TwoWay || mode == BindingMode.OneWay)
{
_source.PropertyChanged += SourceOnPropertyChanged;
}
}
NotifyPropertyChangedKVOHelper(INotifyPropertyChanged anObject)
{
TargetObject = anObject;
TargetObject.PropertyChanged += PropertyDidChange;
if (typeof(INotifyPropertyChanging).IsAssignableFrom(anObject.GetType())) {
targetSupportsPropertyChanging = true;
((INotifyPropertyChanging)anObject).PropertyChanging += PropertyWillChange;
}
}
/// <summary>
/// Detaches the event source.
/// </summary>
/// <param name="item">The item to detach.</param>
protected void DetachEventSource([NotNull] INotifyPropertyChanged item)
{
var sourceType = item.GetType();
if (EventSources.TryGetValue(sourceType, out var oldListern))
{
oldListern?.Detach();
EventSources.Remove(sourceType);
}
}
/// <summary>
/// This raises the INotifyPropertyChanged.PropertyChanged event to indicate
/// a specific property has changed value.
/// </summary>
/// <param name="eh">Event Handler</param>
/// <param name="name">Primary property</param>
/// <param name="sender">Sender</param>
public static void RaisePropertyChanged(this INotifyPropertyChanged sender, PropertyChangedEventHandler eh, [CallerMemberName] string name = null)
{
Debug.Assert(!string.IsNullOrEmpty(name) &&
sender.GetType().GetTypeInfo().GetDeclaredProperty(name) != null);
if (sender != null && eh != null)
{
Invoke(eh, sender, new PropertyChangedEventArgs(name));
}
}
/// <summary>
/// 특정 뷰모델에다 Dalog 타입을 위치시키는 메서드
/// </summary>
/// <param name="viewModel"></param>
/// <returns></returns>
public Type Locate(INotifyPropertyChanged viewModel)
{
Type viewModelType = viewModel.GetType();
string dialogFullName = viewModelType.FullName;
dialogFullName = dialogFullName.Substring(0, dialogFullName.Length - "Model".Length);
return(viewModelType.Assembly.GetType(dialogFullName));
}
public StubView(INotifyPropertyChanged viewModel)
{
viewModel.PropertyChanged += Collect;
foreach (var commandProperty in viewModel.GetType().GetProperties().Where(prop => typeof(ICommand).IsAssignableFrom(prop.PropertyType)))
{
var command = (ICommand)commandProperty.GetValue(viewModel);
command.CanExecuteChanged += (sender, e) => CommandCanExecuteChangedNotifications.Add(commandProperty.Name);
}
}
public ValidationTemplate(INotifyPropertyChanged target)
{
_target = target;
_validator = GetValidator(target.GetType());
if (_validator != null)
{
_validationResult = _validator.Validate(target);
target.PropertyChanged += Validate;
}
}
private IAsyncOperation <ContentDialogResult> ShowContentDialogAsync(
INotifyPropertyChanged viewModel,
Type contentDialogType)
{
Logger.Write($"Content dialog: {contentDialogType}; View model: {viewModel.GetType()}");
IContentDialog dialog = CreateContentDialog(contentDialogType, viewModel);
return(dialog.ShowAsync());
}
public static IObservable <PropertyChangedEventArgs> ObservePropertyChangedSlim(this INotifyPropertyChanged source, string name, bool signalInitial = true)
{
Ensure.NotNull(source, nameof(source));
Ensure.NotNullOrEmpty(name, "name");
if (source.GetType().GetProperty(name) == null)
{
throw new ArgumentException($"The type {source.GetType()} does not have a property named {name}", name);
}
var observable = source.ObservePropertyChangedSlim()
.Where(e => IsPropertyName(e, name));
if (signalInitial)
{
observable = observable.StartWith(new PropertyChangedEventArgs(name));
}
return(observable);
}
/// <summary>
/// Sets the property binding.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="target">The target.</param>
/// <param name="sourceProp">The source prop.</param>
/// <param name="targetProp">The target prop.</param>
/// <param name="notify">if set to <c>true</c> update immediately.</param>
/// <param name="converter">The converter.</param>
/// <param name="parameter">The converter parameter.</param>
public static void SetPropertyBinding(Object source, INotifyPropertyChanged target, string sourceProp, string targetProp, bool notify = true, IDataConverter converter = null, object parameter = null)
{
WeakEntry entry = new WeakEntry(source.GetType(), target.GetType(), sourceProp, targetProp);
Delegate setAction = GetExpressionAction(entry, source, true, converter);
WeakSource wSource = WeakSource.Register(source, target, setAction, targetProp, converter, parameter);
if (notify)
{
wSource.NotifyPropertyChanged(target, targetProp);
}
}
private void Show(
INotifyPropertyChanged ownerViewModel,
INotifyPropertyChanged viewModel,
Type dialogType)
{
Logger.Write($"Dialog: {dialogType}; View model: {viewModel.GetType()}; Owner: {ownerViewModel.GetType()}");
IWindow dialog = CreateDialog(dialogType, ownerViewModel, viewModel);
dialog.Show();
}
private static void GetHandlerField(INotifyPropertyChanged changed, out CacheItem[] handlerFields)
{
handlerFields = null;
var type = changed.GetType();
Func<object, object> instanceGetter;
if (cached.ContainsKey(type)) {
handlerFields = cached[type];
}
else {
var result = new List<CacheItem>();
while (type != null) {
var handlerField = type.GetField("PropertyChanged", BindingFlags.Instance | BindingFlags.NonPublic);
if (handlerField != null) {
result.Add(new CacheItem(handlerField, x => x));
}
else {
var field = type.GetFields(BindingFlags.Instance | BindingFlags.NonPublic).FirstOrDefault(f => f.FieldType.Name == "TrackableEntityAttribute");
if (field != null) {
var value = field.GetValue(changed);
if (value != null) {
handlerField = value.GetType().GetField("PropertyChanged", BindingFlags.Instance | BindingFlags.NonPublic);
if (handlerField != null)
{
result.Add(new CacheItem(handlerField, field, (x, ifield) => ifield.GetValue(x)));
}
}
}
}
type = type.BaseType;
}
Debug.Assert(result.Count() > 0);
handlerFields = result.ToArray();
lock (cacheLock) {
if (!cached.ContainsKey(changed.GetType()))
cached[changed.GetType()] = handlerFields;
}
}
}
public InvokeMethodCommand(INotifyPropertyChanged target, MethodInfo method, params object[] parameters)
{
if (method == null)
throw new ArgumentException($"Method on {target} not found!");
Target = target;
Method = method;
Parameters = parameters;
target.PropertyChanged += Target_PropertyChanged;
CanExecutePropertyName = $"Can{method.Name}";
CanExecuteProperty = Target.GetType().GetProperty(CanExecutePropertyName);
}
public MakeObjectReactiveHelper(INotifyPropertyChanged hostObject)
{
var hostChanging = hostObject as INotifyPropertyChanging;
if (hostChanging != null) {
hostChanging.PropertyChanging += (o, e) => _Changing.OnNext(
new ObservedChange<object, object>() { Sender = o, PropertyName = e.PropertyName });
} else {
this.Log().Error("'{0}' does not implement INotifyPropertyChanging - RxUI may return duplicate change notifications",
hostObject.GetType().FullName);
}
hostObject.PropertyChanged += (o, e) => _Changed.OnNext(
new ObservedChange<object, object>() { Sender = o, PropertyName = e.PropertyName });
}
private void AssignAllCommands(INotifyPropertyChanged viewModel)
{
var viewModelType = viewModel.GetType();
var commands =
viewModelType
.GetProperties(BindingFlags.Instance | BindingFlags.Public)
.Where(property =>
property.PropertyType.EqualsOrSubclassOf<ICommand>() &&
property.GetValue(viewModel, null) == null)
.ToList();
var errors = commands.SelectMany(property => AssignCommand(viewModel, property)).ToList();
if (!errors.Any())
{
return;
}
errors.Insert(0, "Issues found on type {0}:".NamedFormat(viewModel.GetType().Name));
var message = errors.JoinMultiLine();
new InvalidOperationException(message).Throw();
}
/// <summary>
/// Initializes a new instance of the <see cref="ObjectObserver"/> class.
/// </summary>
/// <param name="propertyChanged">The property changed.</param>
/// <param name="tag">The tag.</param>
/// <param name="mementoService">The memento service. If <c>null</c>, the service will be retrieved from the <see cref="IServiceLocator"/>.</param>
/// <exception cref="ArgumentNullException">The <paramref name="propertyChanged"/> is <c>null</c>.</exception>
public ObjectObserver(INotifyPropertyChanged propertyChanged, object tag = null, IMementoService mementoService = null)
: base(tag, mementoService)
{
Argument.IsNotNull("propertyChanged", propertyChanged);
var propertyChangedType = propertyChanged.GetType();
Log.Debug("Initializing ObjectObserver for type '{0}'", propertyChangedType.Name);
_object = propertyChanged;
_object.PropertyChanged += OnPropertyChanged;
InitializeDefaultValues(propertyChanged);
Log.Debug("Initialized ObjectObserver for type '{0}'", propertyChangedType.Name);
}
public MenuItemViewModel(string name, ICommand command, INotifyPropertyChanged commandParameterSource = null, string commandParameterName= null)
: this(name, new ObservableCollection<IMenuItemViewModel>())
{
m_command = command;
m_commandParameterSource = commandParameterSource;
m_commandParameterName = commandParameterName;
if (m_commandParameterSource != null && m_commandParameterName != null)
{
m_commandPropertyInfo = m_commandParameterSource.GetType().GetProperty(m_commandParameterName);
if (m_commandPropertyInfo != null)
{
m_commandParameter = m_commandPropertyInfo.GetValue(m_commandParameterSource);
m_commandParameterSource.PropertyChanged += CommandParameterSourceOnPropertyChanged;
}
}
}
public static IDisposable BindPropertyToObject(
INotifyPropertyChanged source,
string propertyName,
object target,
Action<object, object> setTargetValue,
Func<object, IObservable<object>> createTargetObservable,
Func<object> getInitialValue,
Func<object, object> getCurrentValue)
{
var propertyObs = source.ObservableForProperty(new string[] { propertyName });
propertyObs.Subscribe(e => {
setTargetValue(target, e.Value);
});
var targetObs = createTargetObservable(target);
var propertySetter = source.GetType().GetProperty(propertyName).GetSetMethod();
return Observable.Return(getInitialValue()).Concat(targetObs).Subscribe(e => {
propertySetter.Invoke(source, new object[] { getCurrentValue(target) });
});
}
static void SetupPropertyChanged(IList<object> closed, INotifyPropertyChanged component, ChangeOccuredHandler changedHandler)
{
if (closed.Contains(component)) return; // event was already registered
closed.Add(component); //adds the property that is to be processed
//sets the property changed event if the property isn't a collection
if (!(component is INotifyCollectionChanged))
component.PropertyChanged += (sender, e) => changedHandler(sender, e.PropertyName);
/*
* If the component is an enumerable there are two steps. First check to see if it supports the INotifyCollectionChanged event.
* If it supports it add and handler on to this object to support notification. Next iterate through the collection of objects
* to add hook up their PropertyChangedEvent.
*
* If the component isn't a collection then iterate through its properties and attach the changed handler to the properties.
*/
if (component is IEnumerable<object>)
{
if (component is INotifyCollectionChanged)
{
//((INotifyCollectionChanged)component).CollectionChanged += collectionHandler;
((INotifyCollectionChanged)component).CollectionChanged += (sender, e) => changedHandler(sender, "collection");
}
foreach (object obj in component as IEnumerable<object>)
{
if (obj is INotifyPropertyChanged)
SetupPropertyChanged(closed, (INotifyPropertyChanged)obj, changedHandler);
}
}
else
{
foreach (PropertyInfo info in component.GetType().GetProperties())
{
var propertyValue = info.GetValue(component, new object[] { });
var inpc = propertyValue as INotifyPropertyChanged;
if (inpc == null) continue;
SetupPropertyChanged(closed, inpc, changedHandler);
}
}
}
public PropertyCollection GetProperties(INotifyPropertyChanged obj)
{
var visibleProperties =
from p in obj.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance)
where p.IsDefined(typeof(UIVisibleAttribute))
select p;
var collection = new PropertyCollection();
foreach (var item in visibleProperties)
{
var propertyValue = (PropertyValue)Activator.CreateInstance(
typeof(PropertyValue<>).MakeGenericType(item.PropertyType),
obj,
item);
collection.Items.Add(propertyValue);
}
return collection;
}
/// <summary>
/// Verifies that the provided object raised <see cref="INotifyPropertyChanged.PropertyChanged"/>
/// as a result of executing the given test code.
/// </summary>
/// <param name="object">The object which should raise the notification</param>
/// <param name="propertyName">The property name for which the notification should be raised</param>
/// <param name="testCode">The test code which should cause the notification to be raised</param>
/// <param name="expectedValue">The expected value of the property as the notification is raised</param>
/// <exception cref="PropertyChangedException">Thrown when the notification is not raised, or if
/// given property was not updated with expected value when notification was raised.</exception>
public static void PropertyChanged(INotifyPropertyChanged @object, string propertyName, Action testCode, object expectedValue = null)
{
Assert.GuardArgumentNotNull("object", @object);
Assert.GuardArgumentNotNull("testCode", testCode);
bool propertyChangeHappened = false;
object actualValue = null;
PropertyChangedEventHandler handler = (sender, args) =>
{
if (propertyName.Equals(args.PropertyName, StringComparison.OrdinalIgnoreCase))
{
propertyChangeHappened = true;
if (expectedValue != null)
{
actualValue = @object.GetType().GetRuntimeProperties().Single(property => property.Name.Equals(propertyName, StringComparison.OrdinalIgnoreCase)).GetValue(@object);
}
}
};
@object.PropertyChanged += handler;
try
{
testCode();
if (!propertyChangeHappened)
throw new PropertyChangedException(propertyName);
if (expectedValue != null && !expectedValue.Equals(actualValue))
throw new PropertyChangedException(propertyName, expectedValue);
}
finally
{
@object.PropertyChanged -= handler;
}
}
internal ViewModelInstance InstantiateInBrowser(INotifyPropertyChanged instance, BrowserBridge browser)
{
ViewModelInstance result = null;
viewModelInstancesByViewModel.TryGetValue(instance, out result);
if (result == null)
{
result = new ViewModelInstance(instance, GetViewModelDefinition(instance.GetType()), browser);
result.RefCount = 1;
viewModelInstancesById[result.Id] = result;
viewModelInstancesByViewModel[instance] = result;
result.InitializeProperties();
browser.ExecuteScriptFunction("handleViewModelCreated", instance.GetType().Name, result.Id.ToString("N"));
}
else
result.RefCount++;
return result;
}
public InvokeMethodCommand(INotifyPropertyChanged target, string method, params object[] parameters)
: this(target, target.GetType().GetMethod(method), parameters)
{
}
public ObjectPayload(Guid clientId, INotifyPropertyChanged sharedObject, Guid objectId, string objectName)
: base(objectName, objectId, clientId)
{
Type sharedObjectType = sharedObject.GetType();
#if IL2JS
this.Type = sharedObject.GetType().Name;
#else
this.Type = sharedObjectType.AssemblyQualifiedName;
#endif
this.Attributes = new SharedAttributes(sharedObjectType);
this.SharedProperties = new SharedPropertyDictionary(sharedObject.GetSharedProperties(clientId));
}
/// <summary>
/// Constructor with item</summary>
/// <param name="instance">Item whose property value change is listened to</param>
public ChildChangeListener(INotifyPropertyChanged instance)
{
Requires.NotNull(instance, "instance");
m_value = instance;
m_type = m_value.GetType();
Subscribe();
}
/// <summary>
/// Update the properties of the target object with the contents of the ObjectPayload
/// </summary>
/// <param name="target"></param>
/// <param name="data"></param>
private void UpdateProperties(INotifyPropertyChanged target, ObjectPayload data)
{
this.client.VerifyAccess();
Type targetType = target.GetType();
IJsObject jsDictionary = target as IJsObject;
if (jsDictionary != null)
{
// In case of JsObservableDictionary, we want to treat the properties in this payload as items of the dictionary
foreach (SharedProperty sharedProp in data.SharedProperties.Values)
{
jsDictionary[sharedProp.Name] = Json.ReadObject(DynamicTypeMapping.Instance.GetTypeFromValue(sharedProp.PropertyType), sharedProp.Value);
}
}
else
{
foreach (SharedProperty sharedProp in data.SharedProperties.Values)
{
Json.AssignProperty(target, sharedProp.Name, sharedProp.Value);
}
}
}
/// <summary>
/// Constructor used for outgoing codepaths
/// </summary>
/// <param name="client"></param>
/// <param name="name"></param>
/// <param name="id"></param>
/// <param name="obj"></param>
private ObjectEntry(SharedObjectsClient client, string name, Guid id, INotifyPropertyChanged obj)
{
this.client = client;
this.IgnoreChanges = false;
this.Object = obj;
this.Id = id;
this.Name = name ?? this.Id.ToString();
IJsObject jsObj = obj as IJsObject; // do this here so we only do the cast once
this.IsDynamic = jsObj != null;
this.Parents = new Dictionary<Guid, ParentEntry>();
this.Type = obj.GetType();
this.Attributes = new SharedAttributes(obj.GetType());
if(jsObj != null)
{
this.Properties = new SharedPropertyDictionary(jsObj.GetSharedProperties(this.client.ClientId));
}
else
{
this.Properties = new SharedPropertyDictionary(obj.GetSharedProperties(this.client.ClientId));
}
}
