/// <summary>
/// Is state of the object changed.
/// </summary>
/// <typeparam name="T">object type</typeparam>
/// <param name="tracking">object which implements change tracking</param>
/// <returns>is object changed</returns>
public static bool IsChanged <T>(this IChangeTracking <T> tracking)
{
var original = tracking.GetOriginalValue();
return(original == null ||
tracking.Equals(original));
}
public void AcceptChanges()
{
IntPtr ptr;
Bid.ScopeEnter(out ptr, "<ds.DataRow.AcceptChanges|API> %d#\n", this.ObjectID);
try
{
this.EndEdit();
if (((this.RowState != DataRowState.Detached) && (this.RowState != DataRowState.Deleted)) && (this._columns.ColumnsImplementingIChangeTrackingCount > 0))
{
foreach (DataColumn column in this._columns.ColumnsImplementingIChangeTracking)
{
object obj2 = this[column];
if (DBNull.Value != obj2)
{
IChangeTracking tracking = (IChangeTracking)obj2;
if (tracking.IsChanged)
{
tracking.AcceptChanges();
}
}
}
}
this._table.CommitRow(this);
}
finally
{
Bid.ScopeLeave(ref ptr);
}
}
public void RejectChanges()
{
IntPtr ptr;
Bid.ScopeEnter(out ptr, "<ds.DataRow.RejectChanges|API> %d#\n", this.ObjectID);
try
{
if (this.RowState != DataRowState.Detached)
{
if (this._columns.ColumnsImplementingIChangeTrackingCount != this._columns.ColumnsImplementingIRevertibleChangeTrackingCount)
{
foreach (DataColumn column in this._columns.ColumnsImplementingIChangeTracking)
{
if (!column.ImplementsIRevertibleChangeTracking)
{
object obj3 = null;
if (this.RowState != DataRowState.Deleted)
{
obj3 = this[column];
}
else
{
obj3 = this[column, DataRowVersion.Original];
}
if ((DBNull.Value != obj3) && ((IChangeTracking)obj3).IsChanged)
{
throw ExceptionBuilder.UDTImplementsIChangeTrackingButnotIRevertible(column.DataType.AssemblyQualifiedName);
}
}
}
}
foreach (DataColumn column2 in this._columns.ColumnsImplementingIChangeTracking)
{
object obj2 = null;
if (this.RowState != DataRowState.Deleted)
{
obj2 = this[column2];
}
else
{
obj2 = this[column2, DataRowVersion.Original];
}
if (DBNull.Value != obj2)
{
IChangeTracking tracking = (IChangeTracking)obj2;
if (tracking.IsChanged)
{
((IRevertibleChangeTracking)obj2).RejectChanges();
}
}
}
}
this._table.RollbackRow(this);
}
finally
{
Bid.ScopeLeave(ref ptr);
}
}
public void Remove(IChangeTracking trackedObject)
{
if (_changedObjects.Contains(trackedObject))
{
_changedObjects.Remove(trackedObject);
RaiseHasChangesPropertyChanged();
}
}
internal static void TrackChanges(this IChangeTracking self, string name, object value)
{
if (name != SystemFields.IsChanged && self.GetPropertyInternal(SystemFields.Shapshot) != Value.Undefined)
{
var shapshot = (IMixin)self.GetPropertyInternal(SystemFields.Shapshot);
var isChanged = !self.EqualsByValue(shapshot);
self.SetProperty(SystemFields.IsChanged, isChanged);
}
}
static void TrackUpdate(IChangeTracking track)
{
if (track == null)
{
return;
}
track.LastModifiedOn = DateTime.Now;
track.LastModifiedBy = GetUserID();
}
public void Add(IChangeTracking changedObject)
{
if (!changedObject.IsChanged)
{
throw new ArgumentOutOfRangeException("changedObject", "An unchanged object shall be registered for the change tracking service.");
}
if (!_changedObjects.Contains(changedObject))
{
_changedObjects.Add(changedObject);
RaiseHasChangesPropertyChanged();
}
}
/// <summary>
/// Sets the value of the component to a different value.
/// </summary>
/// <param name="component">The component with the property value that is to be set.</param>
/// <param name="value">The new value.</param>
public override void SetValue(object component, object value)
{
// Validate new value
ValidateValue(this._name, value);
// Get new value as string
string stringValue = GetStringFromValue(value);
// "UserDefined" property expose comma separated user defined properties
CustomProperties customAttr = component as CustomProperties;
if (this._name == "UserDefined")
{
customAttr.SetUserDefinedAttributes(stringValue);
}
else
{
// Check if the new value is the same as DefaultValue
bool setAttributeValue = true;
if (IsDefaultValue(stringValue))
{
// Remove custom properties with default values from data point
// only when series do not have this attribute set.
if (!(customAttr.DataPointCustomProperties is DataPoint) ||
!((DataPoint)customAttr.DataPointCustomProperties).series.IsCustomPropertySet(this._name))
{
// Delete attribute
if (customAttr.DataPointCustomProperties.IsCustomPropertySet(this._name))
{
customAttr.DataPointCustomProperties.DeleteCustomProperty(this._name);
setAttributeValue = false;
}
}
}
// Set custom attribute value
if (setAttributeValue)
{
customAttr.DataPointCustomProperties[this._name] = stringValue;
}
}
customAttr.DataPointCustomProperties.CustomProperties = customAttr.DataPointCustomProperties.CustomProperties;
IChangeTracking changeTracking = component as IChangeTracking;
if (changeTracking != null)
{
changeTracking.AcceptChanges();
}
}
public static void SystemComponentModel_Interfaces_LoadedSuccessfully()
{
IRevertibleChangeTracking iRevertibleChangeTracking = null;
IChangeTracking iChangeTracking = iRevertibleChangeTracking;
Assert.Null(iChangeTracking);
IEditableObject iEditableObject = null;
Assert.Null(iEditableObject);
IServiceProvider iServiceProvider = null;
Assert.Null(iServiceProvider);
}
public async Task CommitTrackedChangesAsync(SyncRelationship relationship)
{
foreach (KeyValuePair <int, AnalyzeAdapterResult> adapterResult in AdapterResults)
{
if (adapterResult.Value.TrackedChanges != null)
{
AdapterBase adapterBase =
relationship.Adapters.First(a => a.Configuration.Id == adapterResult.Key);
Logger.Info("Committing tracked change for adapter {0}", adapterBase.Configuration.Id);
IChangeTracking changeTracking = (IChangeTracking)adapterBase;
await changeTracking.CommitChangesAsync(adapterResult.Value.TrackedChanges).ConfigureAwait(false);
}
}
}
public static void TestComponentModelBasic()
{
// dummy tests to make sure the System.ComponentModel library loaded successfully
#pragma warning disable 0219
IRevertibleChangeTracking iRevertibleChangeTracking = null;
IChangeTracking iChangeTracking = iRevertibleChangeTracking;
Assert.Null(iChangeTracking);
IEditableObject iEditableObject = null;
CancelEventArgs cancelEventArgs = new CancelEventArgs();
Assert.NotNull(cancelEventArgs);
IServiceProvider iServiceProvider = null;
Assert.Null(iServiceProvider);
#pragma warning restore 0219
}
private void ShowConfirmationMessage(SelectionChangedEventArgs e, IChangeTracking viewModel, object mainViewModel = null)
{
var result = MessageBox.Show("You have unsaved changes. Do you want to continue?", "Unsaved changes", MessageBoxButton.YesNo);
if (result == MessageBoxResult.No)
{
e.Handled = true;
}
else
{
if (mainViewModel != null)
{
DisposePreviousViewModelReferences(mainViewModel);
}
viewModel.AcceptChanges();
}
}
private void ComboBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
var comboBox = sender as ComboBox;
var comboBoxItem = comboBox?.SelectedItem as ComboBoxItem;
var culture = comboBoxItem?.Content?.ToString();
if (culture != null)
{
Thread.CurrentThread.CurrentCulture = new CultureInfo(culture);
Thread.CurrentThread.CurrentUICulture = new CultureInfo(culture);
IChangeTracking changeable = DataContext as IChangeTracking;
if (changeable.IsChanged)
{
if (DataContext is IValidatable validatable)
{
validatable.Validate();
}
}
}
}
public static void AcceptChanges(this IChangeTracking self)
{
self.EndEdit();
}
public void ListenChanged(IChangeTracking other)
{
other.OnChange += ReportChange;
}
public static void RejectChanges(this IChangeTracking self)
{
self.CancelEdit();
}
protected void Init(IOutlineSettings settings)
{
_settings = settings;
_changeTracking = settings as IChangeTracking;
}
protected void Init(IOutlineSettingsEx settings)
{
_settings = settings;
_changeTracking = settings as IChangeTracking;
base.Init(settings);
}