/// <summary>
        /// When a new item is added to the Inbox Collection we will get a notification here which we will distribute to the listening clients
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void newMail(object sender, NotifyCollectionChangedEventArgs e)
        {
            if (Clients != null)
                Clients.updateInbox(MvcApplication.Inbox);

            // Clients.alert("You've got mail!");
        }

 private void Clients_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
 {
     switch (e.Action)
     {
         case NotifyCollectionChangedAction.Add:
             IMPClient addedItem = e.NewItems[0] as IMPClient;
             if (addedItem != null)
             {
                 Dispatcher.BeginInvoke(
                     new Action(() =>
                     {
                         clientList.Add(addedItem);
                         Lbl_ClientCount.Content = clientList.Count;
                     })
                 );
             }
             break;
         case NotifyCollectionChangedAction.Remove:
             IMPClient removedItem = e.OldItems[0] as IMPClient;
             if (removedItem != null)
             {
                 Dispatcher.BeginInvoke(
                     new Action(() =>
                     {
                         clientList.Remove(removedItem);
                         Lbl_ClientCount.Content = clientList.Count;
                     })
                 );
             }
             break;
     }
 }

			void insightWindow_items_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
			{
				OnPropertyChanged("Count");
				OnPropertyChanged("CurrentHeader");
				OnPropertyChanged("CurrentContent");
				OnPropertyChanged("CurrentIndexText");
			}

 void TeamMembers_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
 {
     TeamOneList.UpdateLayout();
     TeamTwoList.UpdateLayout();
     team1SkaterCount.Text = GameViewModel.Instance.Team1.TeamMembers.Count + " Skaters";
     team2SkaterCount.Text = GameViewModel.Instance.Team2.TeamMembers.Count + " Skaters";
 }

 private void OnNavigationViewsChanged(object sender, NotifyCollectionChangedEventArgs e)
 {
     if (e.Action == NotifyCollectionChangedAction.Add)
     {
         PopulateRegion(e.NewItems);
     }
 }

 private void AllFilesOnCollectionChanged(object sender, NotifyCollectionChangedEventArgs notifyCollectionChangedEventArgs)
 {
     switch (notifyCollectionChangedEventArgs.Action)
       {
     case NotifyCollectionChangedAction.Add:
       foreach (FileViewModel fileViewModel in notifyCollectionChangedEventArgs.NewItems)
       {
     if (fileViewModel.Path.EndsWith("template.json"))
       Templates.Add(new Template(fileViewModel));
       }
       break;
     case NotifyCollectionChangedAction.Remove:
       foreach (FileViewModel fileViewModel in notifyCollectionChangedEventArgs.OldItems)
       {
     if (fileViewModel.Path.EndsWith("template.json"))
     {
       Template template = m_templates.FirstOrDefault(n => n.FileViewModel == fileViewModel);
       m_templates.Remove(template);
     }
       }
       break;
     case NotifyCollectionChangedAction.Replace:
       break;
     case NotifyCollectionChangedAction.Move:
       break;
     case NotifyCollectionChangedAction.Reset:
       break;
     default:
       throw new ArgumentOutOfRangeException();
       }
 }

        private void Columns_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
        {
            switch (e.Action)
            {
                case NotifyCollectionChangedAction.Add:
                    foreach (DataGridColumn column in e.NewItems ?? EmptyList)
                    {
                        AddEventHandlers(column);
                    }
                    break;

                case NotifyCollectionChangedAction.Remove:
                    foreach (DataGridColumn column in e.OldItems ?? EmptyList)
                    {
                        RemoveEventHandlers(column);
                    }
                    break;

                case NotifyCollectionChangedAction.Replace:
                    foreach (DataGridColumn column in e.OldItems ?? EmptyList)
                    {
                        RemoveEventHandlers(column);
                    }
                    foreach (DataGridColumn column in e.NewItems ?? EmptyList)
                    {
                        AddEventHandlers(column);
                    }
                    break;
            }
        }

		private void boxesCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
		{
			//VIEW0
			int i = 0;
			if (e.NewItems != null)
				foreach (var newBoxViewModel in e.NewItems.Cast<BoxViewModel>())
				{
					var boxIndex = e.NewStartingIndex + i;
					var box = new Box(newBoxViewModel, ((Box)this.Parent).CaretPerTree);
					this.locations.Insert(boxIndex, default(Point));
					this.Children.Insert(boxIndex, box);
					SetLeft(box, 0);
					SetTop(box, 0);
					newBoxViewModel.PropertyChanged += (_, _e) =>
					{
						//if (_e.PropertyName == nameof(BoxViewModel.Layout))//TODO: filter all calls to the following method by only propagating those properties that cause a layout change
						this.boxLayoutChanged();
					};
				}
			//VIEW1//VIEW2
			if (e.OldItems != null)
				foreach (var newBoxViewModel in e.OldItems.Cast<BoxViewModel>())
				{
					this.locations.RemoveAt(e.OldStartingIndex);
					this.Children.RemoveAt(e.OldStartingIndex);
				}
		}

        void _container_ItemsChanged(object sender, NotifyCollectionChangedEventArgs e)
        {
            if (e.Action == NotifyCollectionChangedAction.Reset)
            {
                var separators = _control.Items.OfType<ToolStripSeparator>().ToArray();

                foreach (var separator in separators)
                {
                    ((GroupControl)separator.Tag).Dispose();
                }
            }
            else
            {
                if (e.OldItems != null)
                {
                    foreach (NiCommandBarGroup group in e.OldItems)
                    {
                        GetGroupControl(group).Dispose();
                    }
                }

                if (e.NewItems != null)
                {
                    foreach (NiCommandBarGroup group in e.NewItems)
                    {
                        new GroupControl(_serviceProvider, _control, group);
                    }
                }
            }
        }

 private void OnCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
 {
     if (_isInitialized)
     {
         switch (e.Action)
         {
             case NotifyCollectionChangedAction.Reset:
                 ClearChildren();
                 break;
             case NotifyCollectionChangedAction.Add:
                 int index = e.NewStartingIndex;
                 foreach (var item in e.NewItems)
                 {
                     AddItem(item, index++);
                 }
                 SelectedIndexChanged(this.SelectedIndex);
                 break;
             case NotifyCollectionChangedAction.Remove:
                 foreach (var item in e.OldItems)
                 {
                     RemoveItem(item);
                 }
                 SelectedIndexChanged(this.SelectedIndex);
                 break;
             case NotifyCollectionChangedAction.Replace:
             case NotifyCollectionChangedAction.Move:
             default:
                 break;
         }
     }
 }

 private void ctrlTranscriptEntries_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
 {
     if (ctrlTranscriptEntries.Items.Count > 0)
     {
         ctrlTranscriptEntries.ScrollIntoView(ctrlTranscriptEntries.Items[ctrlTranscriptEntries.Items.Count - 1]);
     }
 }

 private void _positions_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
 {
     switch (e.Action)
     {
         case NotifyCollectionChangedAction.Add:
             HandlePositionAddEvent(e.NewItems);
             break;
         case NotifyCollectionChangedAction.Move:
             // don't care
             break;
         case NotifyCollectionChangedAction.Remove:
             HandlePositionRemoveEvent(e.OldItems);
             break;
         case NotifyCollectionChangedAction.Replace:
             HandlePositionAddEvent(e.NewItems);
             HandlePositionRemoveEvent(e.OldItems);
             break;
         case NotifyCollectionChangedAction.Reset:
             HandlePositionAddEvent(e.NewItems);
             HandlePositionRemoveEvent(e.OldItems);
             break;
         default:
             throw new Exception(String.Format("unexpected action type {0}", e.Action));
     }
     // We *could* be clever, check to see if TotalValues really changed,
     // and only report Positions changing if TotalValues stayed the same,
     // but it's simpler to just assume TotalValue will change as well
     RaisePropertyChanged(String.Empty);
 }

        private void ElementsChanged(object sender, NotifyCollectionChangedEventArgs e)
        {
            if (e.Action == NotifyCollectionChangedAction.Add)
            {
                foreach (var item in e.NewItems)
                {
                    var elementViewModel = item as ElementViewModel;
                    if (elementViewModel == null) continue;
                    AddElementResultsCollections(elementViewModel);
                }
            }

            if (e.Action == NotifyCollectionChangedAction.Remove)
            {
                foreach (var item in e.OldItems)
                {
                    var elementViewModel = item as ElementViewModel;
                    if (elementViewModel == null) continue;
                    RemoveElementResultsCollections(elementViewModel);
                }
            }
            if (e.Action == NotifyCollectionChangedAction.Reset)
            {
                ResetCollection();
            }
        }

      private void _onConvertersCollectionChanged(object sender, NotifyCollectionChangedEventArgs e) {
         IList C = null;

         switch (e.Action) {
            case NotifyCollectionChangedAction.Add:
               C = e.NewItems;
               break;

            case NotifyCollectionChangedAction.Replace:
               C = e.NewItems;
               break;

            case NotifyCollectionChangedAction.Remove:
               foreach (IValueConverter c in e.OldItems) {
                  _convertersInfo.Remove(c); 
               }
               break;

            case NotifyCollectionChangedAction.Reset:
               _convertersInfo.Clear();
               C = Converters;
               break;
         }
         if (C == null || C.Count == 0) return;

         foreach (IValueConverter c in C) {
            var attrs = c.GetType().GetAttributes<ValueConversionAttribute>();
            Assumption.IsTrue(attrs.Length == 1, "All value converters in a converter chain must be decorated with the ValueConversion attribute exactly once.");
            _convertersInfo.Add(c, attrs[0]);
         }
      }

        private void CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
        {
            bool update = false;

            switch (e.Action)
            {
                case NotifyCollectionChangedAction.Add:
                    update = _intArgs[0] >= e.NewStartingIndex;
                    break;
                case NotifyCollectionChangedAction.Remove:
                    update = _intArgs[0] >= e.OldStartingIndex;
                    break;
                case NotifyCollectionChangedAction.Replace:
                    update = _intArgs[0] >= e.NewStartingIndex &&
                             _intArgs[0] < e.NewStartingIndex + e.NewItems.Count;
                    break;
                case NotifyCollectionChangedAction.Move:
                    update = (_intArgs[0] >= e.NewStartingIndex &&
                              _intArgs[0] < e.NewStartingIndex + e.NewItems.Count) ||
                             (_intArgs[0] >= e.OldStartingIndex &&
                             _intArgs[0] < e.OldStartingIndex + e.OldItems.Count);
                    break;
                case NotifyCollectionChangedAction.Reset:
                    update = true;
                    break;
            }

            if (update)
            {
                CurrentValue = GetValue(sender);
            }
        }

 private void OnCurrentPlaylistChanged(object sender, NotifyCollectionChangedEventArgs e)
 {
     switch (e.Action)
     {
         case NotifyCollectionChangedAction.Add:
         {
             foreach (Song item in e.NewItems)
                 CurrentPlaylist.Add(new SongViewModel(item, this));
             break;
         }
         case NotifyCollectionChangedAction.Remove:
         {
             var models = e.OldItems as List<Song>;
             if (models != null)
             {
                 var viewModels = models.Select(item => CurrentPlaylist.First(s => s.Model == item)).ToList();
                 foreach (var viewModel in viewModels)
                 {
                     CurrentPlaylist.Remove(viewModel);
                 }
             }
             break;
         }
     }
 }

		void SubscriptionsCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
		{
			if (e.Action == NotifyCollectionChangedAction.Remove)
			{
				SubscriptionsGrid.SelectedIndex = e.OldStartingIndex;
			}
		}

 void ChatView_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
 {
     if (e.Action == NotifyCollectionChangedAction.Add)
     {
         ConversationList.ScrollIntoView(e.NewItems[0]);
     }
 }

		protected virtual void RaiseDataCollectionChanged(NotifyCollectionChangedEventArgs args)
		{
			if (this.CollectionChanged != null)
			{
				this.CollectionChanged(this.value, args);
			}
		}

        private void OnConditionItemsCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
        {
            if (e.OldItems != null)
            {
                foreach (var item in e.OldItems)
                {
                    var conditionTreeItem = (ConditionTreeItem)item;

                    if (ReferenceEquals(conditionTreeItem, this))
                    {
                        conditionTreeItem.Parent = null;
                    }

                    conditionTreeItem.Updated -= OnConditionUpdated;
                }
            }

            var newCollection = (e.Action == NotifyCollectionChangedAction.Reset) ? (IList)sender : e.NewItems;
            if (newCollection != null)
            {
                foreach (var item in newCollection)
                {
                    var conditionTreeItem = (ConditionTreeItem)item;

                    conditionTreeItem.Parent = this;
                    conditionTreeItem.Updated += OnConditionUpdated;
                }
            }
        }