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") { } }