protected override void OnItemsChanged(object sender, ItemsChangedEventArgs args) {
            ItemsControl itemsOwner;
            switch (args.Action) {
            case NotifyCollectionChangedAction.Remove:
            case NotifyCollectionChangedAction.Replace:
            case NotifyCollectionChangedAction.Move:
                // THE HACK
                RemoveChildRange(args.Position, args.ItemCount, args.ItemUICount);
                return;

            case NotifyCollectionChangedAction.Reset:
                itemsOwner = ItemsControl.GetItemsOwner(this);
                if (itemsOwner == null)
                    return;
                if (PreviousItemCount != itemsOwner.Items.Count) {
                    if (Orientation != Orientation.Horizontal) {
                        SetHorizontalOffset(0.0);
                        break;
                    }
                    SetVerticalOffset(0.0);
                }
                break;

            default:
                return;
            }
            var itemCount = itemsOwner.Items.Count;
            PreviousItemCount = itemCount;
        }

 private void ItemContainerGeneratorOnItemsChanged(object sender, ItemsChangedEventArgs e)
 {
     if (e.Action == NotifyCollectionChangedAction.Reset)
     {
         MixListScrollViewer.ScrollToTop();
     }
 }

 void ItemContainerGenerator_ItemsChanged(object sender, ItemsChangedEventArgs e)
 {
     if (e.Action == NotifyCollectionChangedAction.Add)
     {
         Position item = lstPositions.Items.Last() as Position;
         location = new GeoCoordinate(item.Latitude, item.Longitude);
         mapPositions.Center = location;
         layer = new MapLayer();
         grid = new Grid();
         grid.DataContext = item;
         grid.Hold += grid_Hold;
         textBlock = new TextBlock();
         textBlock.Text = item.Counter.ToString();
         textBlock.VerticalAlignment = VerticalAlignment.Bottom;
         textBlock.HorizontalAlignment = HorizontalAlignment.Center;
         brush = new ImageBrush();
         brush.ImageSource = image;
         ellipse = new Ellipse();
         ellipse.Height = 100;
         ellipse.Width = 100;
         ellipse.Fill = brush;
         grid.Children.Add(ellipse);
         grid.Children.Add(textBlock);
         overlay = new MapOverlay();
         overlay.Content = grid;
         overlay.GeoCoordinate = location;
         layer.Add(overlay);
         mapPositions.Layers.Add(layer);
     }
 }

		void OnItemsChangedItemContainerGenerator(object sender, ItemsChangedEventArgs e)
		{
			ItemsControl ic = ItemsControl.ItemsControlFromItemContainer(item);

			if (null == ic)
				return;
			item.SetValue(IsLastOneProperty, ic.ItemContainerGenerator.IndexFromContainer(item) == ic.Items.Count - 1);
		}

 private void ModifyModelActionOnItemsChanged(object sender, ItemsChangedEventArgs e){
     foreach (var itemChangesType in e.ChangedItemsInfo.Where(pair => pair.Value==ChoiceActionItemChangesType.Add)){
         var choiceActionItem = itemChangesType.Key as ChoiceActionItem;
         if (choiceActionItem != null && choiceActionItem.Id==ModifyModelActionChoiceItemsUpdater.ChangeViewModel) {
             choiceActionItem.Active.BeginUpdate();
             choiceActionItem.Active["ModelNotConfigured"] = ((IModelViewConfigurationView)View.Model).ConfigurationView != null;
             choiceActionItem.Active.EndUpdate();
         }
     }
 }

		void OnItemsChangedInternal (object sender, ItemsChangedEventArgs args)
 		{
			InvalidateMeasure ();
			if (args.Action == NotifyCollectionChangedAction.Reset) {
				Children.Clear ();
				ItemContainerGenerator.RemoveAll ();
				OnClearChildren ();
			}

			OnItemsChanged (sender, args);
 		}

 void OnItemsChanged(object sender, ItemsChangedEventArgs itemsChangedEventArgs) {
     var changedItemsInfo = itemsChangedEventArgs.ChangedItemsInfo;
     foreach (var actionItemChangesType in changedItemsInfo) {
         if (actionItemChangesType.Key is ChoiceActionItem && actionItemChangesType.Value == ChoiceActionItemChangesType.Add) {
             var choiceActionItem = ((ChoiceActionItem)actionItemChangesType.Key);
             var transition = choiceActionItem.Data as ITransition;
             if (transition != null)
                 choiceActionItem.Active["Permission"] = !IsGranted(transition.TargetState);
         }
     }
 }

 protected override void OnItemsChanged(object sender, ItemsChangedEventArgs args)
 {
     switch (args.Action)
     {
         case NotifyCollectionChangedAction.Move:
         case NotifyCollectionChangedAction.Remove:
         case NotifyCollectionChangedAction.Replace:
             RemoveInternalChildRange(args.Position.Index, args.ItemUICount);
             break;
     }
     base.OnItemsChanged(sender, args);
 }

 void AddNodeActionOnItemsChanged(object sender, ItemsChangedEventArgs itemsChangedEventArgs) {
     var singleChoiceAction = (sender) as SingleChoiceAction;
     if (singleChoiceAction != null && (singleChoiceAction.Id == "Add" && itemsChangedEventArgs.ChangedItemsInfo.Values.Contains(ChoiceActionItemChangesType.ItemsAdd))) {
         if (CurrentModelNode.ModelNode.GetType().Name == "ModelLogicRules") {
             var modelTreeListNode = CurrentModelNode.Parent;
             for (int i = singleChoiceAction.Items.Count - 1; i > -1; i--) {
                 var value = modelTreeListNode.ModelNode.Id.Replace("Conditional", "");
                 if (!singleChoiceAction.Items[i].Id.StartsWith(value))
                     singleChoiceAction.Items.RemoveAt(i);
             }
         }
     }
 }

 void AddNodeActionOnItemsChanged(object sender, ItemsChangedEventArgs itemsChangedEventArgs) {
     var singleChoiceAction = (sender) as SingleChoiceAction;
     if ((singleChoiceAction != null && singleChoiceAction.Id == "Add") && (itemsChangedEventArgs.ChangedItemsInfo.Values.Contains(ChoiceActionItemChangesType.ItemsAdd | ChoiceActionItemChangesType.ItemsRemove))) {
         string name = CurrentModelNode.ModelNode.GetType().Name;
         switch (name) {
             case "ModelLogicRules":
                 FilterModelLogicRules(singleChoiceAction);
                 break;
             case "ModelBOModelClassMembers":
                 EnableBOModelClassMembersAddMenu();
                 break;
         }
     }
 }

 /// <summary>
 /// Event handler for the items changed event
 /// </summary>
 /// <param name="sender">The source of the event.</param>
 /// <param name="e">A <see cref="ItemsChangedEventArgs"/> that contains the event data.</param>
 private static void ItemsChanged(object sender, ItemsChangedEventArgs e)
 {
     ItemsControl control;
     if (itemsControls.TryGetValue(sender, out control))
     {
         if (ShouldShowWatermark(control))
         {
             ShowWatermark(control);
         }
         else
         {
             RemoveWatermark(control);
         }
     }
 }

 private void ItemContainerGeneratorOnItemsChanged(object sender, ItemsChangedEventArgs itemsChangedEventArgs)
 {
     //throw new NotImplementedException();
 }

 private void singleChoiceAction_ItemsChanged(object sender, ItemsChangedEventArgs e)
 {
     if ((
         from a in e.ChangedItemsInfo.Values
         where a == ChoiceActionItemChangesType.Items
         select a).Count<ChoiceActionItemChangesType>() > 0)
     {
         this.ItemChanged(this, ChoiceActionItemChangesType.Items);
     }
 }

 private void OnItemsMove(ItemsChangedEventArgs args)
 {
     RemoveChildRange(args.OldPosition, args.ItemCount, args.ItemUICount);
 }

 		protected override void OnItemsChanged (object sender, ItemsChangedEventArgs args)
 		{
			base.OnItemsChanged (sender, args);
			IItemContainerGenerator generator = ItemContainerGenerator;
			ItemsControl owner = ItemsControl.GetItemsOwner (this);
			int index, offset, viewable, delta;
			
			switch (args.Action) {
			case NotifyCollectionChangedAction.Add:
				// The following logic is meant to keep the current viewable items in view
				// after adjusting for added items.
				index = generator.IndexFromGeneratorPosition (args.Position);
				if (Orientation == Orientation.Horizontal)
					offset = (int) HorizontalOffset;
				else
					offset = (int) VerticalOffset;
				
				if (index <= offset) {
					// items have been added earlier in the list than what is viewable
					offset += args.ItemCount;
				}
				
				if (Orientation == Orientation.Horizontal)
					SetHorizontalOffset (offset);
				else
					SetVerticalOffset (offset);
				break;
			case NotifyCollectionChangedAction.Remove:
				// The following logic is meant to keep the current viewable items in view
				// after adjusting for removed items.
				index = generator.IndexFromGeneratorPosition (args.Position);
				if (Orientation == Orientation.Horizontal) {
					offset = (int) HorizontalOffset;
					viewable = (int) ViewportWidth;
				} else {
					viewable = (int) ViewportHeight;
					offset = (int) VerticalOffset;
				}
				
				if (index < offset) {
					// items earlier in the list than what is viewable have been removed
					offset = Math.Max (offset - args.ItemCount, 0);
				}
				
				// adjust for items removed in the current view and/or beyond the current view
				offset = Math.Min (offset, owner.Items.Count - viewable);
				offset = Math.Max (offset, 0);
				
				if (Orientation == Orientation.Horizontal)
					SetHorizontalOffset (offset);
				else
					SetVerticalOffset (offset);
				
				RemoveInternalChildRange (args.Position.Index, args.ItemUICount);
				break;
			case NotifyCollectionChangedAction.Replace:
				RemoveInternalChildRange (args.Position.Index, args.ItemUICount);
				break;
			case NotifyCollectionChangedAction.Reset:
				// DO NOTHING
				break;
			}
			
			InvalidateMeasure ();
			
			if (ScrollOwner != null)
				ScrollOwner.InvalidateScrollInfo ();
 		}

		protected override void OnItemsChanged (object sender, ItemsChangedEventArgs args)
		{
			if (OnItemsChangedAction != null)
				OnItemsChangedAction ();
			base.OnItemsChanged (sender, args);
		}

        /// <summary>
        ///     Called when the Items collection associated with the containing ItemsControl changes.
        /// </summary>
        /// <param name="sender">sender</param>
        /// <param name="args">Event arguments</param>
        protected override void OnItemsChanged(object sender, ItemsChangedEventArgs args)
        {
            base.OnItemsChanged(sender, args);

            switch (args.Action)
            {
                case NotifyCollectionChangedAction.Remove:
                    OnItemsRemove(args);
                    break;

                case NotifyCollectionChangedAction.Replace:
                    OnItemsReplace(args);
                    break;

                case NotifyCollectionChangedAction.Move:
                    OnItemsMove(args);
                    break;

                case NotifyCollectionChangedAction.Reset:
                    break;
            }
        }

 /// <summary>
 ///     Returns whether an Items collection change affects layout for this panel.
 /// </summary>
 /// <param name="args">Event arguments</param>
 /// <param name="areItemChangesLocal">Says if this notification represents a direct change to this Panel's collection</param>
 protected virtual bool ShouldItemsChangeAffectLayoutCore(bool areItemChangesLocal, ItemsChangedEventArgs args)
 {
     return true;
 }

 static void ItemContainerGenerator_ItemsChanged(object sender, ItemsChangedEventArgs e)
 {
     RefreshWidth(sender as ItemsControl);
 }

        protected override void OnItemsChanged(object sender, ItemsChangedEventArgs args)
        {
            CalculateItemSizes();

            base.OnItemsChanged(sender, args);
        }