WPF Extensibility Hacks or WEX - Includes EventTrigger, ReactiveTrigger, InvokeMethodAction, InvokeCommandAction etc.

using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;
using System.Windows.Interactivity;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.Globalization;
using System.Diagnostics;
using System.ComponentModel;

namespace Wex.Lib.Interactions
{
    public abstract class WexAttachableCollection<T> : FreezableCollection<T>, IAttachedObject where T : DependencyObject, IAttachedObject
    {
        // Fields
        private DependencyObject associatedObject;
        private Collection<T> snapshot;

        // Methods
        internal WexAttachableCollection()
        {
            INotifyCollectionChanged changed = this;
            changed.CollectionChanged += new NotifyCollectionChangedEventHandler(this.OnCollectionChanged);
            this.snapshot = new Collection<T>();
        }

        public void Attach(DependencyObject dependencyObject)
        {
            if (dependencyObject != this.AssociatedObject)
            {
                if (this.AssociatedObject != null)
                {
                    throw new InvalidOperationException();
                }
                this.OnAttached();
            }
        }

        public void Detach()
        {
            this.OnDetaching();
            base.WritePreamble();
            this.associatedObject = null;
            base.WritePostscript();
        }

        internal virtual void ItemAdded(T item) {}
        internal virtual void ItemRemoved(T item){}

        protected virtual void OnAttached() { }

        private void OnCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
        {
            switch (e.Action)
            {
                case NotifyCollectionChangedAction.Add:
                    foreach (T local in e.NewItems)
                    {
                        try
                        {
                            this.VerifyAdd(local);
                            this.ItemAdded(local);
                            continue;
                        }
                        finally
                        {
                            this.snapshot.Insert(base.IndexOf(local), local);
                        }
                    }
                    break;

                case NotifyCollectionChangedAction.Remove:
                    foreach (T local4 in e.OldItems)
                    {
                        this.ItemRemoved(local4);
                        this.snapshot.Remove(local4);
                    }
                    break;

                case NotifyCollectionChangedAction.Replace:
                    foreach (T local2 in e.OldItems)
                    {
                        this.ItemRemoved(local2);
                        this.snapshot.Remove(local2);
                    }
                    foreach (T local3 in e.NewItems)
                    {
                        try
                        {
                            this.VerifyAdd(local3);
                            this.ItemAdded(local3);
                            continue;
                        }
                        finally
                        {
                            this.snapshot.Insert(base.IndexOf(local3), local3);
                        }
                    }
                    break;

                case NotifyCollectionChangedAction.Move:
                    break;

                case NotifyCollectionChangedAction.Reset:
                    foreach (T local5 in this.snapshot)
                    {
                        this.ItemRemoved(local5);
                    }
                    this.snapshot = new Collection<T>();
                    foreach (T local6 in this)
                    {
                        this.VerifyAdd(local6);
                        this.ItemAdded(local6);
                    }
                    break;

                default:
                    return;
            }
        }

        protected virtual void OnDetaching() { }

        private void VerifyAdd(T item)
        {
            if (this.snapshot.Contains(item))
            {
                throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, "Duplicate item", new object[] { typeof(T).Name, base.GetType().Name }));
            }
        }

 
        // Properties
        protected DependencyObject AssociatedObject
        {
            get
            {
                base.ReadPreamble();
                return this.associatedObject;
            }
        }

        DependencyObject IAttachedObject.AssociatedObject
        {
            get
            {
                return this.AssociatedObject;
            }
        }
    }



}