//
// Internal API that calls OnItemChanged. This is invoked from the
// abstract ContextItemCollection class so deriving classes can still
// invoke it.
//
internal void InvokeOnItemChanged(EditingContext context, ContextItem previousItem)
{
OnItemChanged(context, previousItem);
}
/// <summary>
/// This method is called on a context item before it is stored in the context item
/// manager. The previous item in the context item manager is passed.
/// </summary>
/// <param name="context">The editing context that is making this change.</param>
/// <param name="previousItem">The previously active item in the context. Because items must have default constructors a default item will be fabricated if an item is first passed into the context.</param>
/// <returns></returns>
protected virtual void OnItemChanged(EditingContext context, ContextItem previousItem)
{
}
/// <summary>
/// Called when an item changes value. This happens in one of two ways:
/// either the user has called Change, or the user has removed a layer.
/// </summary>
private void OnItemChanged(ContextItem item)
{
SubscribeContextCallback callback;
Debug.Assert(item != null, "You cannot pass a null item here.");
if (_subscriptions != null
&& _subscriptions.TryGetValue(item.ItemType, out callback))
{
callback(item);
}
}
/// <summary>
/// This changes a context item to the given value. It is illegal to pass
/// null here. If you want to set a context item to its empty value create
/// an instance of the item using a default constructor.
/// </summary>
/// <param name="value"></param>
internal override void SetValue(ContextItem value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
// The rule for change is that we store the new value,
// raise a change on the item, and then raise a change
// to everyone else. If changing the item fails, we recover
// the previous item.
ContextItem existing, existingRawValue;
existing = existingRawValue = GetValueNull(value.ItemType);
if (existing == null)
{
existing = GetValue(value.ItemType);
}
var success = false;
try
{
_currentLayer.Items[value.ItemType] = value;
NotifyItemChanged(_context, value, existing);
success = true;
}
finally
{
if (success)
{
OnItemChanged(value);
}
else
{
// The item threw during its transition to
// becoming active. Put the old one back.
// We must put the old one back by re-activating
// it. This could throw a second time, so we
// cover this case by removing the value first.
// Should it throw again, we won't recurse because
// the existing raw value would be null.
_currentLayer.Items.Remove(value.ItemType);
if (existingRawValue != null)
{
SetValue(existingRawValue);
}
}
}
}
//
// Internal API that calls OnItemChanged. This is invoked from the
// abstract ContextItemCollection class so deriving classes can still
// invoke it.
//
internal void InvokeOnItemChanged(EditingContext context, ContextItem previousItem)
{
OnItemChanged(context, previousItem);
}
/// <summary>
/// This method is called on a context item before it is stored in the context item
/// manager. The previous item in the context item manager is passed.
/// </summary>
/// <param name="context">The editing context that is making this change.</param>
/// <param name="previousItem">The previously active item in the context. Because items must have default constructors a default item will be fabricated if an item is first passed into the context.</param>
/// <returns></returns>
protected virtual void OnItemChanged(EditingContext context, ContextItem previousItem)
{
}
