Beispiel #1
0
 private void CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
 {
     if (e.NewItems != null)
     {
         if (AddedItems == null)
         {
             AddedItems = new List <object>(e.NewItems.Count);
         }
         foreach (var item in e.NewItems)
         {
             AddedItems.Add(item);
         }
     }
     if (e.OldItems != null)
     {
         if (RemovedItems == null)
         {
             RemovedItems = new List <object>(e.OldItems.Count);
         }
         foreach (var item in e.OldItems)
         {
             RemovedItems.Add(item);
         }
     }
 }
Beispiel #2
0
        public virtual void RejectChanges()
        {
            BeginUpdate();

            try
            {
                foreach (var i in AddedItems.OfType <IRevertibleChangeTracking>())
                {
                    i.RejectChanges();
                }

                foreach (var i in AddedItems)
                {
                    RemoveItem(Items.IndexOf(i));
                }

                foreach (var i in RemovedItems)
                {
                    InsertItem(Items.Count, i);
                }

                foreach (var i in Items.OfType <IRevertibleChangeTracking>())
                {
                    i.RejectChanges();
                }

                AcceptChanges(); // To clear the added and removed collections.
            }
            finally
            {
                EndUpdate();
            }
        }
Beispiel #3
0
        private void RaiseLanguageRemoveInteractionRequest(GeneralLanguage selectedItem)
        {
            var confirmation = new ConditionalConfirmation
            {
                Title   = "Remove confirmation".Localize(null, LocalizationScope.DefaultCategory),
                Content = string.Format("Are you sure you want to remove Language '{0}'?".Localize(), selectedItem.LanguageCode)
            };

            LanguageCommonConfirmRequest.Raise(confirmation,
                                               (x) =>
            {
                if (x.Confirmed)
                {
                    if (AddedItems.Contains(selectedItem))
                    {
                        AddedItems.Remove(selectedItem);
                    }
                    else
                    {
                        if (UpdatedItems.Contains(selectedItem))
                        {
                            UpdatedItems.Remove(selectedItem);
                        }
                        RemovedItems.Add(selectedItem);
                    }
                    InnerItems.Remove(selectedItem);
                }
            });
        }
Beispiel #4
0
        /// <summary>
        /// Finishes the item setup, adds it to the item databases, adds an encounter trackable
        /// blah, blah, blah
        /// </summary>
        public static void SetupItem(this PickupObject item, string shortDesc, string longDesc, string idPool = "psm")
        {
            try
            {
                item.encounterTrackable = null;

                ETGMod.Databases.Items.SetupItem(item, item.name);
                SpriteBuilder.AddToAmmonomicon(item.sprite.GetCurrentSpriteDef());
                item.encounterTrackable.journalData.AmmonomiconSprite = item.sprite.GetCurrentSpriteDef().name;

                item.SetName(item.name);
                item.SetShortDescription(shortDesc);
                item.SetLongDescription(longDesc);

                if (item is PlayerItem)
                {
                    (item as PlayerItem).consumable = false;
                }
                Gungeon.Game.Items.Add(idPool + ":" + item.name.ToLower().Replace(" ", "_"), item);
                AddedItems.Add(item);
                ETGMod.Databases.Items.Add(item);
            }
            catch (Exception e)
            {
                ETGModConsole.Log(e.Message);
                ETGModConsole.Log(e.StackTrace);
            }
        }
Beispiel #5
0
 internal override void Update(Change change)
 {
     var _change = change as ListPropertyChange;
     var newAddList = new List<object>(AddedItems.Except(_change.RemovedItems).Concat(_change.AddedItems.Except(RemovedItems).Except(AddedItems)));
     var newRemoveList = new List<object>(RemovedItems.Except(_change.AddedItems).Concat(_change.RemovedItems.Except(AddedItems).Except(RemovedItems)));
     AddedItems = newAddList;
     RemovedItems = newRemoveList;
 }
Beispiel #6
0
        public void CommitChanges()
        {
            RemovedItems.Clear();
            UpdatedItems.Clear();
            AddedItems.Clear();

            OriginalItems.Clear();
            OriginalItems.AddRange(InnerItems);
        }
Beispiel #7
0
        private void OnPropertyChanged(object sender, PropertyChangedEventArgs propertyChangedEventArgs)
        {
            var item = (T)sender;

            if (!AddedItems.Contains(item) && !UpdatedItems.Contains(item))
            {
                UpdatedItems.Add(item);
            }
        }
 public bool Equals(Commit other)
 {
     return(CommitTime == other.CommitTime &&
            CreationTime == other.CreationTime &&
            Invoker == other.Invoker &&
            Name == other.Name &&
            ChangedItems.SequenceEqual(other.ChangedItems) &&
            AddedItems.SequenceEqual(other.AddedItems) &&
            CommitedAll == other.CommitedAll);
 }
Beispiel #9
0
        private void RaiseLanguageAddInteractionRequest()
        {
            var item = new GeneralLanguage();

            if (RaiseLanguageEditInteractionRequest(item, "Create Language".Localize()))
            {
                AddedItems.Add(item);
                InnerItems.Add(item);
            }
        }
Beispiel #10
0
        /// <summary>
        /// Rebuild the binding chain to establish property change monitoring,
        /// additionally setting up collection change event listening on the
        /// source object (if it is a collection)
        /// </summary>
        public override void RefreshBinding()
        {
            base.RefreshBinding();

            object newValue = GetBoundValue();

            if (newValue != _Collection)
            {
                // Remove collectionchanged event watcher:
                if (_Collection != null)
                {
                    _Collection.CollectionChanged -= CollectionChanged;
                    if (_Collection is IEnumerable)
                    {
                        // Remove items from the old collection:
                        var enumerable = (IEnumerable)_Collection;
                        if (RemovedItems == null)
                        {
                            RemovedItems = new List <object>();
                        }
                        foreach (var item in enumerable)
                        {
                            RemovedItems.Add(item);
                        }
                    }
                }

                // Add collectionchanged event watcher:
                if (newValue != null && newValue is INotifyCollectionChanged)
                {
                    var newCollection = (INotifyCollectionChanged)newValue;
                    newCollection.CollectionChanged += CollectionChanged;
                    _Collection = newCollection;
                    if (newCollection is IEnumerable)
                    {
                        // Add items from the new collection:
                        var enumerable = (IEnumerable)newCollection;
                        if (AddedItems == null)
                        {
                            AddedItems = new List <object>();
                        }
                        foreach (var item in enumerable)
                        {
                            AddedItems.Add(item);
                        }
                    }
                }
                else
                {
                    _Collection = null;
                }
            }
        }
Beispiel #11
0
 public void RejectChanges()
 {
     AddedItems.ToList().ForEach(i => _WrappedTarget.Remove(i));
     foreach (var item in _WrappedTarget.Cast <IChangeTrackable <T> >())
     {
         item.RejectChanges();
     }
     foreach (var item in _DeletedItems)
     {
         ((System.ComponentModel.IRevertibleChangeTracking)item).RejectChanges();
         _WrappedTarget.Add(item);
     }
     _DeletedItems.Clear();
 }
Beispiel #12
0
 public void Remove(T item)
 {
     if (AddedItems.Contains(item))
     {
         AddedItems.Remove(item);
     }
     else
     {
         if (UpdatedItems.Contains(item))
         {
             UpdatedItems.Remove(item);
         }
         RemovedItems.Add(item);
     }
     InnerItems.Remove(item);
     item.PropertyChanged -= OnPropertyChanged;
 }
 private void RejectChanges(object proxy, List <object> parents)
 {
     AddedItems.ToList().ForEach(i => _WrappedTarget.Remove(i));
     parents = parents ?? new List <object>(20)
     {
         proxy
     };
     foreach (var item in _WrappedTarget.Cast <IRevertibleChangeTrackingInternal>())
     {
         item.RejectChanges(parents);
     }
     foreach (var item in _DeletedItems)
     {
         ((IRevertibleChangeTrackingInternal)item).RejectChanges(parents);
         _WrappedTarget.Add(item);
     }
     _DeletedItems.Clear();
 }
Beispiel #14
0
        public virtual void RejectChange(T item, bool applyToItem)
        {
            if (AddedItems.Contains(item))
            {
                RemoveItem(Items.IndexOf(item));
            }
            else if (RemovedItems.Contains(item))
            {
                InsertItem(Items.Count, item);
            }
            else
            {
                throw new ArgumentOutOfRangeException(nameof(item), "The specified item does not exist in this collection.");
            }

            if (applyToItem && item is IRevertibleChangeTracking)
            {
                ((IRevertibleChangeTracking)item).RejectChanges();
            }
        }
Beispiel #15
0
        /// <summary>
        ///     Removes a user defined <see cref="Item"/> from the Connector Plugin's data structure.
        /// </summary>
        /// <remarks>
        ///     <para>If an Item being removed has child Items, all children are also removed.</para>
        /// </remarks>
        /// <param name="fqn">The Item to remove.</param>
        /// <returns>A Result containing the result of the operation.</returns>
        public Result RemoveItem(string fqn)
        {
            logger.EnterMethod(xLogger.Params(fqn));
            logger.Info("Removing user defined Item '" + fqn + "...");

            Result retVal = new Result <Item>();

            // check to see if the specified Item has been added previously
            if (AddedItems.ContainsKey(fqn))
            {
                // try to find the matching Item instance
                Item foundItem = Find(fqn);

                if (foundItem != default(Item))
                {
                    // leverage the Item's parent to remove it from the model. The RemoveChild() method in Item will recursively
                    // remove all children.
                    foundItem.Parent.RemoveChild(foundItem);
                }
                else
                {
                    retVal.AddWarning("The Item '" + fqn + "' was not found in the Item data structure, but exists in the list of added items.  It will be removed from the list.");
                }

                // remove the item from the AddedItems list
                AddedItems.Remove(fqn);
            }
            else
            {
                retVal.AddError("The Item '" + fqn + "' does not exist in the list of added Items.");
            }

            retVal.LogResult(logger);
            logger.ExitMethod(retVal);
            return(retVal);
        }
 public bool Any()
 {
     return(AddedItems.Any() || RemovedItems.Any() || UpdatedItems.Any());
 }
Beispiel #17
0
 private void Invariants()
 {
     Contract.Invariant(AddedItems != null, "Added items cannot be a null reference");
     Contract.Invariant(RemovedItems != null, "Removed items cannot be a null reference");
     Contract.Invariant(AddedItems.Intersect(RemovedItems).Count == 0, "Added and removed item collection cannot match because it would mean that some items have been added and removed");
 }
Beispiel #18
0
 public void Add(T item)
 {
     item.PropertyChanged += OnPropertyChanged;
     AddedItems.Add(item);
     InnerItems.Add(item);
 }
 private void Invariants()
 {
     Contract.Invariant(AddedItems != null, "This property cannot be null");
     Contract.Invariant(RemovedItems != null, "This property cannot be null");
     Contract.Invariant(AddedItems.Intersect(RemovedItems).Count() == 0, "This property cannot be null");
 }