public void SetsValuesCorrectlyForNullPropertyName()
{
var iniEntry = new IniEntry();
var nullEventArgs = new AdvancedPropertyChangedEventArgs(iniEntry, (string) null);
Assert.AreEqual(null, nullEventArgs.PropertyName);
}
public void SetsValuesCorrectlyForEmptyPropertyName()
{
var iniEntry = new IniEntry();
var nullEventArgs = new AdvancedPropertyChangedEventArgs(iniEntry, string.Empty);
Assert.AreEqual(string.Empty, nullEventArgs.PropertyName);
}
/// <summary>
/// Raises the <see cref="PropertyChanged"/> event.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="propertyName">Name of the property.</param>
/// <param name="oldValue">The old value.</param>
/// <param name="newValue">The new value.</param>
protected internal void RaisePropertyChanged(object sender, string propertyName, object oldValue, object newValue)
{
// This is 1 of the 3 places where the AdvancedPropertyChangedEventArgs are created
var eventArgs = new AdvancedPropertyChangedEventArgs(sender, propertyName, oldValue, newValue);
RaisePropertyChanged(sender, eventArgs);
}
/// <summary>
/// Raises the <see cref="PropertyChanged"/> event.
/// <para />
/// This is the one and only method that actually raises the <see cref="PropertyChanged"/> event. All other
/// methods are (and should be) just overloads that eventually call this method.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="System.ComponentModel.PropertyChangedEventArgs"/> instance containing the event data.</param>
protected virtual void RaisePropertyChanged(object sender, AdvancedPropertyChangedEventArgs e)
{
PropertyChanged.SafeInvoke(sender, e);
if (ReferenceEquals(this, sender))
{
OnPropertyChanged(e);
}
}
public void SetsValuesCorrectlyWithTwoArguments()
{
var iniEntry = new IniEntry();
var iniFile = new IniFile();
var originalEventArgs = new AdvancedPropertyChangedEventArgs(iniEntry, "PropertyName");
var eventArgs = new AdvancedPropertyChangedEventArgs(iniFile, originalEventArgs);
Assert.AreEqual(iniEntry, eventArgs.OriginalSender);
Assert.AreEqual(iniFile, eventArgs.LatestSender);
Assert.AreEqual("PropertyName", eventArgs.PropertyName);
}
public void SetsValuesCorrectlyWithTheeArgumentsExceptOldValue()
{
IniEntry iniEntry = new IniEntry();
var eventArgs = new AdvancedPropertyChangedEventArgs(iniEntry, "PropertyName", (object) "new value");
Assert.AreEqual(iniEntry, eventArgs.OriginalSender);
Assert.AreEqual(iniEntry, eventArgs.LatestSender);
Assert.AreEqual("PropertyName", eventArgs.PropertyName);
Assert.AreEqual(null, eventArgs.OldValue);
Assert.AreEqual("new value", eventArgs.NewValue);
Assert.AreEqual(false, eventArgs.IsOldValueMeaningful);
Assert.AreEqual(true, eventArgs.IsNewValueMeaningful);
}
public void SetsValuesCorrectlyWithAllARguments()
{
var iniEntry = new IniEntry();
var eventArgs = new AdvancedPropertyChangedEventArgs(iniEntry, "PropertyName", (object) "old value", "new value");
Assert.AreEqual(iniEntry, eventArgs.OriginalSender);
Assert.AreEqual(iniEntry, eventArgs.LatestSender);
Assert.AreEqual("PropertyName", eventArgs.PropertyName);
Assert.AreEqual("old value", eventArgs.OldValue);
Assert.AreEqual("new value", eventArgs.NewValue);
Assert.AreEqual(true, eventArgs.IsOldValueMeaningful);
Assert.AreEqual(true, eventArgs.IsNewValueMeaningful);
}
private void OnPinMaskedChanged(Catel.Data.AdvancedPropertyChangedEventArgs args)
{
var oldValue = this.Pin;
var newValue = this.PinMasked;
if ((oldValue.Length + 1) == newValue.Length)
{
var change = this.RemoveInvalidChars(newValue.Substring(oldValue.Length, 1));
this.Pin += change;
this.PinMasked = new string(Enumerable.Repeat('*', this.Pin.Length).ToArray());
}
else if (oldValue.Length > newValue.Length)
{
this.Pin = this.Pin.Substring(0, newValue.Length);
this.PinMasked = new string(Enumerable.Repeat('*', this.Pin.Length).ToArray());
}
}
private void OnNewPasswordConfirmedMaskedChanged(Catel.Data.AdvancedPropertyChangedEventArgs args)
{
var oldValue = args.OldValue as string;
var newValue = args.NewValue as string;
if (((oldValue ?? string.Empty).Length + 1) == ((newValue ?? string.Empty).Length))
{
var change = (newValue ?? string.Empty).Substring((oldValue ?? string.Empty).Length, 1);
NewPasswordConfirmed += change;
NewPasswordConfirmedMasked = NewPasswordConfirmedMasked.Replace(change, "*");
}
else if ((oldValue ?? string.Empty).Length > (newValue ?? string.Empty).Length)
{
NewPasswordConfirmed = NewPasswordConfirmed.Substring(0, (newValue ?? string.Empty).Length);
NewPasswordConfirmedMasked = NewPasswordConfirmedMasked.Substring(0, (newValue ?? string.Empty).Length);
}
}
/// <summary>
/// Raises the <see cref="E:PropertyChanged" /> event.
/// </summary>
/// <param name="e">The <see cref="AdvancedPropertyChangedEventArgs"/> instance containing the event data.</param>
protected override void OnPropertyChanged(AdvancedPropertyChangedEventArgs e)
{
base.OnPropertyChanged(e);
var propertyName = e.PropertyName;
if (!string.IsNullOrWhiteSpace(propertyName))
{
if (PropertiesNotCausingValidation.TryGetValue(GetType(), out HashSet <string> ignoredProperties))
{
if (ignoredProperties.Contains(propertyName))
{
return;
}
}
}
_isValidated = false;
if (AutomaticallyValidateOnPropertyChanged)
{
if (!string.IsNullOrWhiteSpace(propertyName))
{
lock (_propertiesCurrentlyBeingValidated)
{
if (_propertiesCurrentlyBeingValidated.Contains(propertyName))
{
return;
}
}
ValidatePropertyUsingAnnotations(propertyName);
}
Validate();
}
}
protected override void OnPropertyChanged(AdvancedPropertyChangedEventArgs e)
{
base.OnPropertyChanged(e);
if (e.HasPropertyChanged(() => SelectedSpanType) || e.HasPropertyChanged(() => Amount))
{
switch (SelectedSpanType)
{
case TimeSpanType.Years:
Value = TimeSpan.FromDays(Amount * AverageDaysInYear);
break;
case TimeSpanType.Months:
Value = TimeSpan.FromDays(Amount * AverageDaysInMonth);
break;
case TimeSpanType.Days:
Value = TimeSpan.FromDays(Amount);
break;
case TimeSpanType.Hours:
Value = TimeSpan.FromHours(Amount);
break;
case TimeSpanType.Minutes:
Value = TimeSpan.FromMinutes(Amount);
break;
case TimeSpanType.Seconds:
Value = TimeSpan.FromSeconds(Amount);
break;
default:
throw new NotSupportedException(string.Format("Type '{0}' is not supported.", SelectedSpanType));
}
}
}
/// <summary>
/// Invoked when a property value has changed.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="PropertyChangedEventArgs"/> instance containing the event data.</param>
/// <param name="setDirtyAndAllowAutomaticValidation">if set to <c>true</c>, the <see cref="IsDirty"/> property is set and automatic validation is allowed.</param>
/// <param name="isRefreshCallOnly">if set to <c>true</c>, the call is only to refresh updates (for example, for the IDataErrorInfo
/// implementation). If this value is <c>false</c>, the custom change handlers will not be called.</param>
private void RaisePropertyChanged(object sender, PropertyChangedEventArgs e, bool setDirtyAndAllowAutomaticValidation, bool isRefreshCallOnly)
{
if (string.IsNullOrEmpty(e.PropertyName))
{
if (!DisablePropertyChangeNotifications)
{
// Call & exit, we can't handle "update them all" property change notifications
base.RaisePropertyChanged(this, new AdvancedPropertyChangedEventArgs(sender, e.PropertyName));
}
return;
}
// If this is an internal data object base property, just leave
if (IsModelBaseProperty(e.PropertyName))
{
var senderAsModelBase = sender as ModelBase;
if ((senderAsModelBase != null) && (string.Equals(e.PropertyName, IsDirtyProperty.Name, StringComparison.Ordinal)))
{
// Maybe this is a child object informing us that it's not dirty any longer
if (senderAsModelBase.GetValue <bool>(e.PropertyName) == false)
{
if (!ReferenceEquals(this, sender))
{
// Ignore
return;
}
}
// A child became dirty, we are dirty as well
if (!ReferenceEquals(this, sender))
{
IsDirty = true;
}
else
{
if (!DisablePropertyChangeNotifications)
{
// Explicitly call base because we have overridden the behavior
var eventArgs = new AdvancedPropertyChangedEventArgs(sender, this, e.PropertyName);
base.RaisePropertyChanged(this, eventArgs);
}
}
return;
}
}
if (HandlePropertyAndCollectionChanges)
{
if (ReferenceEquals(this, sender))
{
AdvancedPropertyChangedEventArgs eventArgs;
var advancedEventArgs = e as AdvancedPropertyChangedEventArgs;
if (advancedEventArgs != null)
{
eventArgs = new AdvancedPropertyChangedEventArgs(this, advancedEventArgs);
}
else
{
eventArgs = new AdvancedPropertyChangedEventArgs(sender, this, e.PropertyName);
}
if (!isRefreshCallOnly)
{
if (IsPropertyRegistered(e.PropertyName))
{
var propertyData = GetPropertyData(e.PropertyName);
if (propertyData.PropertyChangedEventHandler != null)
{
propertyData.PropertyChangedEventHandler(this, eventArgs);
}
}
}
if (!DisablePropertyChangeNotifications)
{
// Explicitly call base because we have overridden the behavior
base.RaisePropertyChanged(this, eventArgs);
}
}
}
SetDirtyAndAutomaticallyValidate(e.PropertyName, setDirtyAndAllowAutomaticValidation);
}
/// <summary>
/// Raises the <see cref="INotifyPropertyChanged.PropertyChanged"/> event.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="System.ComponentModel.PropertyChangedEventArgs"/> instance containing the event data.</param>
/// <remarks>
/// This method is overriden en does not call the base because lots of additional logic is added in this class. The
/// <see cref="RaisePropertyChanged(object,System.ComponentModel.PropertyChangedEventArgs,bool,bool)"/> will explicitly call
/// <see cref="ObservableObject.RaisePropertyChanged(object, AdvancedPropertyChangedEventArgs)"/>.
/// <para />
/// If this method is overriden, it is very important to call the base.
/// </remarks>
protected override void RaisePropertyChanged(object sender, AdvancedPropertyChangedEventArgs e)
{
RaisePropertyChanged(sender, e, true, false);
}
/// <summary>
/// Invoked when a property value has changed.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="PropertyChangedEventArgs"/> instance containing the event data.</param>
/// <param name="setDirtyAndAllowAutomaticValidation">if set to <c>true</c>, the <see cref="IsDirty"/> property is set and automatic validation is allowed.</param>
/// <param name="isRefreshCallOnly">if set to <c>true</c>, the call is only to refresh updates (for example, for the IDataErrorInfo
/// implementation). If this value is <c>false</c>, the custom change handlers will not be called.</param>
private void RaisePropertyChanged(object sender, PropertyChangedEventArgs e, bool setDirtyAndAllowAutomaticValidation, bool isRefreshCallOnly)
{
if (string.IsNullOrEmpty(e.PropertyName))
{
if (!DisablePropertyChangeNotifications)
{
// Call & exit, we can't handle "update them all" property change notifications
base.RaisePropertyChanged(this, new AdvancedPropertyChangedEventArgs(sender, e.PropertyName));
}
return;
}
// If this is an internal data object base property, just leave
if (IsModelBaseProperty(e.PropertyName))
{
var senderAsModelBase = sender as ModelBase;
if ((senderAsModelBase != null) && (string.Equals(e.PropertyName, IsDirtyProperty.Name, StringComparison.Ordinal)))
{
// Maybe this is a child object informing us that it's not dirty any longer
if (senderAsModelBase.GetValue<bool>(e.PropertyName) == false)
{
if (!ReferenceEquals(this, sender))
{
// Ignore
return;
}
}
// A child became dirty, we are dirty as well
if (!ReferenceEquals(this, sender))
{
IsDirty = true;
}
else
{
if (!DisablePropertyChangeNotifications)
{
// Explicitly call base because we have overridden the behavior
var eventArgs = new AdvancedPropertyChangedEventArgs(sender, this, e.PropertyName);
base.RaisePropertyChanged(this, eventArgs);
}
}
return;
}
}
if (HandlePropertyAndCollectionChanges)
{
if (ReferenceEquals(this, sender))
{
AdvancedPropertyChangedEventArgs eventArgs;
var advancedEventArgs = e as AdvancedPropertyChangedEventArgs;
if (advancedEventArgs != null)
{
eventArgs = new AdvancedPropertyChangedEventArgs(this, advancedEventArgs);
}
else
{
eventArgs = new AdvancedPropertyChangedEventArgs(sender, this, e.PropertyName);
}
if (!isRefreshCallOnly)
{
if (IsPropertyRegistered(e.PropertyName))
{
var propertyData = GetPropertyData(e.PropertyName);
if (propertyData.PropertyChangedEventHandler != null)
{
propertyData.PropertyChangedEventHandler(this, eventArgs);
}
}
}
if (!DisablePropertyChangeNotifications)
{
// Explicitly call base because we have overridden the behavior
base.RaisePropertyChanged(this, eventArgs);
}
}
}
SetDirtyAndAutomaticallyValidate(e.PropertyName, setDirtyAndAllowAutomaticValidation);
}
/// <summary>
/// Initializes a new instance of the <see cref="AdvancedPropertyChangedEventArgs"/>"/> class.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="Catel.Data.AdvancedPropertyChangedEventArgs"/>"/> instance containing the event data.</param>
public AdvancedPropertyChangedEventArgs(object sender, AdvancedPropertyChangedEventArgs e)
: this(e.OriginalSender, sender, e.PropertyName, e.OldValue, e.NewValue, e.IsOldValueMeaningful, e.IsNewValueMeaningful)
{
}
public void CanAutomaticallyDetectNewValue()
{
var iniEntry = new IniEntry();
iniEntry.Key = "mykey";
var eventArgs = new AdvancedPropertyChangedEventArgs(iniEntry, "Key");
Assert.AreEqual(iniEntry, eventArgs.OriginalSender);
Assert.AreEqual(iniEntry, eventArgs.LatestSender);
Assert.AreEqual("Key", eventArgs.PropertyName);
Assert.AreEqual(null, eventArgs.OldValue);
Assert.AreEqual("mykey", eventArgs.NewValue);
Assert.AreEqual(false, eventArgs.IsOldValueMeaningful);
Assert.AreEqual(true, eventArgs.IsNewValueMeaningful);
}
/// <summary>
/// Raises the <see cref="ObservableObject.PropertyChanged"/> event.
/// <para/>
/// This is the one and only method that actually raises the <see cref="ObservableObject.PropertyChanged"/> event. All other
/// methods are (and should be) just overloads that eventually call this method.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="System.ComponentModel.PropertyChangedEventArgs"/> instance containing the event data.</param>
protected override void RaisePropertyChanged(object sender, AdvancedPropertyChangedEventArgs e)
{
_dispatcherService.BeginInvokeIfRequired(() => base.RaisePropertyChanged(sender, e));
}
protected override void OnPropertyChanged(AdvancedPropertyChangedEventArgs e)
{
base.OnPropertyChanged(e);
if (e.PropertyName == "MainScript")
{
this.HasChanges = true;
}
}
/// <summary>
/// Occurs when the value of the Person property is changed.
/// </summary>
/// <param name="e">
/// The event argument
/// </param>
private void OnPersonChanged(AdvancedPropertyChangedEventArgs e)
{
}
protected override void OnPropertyChanged(AdvancedPropertyChangedEventArgs e)
{
base.OnPropertyChanged(e);
RaiseUpdated();
}
public void SetsValuesCorrectlyWithPropertyNameOnly()
{
var iniEntry = new IniEntry();
var iniFile = new IniFile();
var eventArgs = new AdvancedPropertyChangedEventArgs(iniEntry, iniFile, "PropertyName");
Assert.AreEqual(iniEntry, eventArgs.OriginalSender);
Assert.AreEqual(iniFile, eventArgs.LatestSender);
Assert.AreEqual("PropertyName", eventArgs.PropertyName);
Assert.AreEqual(null, eventArgs.OldValue);
Assert.AreEqual(null, eventArgs.NewValue);
Assert.AreEqual(false, eventArgs.IsOldValueMeaningful);
Assert.AreEqual(false, eventArgs.IsNewValueMeaningful);
}
/// <summary>
/// Initializes a new instance of the <see cref="AdvancedPropertyChangedEventArgs"/>"/> class.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="Catel.Data.AdvancedPropertyChangedEventArgs"/>"/> instance containing the event data.</param>
public AdvancedPropertyChangedEventArgs(object sender, AdvancedPropertyChangedEventArgs e)
: this(e.OriginalSender, sender, e.PropertyName, e.OldValue, e.NewValue, e.IsOldValueMeaningful, e.IsNewValueMeaningful) { }
/// <summary>
/// Invoked when a property value has changed.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="PropertyChangedEventArgs"/> instance containing the event data.</param>
/// <param name="updateIsDirty">if set to <c>true</c>, the <see cref="IsDirty"/> property is set and automatic validation is allowed.</param>
/// <param name="isRefreshCallOnly">if set to <c>true</c>, the call is only to refresh updates (for example, for the IDataErrorInfo
/// implementation). If this value is <c>false</c>, the custom change handlers will not be called.</param>
protected void RaisePropertyChanged(object sender, PropertyChangedEventArgs e, bool updateIsDirty, bool isRefreshCallOnly)
{
if (string.IsNullOrEmpty(e.PropertyName))
{
if (!DisablePropertyChangeNotifications)
{
// Call & exit, we can't handle "update them all" property change notifications
base.RaisePropertyChanged(this, new AdvancedPropertyChangedEventArgs(sender, e.PropertyName));
}
return;
}
// If this is an internal data object base property, just leave
if (IsModelBaseProperty(e.PropertyName))
{
var senderAsModelBase = sender as ModelBase;
if ((senderAsModelBase != null) && (string.Equals(e.PropertyName, IsDirtyProperty.Name, StringComparison.Ordinal)))
{
// Maybe this is a child object informing us that it's not dirty any longer
if (!senderAsModelBase.GetValue <bool>(e.PropertyName) && !ReferenceEquals(this, sender))
{
// Ignore
return;
}
// A child became dirty, we are dirty as well
if (!ReferenceEquals(this, sender))
{
IsDirty = true;
}
else
{
if (!DisablePropertyChangeNotifications)
{
// Explicitly call base because we have overridden the behavior
var eventArgs = new AdvancedPropertyChangedEventArgs(sender, this, e.PropertyName);
base.RaisePropertyChanged(this, eventArgs);
}
}
return;
}
}
if (ReferenceEquals(this, sender))
{
AdvancedPropertyChangedEventArgs eventArgs;
var advancedEventArgs = e as AdvancedPropertyChangedEventArgs;
if (advancedEventArgs != null)
{
eventArgs = new AdvancedPropertyChangedEventArgs(this, advancedEventArgs);
}
else
{
eventArgs = new AdvancedPropertyChangedEventArgs(sender, this, e.PropertyName);
}
if (!isRefreshCallOnly)
{
SuspensionContext callbackSuspensionContext;
lock (_lock)
{
callbackSuspensionContext = _changeCallbacksSuspensionContext;
}
if (callbackSuspensionContext != null)
{
callbackSuspensionContext.Add(e.PropertyName);
}
else if (IsPropertyRegistered(e.PropertyName))
{
var propertyData = GetPropertyData(e.PropertyName);
var handler = propertyData.PropertyChangedEventHandler;
if (handler != null)
{
handler(this, eventArgs);
}
}
}
if (!DisablePropertyChangeNotifications)
{
// Explicitly call base because we have overridden the behavior
base.RaisePropertyChanged(this, eventArgs);
}
}
if (updateIsDirty)
{
SetDirty(e.PropertyName);
}
}
/// <summary>
/// Called when the <see cref="PropertyChanged"/> event occurs.
/// </summary>
/// <param name="e">The <see cref="AdvancedPropertyChangedEventArgs"/> instance containing the event data.</param>
protected virtual void OnPropertyChanged(AdvancedPropertyChangedEventArgs e)
{
}
/// <summary>
/// Raises the <see cref="INotifyPropertyChanged.PropertyChanged"/> event.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="System.ComponentModel.PropertyChangedEventArgs"/> instance containing the event data.</param>
/// <remarks>
/// This method is overriden en does not call the base because lots of additional logic is added in this class. The
/// <see cref="RaisePropertyChanged(object,System.ComponentModel.PropertyChangedEventArgs,bool,bool)"/> will explicitly call
/// <see cref="ObservableObject.RaisePropertyChanged(object, AdvancedPropertyChangedEventArgs)"/>.
/// <para />
/// If this method is overriden, it is very important to call the base.
/// </remarks>
protected override void RaisePropertyChanged(object sender, AdvancedPropertyChangedEventArgs e)
{
RaisePropertyChanged(sender, e, true, false);
}
/// <summary>
/// Raises the <see cref="ObservableObject.PropertyChanged"/> event.
/// <para/>
/// This is the one and only method that actually raises the <see cref="ObservableObject.PropertyChanged"/> event. All other
/// methods are (and should be) just overloads that eventually call this method.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="System.ComponentModel.PropertyChangedEventArgs"/> instance containing the event data.</param>
protected override void RaisePropertyChanged(object sender, AdvancedPropertyChangedEventArgs e)
{
_dispatcherService.BeginInvokeIfRequired(() => base.RaisePropertyChanged(sender, e));
}
/// <summary>
/// Raises the <see cref="ObservableObject.PropertyChanged"/> event.
/// <para/>
/// This is the one and only method that actually raises the <see cref="ObservableObject.PropertyChanged"/> event. All other
/// methods are (and should be) just overloads that eventually call this method.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="System.ComponentModel.PropertyChangedEventArgs"/> instance containing the event data.</param>
protected override void RaisePropertyChanged(object sender, AdvancedPropertyChangedEventArgs e)
{
if (_isThrottlingEnabled && !_isHandlingThrottlingNotifications)
{
lock (_throttlingLockObject)
{
_throttlingQueue[e.PropertyName] = DateTime.Now;
}
return;
}
if (DispatchPropertyChangedEvent)
{
_dispatcherService.BeginInvokeIfRequired(() => base.RaisePropertyChanged(sender, e));
}
else
{
base.RaisePropertyChanged(sender, e);
}
}
/// <summary>
/// Raises the <see cref="PropertyChanged"/> event without allowing classes to override this behavior.
/// <para />
/// This is the one and only method that actually raises the <see cref="PropertyChanged"/> event. All other
/// methods are (and should be) just overloads that eventually call this method.
/// <para />
/// Note that this method does not call <see cref="OnPropertyChanged(AdvancedPropertyChangedEventArgs)"/>. Use
/// <see cref="RaisePropertyChanged(object, AdvancedPropertyChangedEventArgs)"/> if that is required.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="System.ComponentModel.PropertyChangedEventArgs"/> instance containing the event data.</param>
protected void RaisePropertyChangedDirect(object sender, AdvancedPropertyChangedEventArgs e)
{
PropertyChanged?.Invoke(sender, e);
}