public void RememberOldValues(object sender, NotifyCollectionChangingEventArgs e)
{
if (List != null)
{
throw new InvalidOperationException("Old value is already initialized");
}
List = (IList)sender;
Action = e.Action;
Index = e.Index;
switch(e.Action)
{
case NotifyCollectionChangeAction.Add:
break;
case NotifyCollectionChangeAction.Remove:
OldValue = e.Item;
break;
case NotifyCollectionChangeAction.Replace:
OldValue = List[e.Index]; // remember value being replaced
break;
}
}
public void OnCollectionChanging(object sender, NotifyCollectionChangingEventArgs e)
{
if (CollectionChanging == null)
{
var change = Instance as ICustomNotifyCollectionChange;
if (change != null)
change.FireCollectionChanging(sender, e);
return;
}
EditActionAttribute.BubbleIndentCounter++;
LogCollectionChanging(sender, e);
var previousSender = EventSettings.LastEventBubbler;
EventSettings.LastEventBubbler = Instance;
try
{
CollectionChanging(sender, e);
}
finally
{
EventSettings.LastEventBubbler = previousSender;
EditActionAttribute.BubbleIndentCounter--;
}
}
public void RememberNewValues(object list, NotifyCollectionChangingEventArgs e)
{
if (this.List != list)
{
throw new InvalidOperationException("Instance of the new value is not the same as for the old value");
}
if (NewValue != null)
{
throw new InvalidOperationException("New value is already initialized");
}
switch (e.Action)
{
case NotifyCollectionChangeAction.Add:
NewValue = e.Item;
break;
case NotifyCollectionChangeAction.Remove:
break;
case NotifyCollectionChangeAction.Replace:
if(e.Index != Index)
{
throw new NotImplementedException("Replace of element in collection with different index is not implemented yet.");
}
NewValue = e.Item;
break;
}
Filled = true;
}
private void LogCollectionChanging(object sender, NotifyCollectionChangingEventArgs e)
{
//if (EventSettings.EnableLogging)
{
var instance = Instance;
if (instance == sender)
Console.WriteLine(
EditActionAttribute.BubbleIndent +
"CollectionChanging >>> '{0}[{1}]', item:{2}, index:{3}, action:{4} - BEGIN >>>>>>>>>>>>>>",
instance, instance != null ? instance.GetType().Name : "null", e.Item, e.Index, e.Action);
else if (sender.GetType().Name.Contains("EventedList"))
{
var senderTypeName = sender.GetType().GetGenericArguments()[0].Name;
Console.WriteLine(
EditActionAttribute.BubbleIndent +
"CollectionChanging >>> '{0}[{1}]' -> '{5}[{6}]', item:{2}, index:{3}, action:{4}",
"EventedList", senderTypeName, e.Item, e.Index, e.Action, instance,
instance != null ? instance.GetType().Name : "null");
}
else
{
Console.WriteLine(
EditActionAttribute.BubbleIndent +
"CollectionChanging >>> '{0}[{1}]' -> '{5}[{6}]', item:{2}, index:{3}, action:{4}", sender,
sender.GetType().Name, e.Item, e.Index, e.Action, instance,
instance != null ? instance.GetType().Name : "null");
}
}
}
protected void LayersCollectionChanged(object sender, NotifyCollectionChangingEventArgs e)
{
// performance
if (!created || cloning)
{
return;
}
OnLayersCollectionChanged(e);
if(CollectionChanged != null)
{
CollectionChanged(sender, e);
}
}
private void OnLayersCollectionChanged(NotifyCollectionChangingEventArgs e)
{
switch (e.Action)
{
case NotifyCollectionChangeAction.Add: //set map property for layers being added
SetMapInLayer((ILayer) e.Item);
((ILayer) e.Item).RenderRequired = true;
break;
case NotifyCollectionChangeAction.Remove:
RenderRequired = true;//render the group if a layer got removed.
break;
case NotifyCollectionChangeAction.Replace:
throw new NotImplementedException();
}
}
private void NodeFeaturesCollectionChanging(object sender, NotifyCollectionChangingEventArgs e)
{
var nodeFeature = (INodeFeature) e.Item;
if (nodeFeature == null) return;
switch (e.Action)
{
case NotifyCollectionChangeAction.Replace:
throw new NotImplementedException();
case NotifyCollectionChangeAction.Remove:
Log.DebugFormat("Removed {0} from the node {1}", nodeFeature, this);
nodeFeature.Node = null;
break;
case NotifyCollectionChangeAction.Add:
nodeFeature.Node = this;
Log.DebugFormat("Added {0} to the node {1}", nodeFeature, this);
break;
}
}
/// <summary>
/// Listens for changes in reduce array and throws exception if reduction is
/// not possible for the given dimension
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void ReduceCollectionChanged(object sender, NotifyCollectionChangingEventArgs e)
{
UpdateRank();
//check whether reduced dimensions are bound by offsets
for (int i = 0; i < parent.Rank; i++)
{
if (Reduce[i])
{
bool isLimitedToOneIndex = OffsetEnd[i] == OffsetStart[i] || (SelectedIndexes[i] != null && SelectedIndexes[i].Length <= 1);
if (!isLimitedToOneIndex)
throw new InvalidOperationException("Reduction not possible because dimension " + i +
" is not bound to a single index");
}
}
}
private void BranchFeaturesOnCollectionChanged(object sender, NotifyCollectionChangingEventArgs e)
{
if (!Equals(sender, branchFeatures))
return;
var branchFeature = (IBranchFeature)e.Item;
switch (e.Action)
{
case NotifyCollectionChangeAction.Add:
branchFeature.Branch = this;
break;
}
}
private void DisconnectedCollectionChanged(object sender, NotifyCollectionChangingEventArgs e)
{
if (InEditAction())
{
if (lastCollectionChangeMemento == null ||
!(Equals(lastCollectionChangeMemento.List, sender) && lastCollectionChangeMemento.Index == e.Index))
{
// track actual changes in disconnected objects
handlingDisconnected = true;
ObservableCollectionChanged(sender, e);
handlingDisconnected = false;
}
else
{
// skip already handled event
lastCollectionChangeMemento = null;
}
}
}
private void LogCollectionChanged(NotifyCollectionChangeMemento memento, NotifyCollectionChangingEventArgs e)
{
if (!EventSettings.EnableLogging)
return;
if (InEditableObjectAction())
{
if (e.Action == NotifyCollectionChangeAction.Replace)
{
log.DebugFormat("adding collection change to edit action {0}: index:{1} {2} -> {3}", memento.Action,
memento.Index, memento.OldValue ?? "null", memento.NewValue ?? "null");
}
else
{
log.DebugFormat("adding collection change to edit action {0}: index:{1} {2}", memento.Action,
memento.Index, memento.NewValue ?? "null");
}
}
else
{
if (e.Action == NotifyCollectionChangeAction.Replace)
{
log.DebugFormat("saving undo for collection change {0}: index:{1} {2} -> {3}", memento.Action,
memento.Index, memento.OldValue ?? "null", memento.NewValue ?? "null");
}
else
{
log.DebugFormat("saving undo for collection change {0}: index: {1} {2}", memento.Action,
memento.Index, memento.NewValue ?? "null");
}
}
}
void LayersCollectionChanging(object sender, NotifyCollectionChangingEventArgs e)
{
// performance
if (!created || cloning)
{
return;
}
if (sender == layers) //only for own layer collection
{
CheckIfLayersIsMutableOrThrow();
}
if (CollectionChanging != null)
{
CollectionChanging(sender, e);
}
}
private void DisconnectedCollectionChanging(object sender, NotifyCollectionChangingEventArgs e)
{
if (!disconnectedObjectHashes.Contains(RuntimeHelpers.GetHashCode(EventSettings.LastEventBubbler)))
{
//see comments in DisconnectedPropertyChanging
UnsubscribeDisconnected(sender);
return;
}
if (restoringMemento != null)
{
if (IsCollectionChangeEventPartOfRestore(sender, e.Index))
{
handlingDisconnected = true;
// track actual changes in disconnected objects
ObservableCollectionChanging(sender, e);
handlingDisconnected = false;
return;
}
}
else
{
if (InEditAction())
{
if (collectionChangeMementos.ContainsKey(new CollectionChangeKey(sender, e.Item, e.Action)))
{
UnsubscribeDisconnected(sender);
}
else
{
handlingDisconnected = true;
// track actual changes in disconnected objects
ObservableCollectionChanging(sender, e);
handlingDisconnected = false;
}
return;
}
if (editActionCallCount > 0)
{
return; // changes occuring in side effects (isolated)
}
}
if (ExcludedTypes.Contains(sender.GetType()))
{
return;
}
throw new InvalidOperationException("Disconnected object which is removed from the main container object but remains in undo/redo stack is being changed, check if side-effect method is marked [EditAction]");
}
public virtual void OnMapCollectionChanged(object sender, NotifyCollectionChangingEventArgs e)
{
}
void ObservableCollectionChanging(object sender, NotifyCollectionChangingEventArgs e)
{
if (!TrackChanges)
{
return;
}
ThrowIfFromDifferentThread();
if (ExcludedTypes.Contains(sender.GetType()))
{
return;
}
if (!handlingDisconnected)
{
//we got an event through the normal path, so we're sure this object is still connected
UnsubscribeDisconnected(sender);
}
// normally this will not happen unless event handlers are subscribed before undo/redo, check nevertheless
if (e.Cancel)
{
log.DebugFormat("CollectionChanging event was cancelled, skipping undo");
return;
}
FixCancelledCollectionChangingEvents();
var key = new CollectionChangeKey(sender, e.Item, e.Action);
if (collectionChangeMementos.ContainsKey(key))
{
if (handlingDisconnected)
{
return; //already received
}
throw new NotSupportedException("The same CollectionChanging event fired twice (probably two different event paths)");
}
if (restoringMemento != null)
{
if (!IsCollectionChangeEventPartOfRestore(sender, e.Index))
{
throw new InvalidOperationException("Side-effect code detected (code which changes object tree in setters or in event handlers) which is not marked with [EditAction]");
}
}
if (eventCascadeCallLevel > 1 && !handlingDisconnected)
{
if (eventCascadeCallLevel < expectedEventCascadeCallLevel)
{
expectedEventCascadeCallLevel = eventCascadeCallLevel;
}
// we must be in a side-effect
if (expectedEventCascadeCallLevel != eventCascadeCallLevel)
{
log.DebugFormat("CascadeEventLevel: {0}, ExpectedCascadeEventLevel: {1}", eventCascadeCallLevel, expectedEventCascadeCallLevel);
throw new InvalidOperationException("Side-effect code detected (code which changes object tree in setters or in event handlers) which is not marked with [EditAction]");
}
}
var memento = (NotifyCollectionChangeMemento)mementoStack.Peek();
memento.RememberOldValues(sender, e);
collectionChangeMementos[key] = memento;
if (!handlingDisconnected && !TypeUtils.IsAggregationList(sender))
{
if (restoringMemento == null)
{
HandleIfTransactional(memento.OldValue, true);
}
SubscribeDisconnected(memento.OldValue); // listen to the changes in disconnected objects
}
}
void ChildCollectionChanged(object sender, NotifyCollectionChangingEventArgs e)
{
OnEntityEventMethod(sender, e, EntityEventType.CollectionChanged);
}
void ObservableCollectionChanged(object sender, NotifyCollectionChangingEventArgs e)
{
if (!TrackChanges)
{
return;
}
ThrowIfFromDifferentThread();
if (ExcludedTypes.Contains(sender.GetType()))
{
return;
}
if (!handlingDisconnected)
{
//we got an event through the normal path, so we're sure this object is still connected
UnsubscribeDisconnected(sender);
}
NotifyCollectionChangeMemento memento;
var key = new CollectionChangeKey(sender, e.Item, e.Action);
collectionChangeMementos.TryGetValue(key, out memento);
if (memento == null)
{
throw new NotSupportedException("CollectionChanged received without CollectionChanging");
}
memento.RememberNewValues(sender, e);
collectionChangeMementos.Remove(key);
lastCollectionChangeMemento = memento;
// exceptional situation, same object!
if (!TypeUtils.IsAggregationList(sender))
{
if (ReferenceEquals(memento.OldValue, memento.NewValue))
{
UnsubscribeDisconnected(memento.OldValue);
}
UnsubscribeDisconnected(memento.NewValue); // newly added value
}
LogCollectionChanged(memento, e);
}
public override void OnMapCollectionChanged(object sender, NotifyCollectionChangingEventArgs e)
{
switch (e.Action)
{
case NotifyCollectionChangeAction.Remove:
{
if(e.Item is ILayer)
{
RefreshSelection();
}
if (sender is Map)
{
var layer = (ILayer)e.Item;
if (layer is GroupLayer)
{
var layerGroup = (GroupLayer)layer;
foreach (ILayer layerGroupLayer in layerGroup.Layers)
{
HandleLayerStatusChanged(layerGroupLayer);
}
}
else
{
HandleLayerStatusChanged(layer);
}
}
break;
}
case NotifyCollectionChangeAction.Replace:
throw new NotImplementedException();
}
}
private void FeaturesCollectionChanged(object sender, NotifyCollectionChangingEventArgs e)
{
themeIsDirty = true;
base.RenderRequired = true;
}