private void UpdateItem(object sender, ItemChangeEventArgs <T> e)
{
// Does it really matter, yes, because I need to replace the item. After all,
// if the reference has changed there is no point/need to do this.
var hasItem = this.FirstOrDefault(item => _changeComparer.Equals(item, e.Item));
if (!_changeComparer.Equals(hasItem, default(T)))
{
// Has item, so replace.
var indexOfExisting = IndexOf(hasItem);
if (!_filterPredicate(hasItem))
{
_changeDispatcher(() => RemoveItem(indexOfExisting));
}
else
{
if (_ordering != null)
{
// Simply remove the item and add it again at the right location. This is far simpler
// because with reference equals you're always comparing the item with itself, which
// then requires code to deal with as well.
_changeDispatcher(() => RemoveAt(indexOfExisting));
AddItem(sender, e);
}
else
{
// This replaces where as MoveItem doesn't!
_changeDispatcher(() => SetItem(indexOfExisting, e.Item));
}
}
}
else
{
AddItem(sender, e);
}
}
private void MethodsContentChanged(object sender, ItemChangeEventArgs e)
{
switch (e.ChangeType)
{
case ContentChangeType.None:
case ContentChangeType.CollectionAdd:
{
var function = (Method)e.NewValue;
Methods.Insert(e.Index.Int, new VisualScriptMethodViewModel(this, function));
break;
}
case ContentChangeType.CollectionRemove:
{
var viewModel = Methods[e.Index.Int];
viewModel?.Destroy();
Methods.RemoveAt(e.Index.Int);
break;
}
default:
throw new ArgumentOutOfRangeException();
}
}
private void CamerasSlotsChanged(object sender, ItemChangeEventArgs e)
{
switch (e.ChangeType)
{
case ContentChangeType.None:
break;
case ContentChangeType.CollectionAdd:
{
CameraSlots.Insert(e.Index.Int, new GraphicsCompositorCameraSlotsViewModel(this, (SceneCameraSlot)e.NewValue));
break;
}
case ContentChangeType.CollectionRemove:
{
CameraSlots.ElementAt(e.Index.Int).Dispose();
CameraSlots.RemoveAt(e.Index.Int);
break;
}
default:
throw new ArgumentOutOfRangeException();
}
}
void _libraryManager_ItemUpdated(object sender, ItemChangeEventArgs e)
{
if (e.UpdateReason == ItemUpdateType.ImageUpdate)
{
var person = e.Item as Person;
if (person != null)
{
var config = _config.GetNfoConfiguration();
if (!config.SaveImagePathsInNfo)
{
return;
}
var items = _libraryManager.RootFolder.GetRecursiveChildren(person.GetItemFilter());
foreach (var item in items)
{
SaveMetadataForItem(item, ItemUpdateType.MetadataEdit);
}
}
}
}
internal void OnItemChanged(object sender, ItemChangeEventArgs e)
{
var value = node.Retrieve();
if (!CollectionItemIdHelper.HasCollectionItemIds(value))
{
return;
}
// Make sure that we have item ids everywhere we're supposed to.
AssetCollectionItemIdHelper.GenerateMissingItemIds(e.Collection.Retrieve());
// Clear the cached item identifier collection.
collectionItemIdentifiers = null;
// Create new ids for collection items
var baseNode = (AssetObjectNode)BaseNode;
var removedId = ItemId.Empty;
var isOverriding = baseNode != null && !PropertyGraph.UpdatingPropertyFromBase;
var itemIds = CollectionItemIdHelper.GetCollectionItemIds(value);
var collectionDescriptor = node.Descriptor as CollectionDescriptor;
switch (e.ChangeType)
{
case ContentChangeType.CollectionUpdate:
break;
case ContentChangeType.CollectionAdd:
{
// Compute the id we will add for this item
var itemId = restoringId != ItemId.Empty ? restoringId : ItemId.New();
// Add the id to the proper location (insert or add)
if (collectionDescriptor != null)
{
if (e.Index == Index.Empty)
{
throw new InvalidOperationException("An item has been added to a collection that does not have a predictable Add. Consider using NonIdentifiableCollectionItemsAttribute on this collection.");
}
itemIds.Insert(e.Index.Int, itemId);
}
else
{
itemIds[e.Index.Value] = itemId;
}
break;
}
case ContentChangeType.CollectionRemove:
{
var itemId = itemIds[e.Index.Value];
// update isOverriding, it should be true only if the item being removed exist in the base.
isOverriding = isOverriding && baseNode.HasId(itemId);
removedId = collectionDescriptor != null?itemIds.DeleteAndShift(e.Index.Int, isOverriding) : itemIds.Delete(e.Index.Value, isOverriding);
break;
}
default:
throw new ArgumentOutOfRangeException();
}
// Don't update override if propagation from base is disabled.
if (PropertyGraph?.Container?.PropagateChangesFromBase == false)
{
return;
}
// Mark it as New if it does not come from the base
if (!ResettingOverride)
{
if (e.ChangeType != ContentChangeType.CollectionRemove && isOverriding)
{
// If it's an add or an updating, there is no scenario where we can be "un-overriding" without ResettingOverride, so we pass true.
OverrideItem(true, e.Index);
}
else if (e.ChangeType == ContentChangeType.CollectionRemove)
{
// If it's a delete, it could be an item that was previously added as an override, and that should not be marked as "deleted-overridden", so we pass isOverriding
OverrideDeletedItem(isOverriding, removedId);
}
}
}
/// <inheritdoc/>
protected override void OnItemChanged([NotNull] ItemChangeEventArgs args)
{
RelinkToOwnerPart((IAssetNode)args.Collection, args.NewValue);
base.OnItemChanged(args);
}
private bool IsValidChange([NotNull] ItemChangeEventArgs e)
{
return(IsValidChange(e.ChangeType, e.Index, Index));
}
protected virtual void KeyFramesContentChanged(object sender, ItemChangeEventArgs e)
{
if (!IsInitialized)
{
return;
}
if (!e.Index.IsInt)
{
return;
}
var index = e.Index.Int;
KeyFrameControlPointViewModel <TValue> controlPoint;
switch (e.ChangeType)
{
case ContentChangeType.ValueChange:
case ContentChangeType.CollectionUpdate:
return;
case ContentChangeType.CollectionAdd:
var node = Editor.Session.AssetNodeContainer.GetNode(e.NewValue);
controlPoint = CreateControlPoint(node);
if (controlPoint != null)
{
// update the double-linked references
if (index > 0)
{
controlPoint.Previous = controlPoints[index - 1];
controlPoints[index - 1].Next = controlPoint;
}
if (index < controlPoints.Count)
{
controlPoint.Next = controlPoints[index];
controlPoints[index].Previous = controlPoint;
}
// insert into the list
controlPoints.Insert(index, controlPoint);
}
break;
case ContentChangeType.CollectionRemove:
// update the double-linked references
controlPoint = controlPoints[index];
if (index > 0)
{
controlPoints[index - 1].Next = controlPoint.Next;
}
if (index + 1 < controlPoints.Count)
{
controlPoints[index + 1].Previous = controlPoint.Previous;
}
// remove from the list
controlPoints.RemoveAt(index);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
private void PlatformFiltersNodeChanged(object sender, ItemChangeEventArgs e)
{
var index = e.Index.Int;
ITransaction transaction = null;
try
{
if (e.ChangeType == ContentChangeType.CollectionUpdate)
{
transaction = UndoRedoService.CreateTransaction();
}
foreach (var platformOverride in Asset.Overrides)
{
var node = Session.AssetNodeContainer.GetNode(platformOverride);
var filterNode = node[nameof(ConfigurationOverride.SpecificFilter)];
switch (e.ChangeType)
{
case ContentChangeType.CollectionUpdate:
{
// This is a hack to force refreshing the display of the filter in override. We clear and reset it before and after the name change.
if (platformOverride.SpecificFilter == index)
{
filterNode.Update(-1);
filterNode.Update(index);
}
break;
}
case ContentChangeType.CollectionAdd:
{
var filterIndex = (int)filterNode.Retrieve();
if (filterIndex >= index)
{
filterNode.Update(filterIndex + 1);
}
break;
}
case ContentChangeType.CollectionRemove:
{
var filterIndex = (int)filterNode.Retrieve();
if (filterIndex > index)
{
filterNode.Update(filterIndex - 1);
}
else if (filterIndex == index)
{
filterNode.Update(-1);
}
break;
}
}
}
}
finally
{
if (transaction != null)
{
UndoRedoService.SetName(transaction, "Force filter refresh");
transaction.Complete();
}
}
}
private void OnItemChanged(object sender, ItemChangeEventArgs e)
{
Refresh();
RaiseValueChanged(Value);
}
private void OnItemChanging(object sender, ItemChangeEventArgs e)
{
RaiseValueChanging(Value);
}
private async void TransformChildrenChanged(object sender, ItemChangeEventArgs e)
{
Entity childEntity;
switch (e.ChangeType)
{
case ContentChangeType.CollectionAdd:
childEntity = ((TransformComponent)e.NewValue).Entity;
Editor.Logger.Verbose($"Add {childEntity.Name} ({childEntity.Id}) to the Entities collection");
break;
case ContentChangeType.CollectionRemove:
childEntity = ((TransformComponent)e.OldValue).Entity;
Editor.Logger.Verbose($"Remove {childEntity.Name} ({childEntity.Id}) from the Entities collection");
break;
default:
throw new ArgumentOutOfRangeException();
}
// Update view model
if (e.ChangeType == ContentChangeType.CollectionAdd)
{
// TODO: can be factorized with what EntityHierarchyRootViewModel is doing, through a base method. There are a few differences though.
var component = (TransformComponent)e.NewValue;
var entity = EntityHierarchy.Hierarchy.Parts[component.Entity.Id];
var element = (EntityViewModel)Editor.CreatePartViewModel(Asset, entity);
var index = e.Index.Int;
var parent = FindOrCreateFolder(entity.Folder);
parent.InsertEntityViewModel(element, parent.FindIndexInParent(index, EntityDesign.Entity.Transform.Children.Select(x => EntityHierarchy.Hierarchy.Parts[x.Entity.Id])));
// FIXME: when we allow loading/unloading single entities, this should be implemented in OnLoadingRequested. Then just call RequestLoading(true).
// Check if the container root is loaded
if (EntityHierarchyEditorViewModel.GetRoot(this).IsLoaded)
{
var children = element.TransformChildren.BreadthFirst(x => x.TransformChildren).ToList();
// Set the new entity and its children as 'loading'
element.IsLoading = true;
foreach (var child in children)
{
child.IsLoading = true;
}
// Add the entity to the game (actually load the entity and its children)
await Editor.Controller.AddPart(this, element.AssetSideEntity);
// Set the new entity and its children as 'loaded'
element.IsLoaded = true;
foreach (var child in children)
{
child.IsLoaded = true;
}
// Manually notify the game-side scene
element.NotifyGameSidePartAdded().Forget();
foreach (var child in children)
{
child.NotifyGameSidePartAdded().Forget();
}
}
}
else if (e.ChangeType == ContentChangeType.CollectionRemove)
{
var component = (TransformComponent)e.OldValue;
var partId = new AbsoluteId(Asset.Id, component.Entity.Id);
var element = (EntityViewModel)Editor.FindPartViewModel(partId);
if (element == null)
{
throw new InvalidOperationException($"{nameof(element)} cannot be null");
}
RemoveEntityViewModel(element);
// FIXME: when we allow loading/unloading single entities, this should be implemented in OnLoadingRequested. Then just call RequestLoading(false).
if (element.IsLoaded)
{
element.IsLoading = true;
Editor.Controller.RemovePart(this, element.AssetSideEntity).Forget();
element.IsLoaded = false;
}
}
}
protected virtual void OnRootUIElementsChanged([NotNull] ItemChangeEventArgs e)
{
// default implementation does nothing
}
public void ItemRemoved(object sender, ItemChangeEventArgs e)
{
if (e.Item.MediaType == "Movies")
{
}
}
