using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
using System.Threading;

namespace SharpLab.ThreadExceptionTest {
	static class Program {

		static Form form;

		/// <summary>
		/// アプリケーションのメイン エントリ ポイントです。
		/// </summary>
		[STAThread]
		static void Main() {

			Application.ThreadException += new System.Threading.ThreadExceptionEventHandler(Application_ThreadException);
			Thread.GetDomain().UnhandledException += new UnhandledExceptionEventHandler(Program_UnhandledException);

			Application.EnableVisualStyles();
			Application.SetCompatibleTextRenderingDefault(false);
			form = new Form();
			Application.Run(new Form1());
		}

		static void Application_ThreadException(object sender, System.Threading.ThreadExceptionEventArgs e) {
			MessageBox.Show(e.Exception.Message);
		}

		static void Program_UnhandledException(object sender, UnhandledExceptionEventArgs e) {
			Exception ex = (Exception)e.ExceptionObject;
			MessageBox.Show(ex.Message);
			Application.Exit();
			Environment.Exit(0);
		}

	}
}

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Threading;

namespace SharpLab.ThreadExceptionTest {
	public partial class Form1 : Form {
		public Form1() {
			InitializeComponent();
		}

		private delegate void SampleDelegate();

		private void button1_Click(object sender, EventArgs e) {

			SampleDelegate a = new SampleDelegate(ThreadMethod);
			a.BeginInvoke((asyncResult) => {
				a.EndInvoke(asyncResult);
			}, null);
		}

		private void ThreadMethod() {
			//意図的に起こした例外
			Thread.Sleep(5000);
			throw new Exception("非同期スレッドで起こった例外です。");
		}

	}
}

private void button1_Click(object sender, EventArgs e) {
    FieldInfo fi = typeof(WebKitBrowser).GetField("webView", BindingFlags.NonPublic| BindingFlags.Instance);
    WebView webView = (WebView)fi.GetValue(this.webBrowser1);
    webView.stringByEvaluatingJavaScriptFromString(@"document.body.innerHTML = 'Hello Webkit DOM!';");
}

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.Windows.Controls;

namespace SharpLab.CredentialsLockerSilverlight.ViewModels {
	public class ReadOnlyObservableTabItemCollection<TViewModel, TViewModelCollection> : ICollection<TabItem>, INotifyCollectionChanged where TViewModelCollection : ICollection<TViewModel>, INotifyCollectionChanged {

		private TViewModelCollection _viewModels;
		private ObservableCollection<TabItem> _tabItems;
		private Func<TViewModel, TabItem> _converter;

		public ReadOnlyObservableTabItemCollection(TViewModelCollection viewModels, Func<TViewModel, TabItem> converter) {
			_converter = converter;
			_viewModels = viewModels;
			_tabItems = new ObservableCollection<TabItem>();

			foreach (var item in _viewModels) {
				_tabItems.Add(_converter(item));
			}

			_viewModels.CollectionChanged += new NotifyCollectionChangedEventHandler(_viewModels_CollectionChanged);

			_tabItems.CollectionChanged += new NotifyCollectionChangedEventHandler(_tabItems_CollectionChanged);
		}

		void _viewModels_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e) {
			switch (e.Action) {
				case NotifyCollectionChangedAction.Add:
					_tabItems.Insert(e.NewStartingIndex, _converter((TViewModel)e.NewItems[0]));
					break;
				case NotifyCollectionChangedAction.Remove:
					_tabItems.RemoveAt(e.OldStartingIndex);
					break;
				case NotifyCollectionChangedAction.Replace:
					_tabItems.RemoveAt(e.OldStartingIndex);
					_tabItems.Insert(e.NewStartingIndex, _converter((TViewModel)e.NewItems[0]));
					break;
				case NotifyCollectionChangedAction.Reset:
					_tabItems.Clear();
					foreach (var item in _viewModels) {
						_tabItems.Add(_converter(item));
					}
					break;
			}
		}

		void _tabItems_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e) {
			if (CollectionChanged != null) {
				CollectionChanged(this, e);
			}
		}

		public event NotifyCollectionChangedEventHandler CollectionChanged;

		#region ICollection<TabItem> メンバ

		public void Add(TabItem item) {
			throw new NotSupportedException();
		}

		public void Clear() {
			throw new NotSupportedException();
		}

		public bool Contains(TabItem item) {
			throw new NotImplementedException();
		}

		public void CopyTo(TabItem[] array, int arrayIndex) {
			throw new NotSupportedException();
		}

		public int Count {
			get {
				throw new NotImplementedException();
			}
		}

		public bool IsReadOnly {
			get {
				return true;
			}
		}

		public bool Remove(TabItem item) {
			throw new NotSupportedException();
		}

		#endregion

		#region IEnumerable<TabItem> メンバ

		public IEnumerator<TabItem> GetEnumerator() {
			foreach (var item in _tabItems) {
				yield return item;
			}
		}

		#endregion

		#region IEnumerable メンバ

		System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
			return GetEnumerator();
		}

		#endregion
	}
}

using System;
using System.Collections.ObjectModel;
using System.Windows.Controls;
using System.Windows.Data;
using SharpLab.CredentialsLockerSilverlight.ViewModels;

namespace SharpLab.CredentialsLockerSilverlight.Views.Converter {
	public class CardVMCol2TabItemColConverter : IValueConverter{
		#region IValueConverter メンバ

		public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture) {
			return new ReadOnlyObservableTabItemCollection<CardViewModel, ObservableCollection<CardViewModel>>((ObservableCollection<CardViewModel>)value,
				(each) => {
					var newTabItem = new TabItem() {
						DataContext = each,
						Header = new CardTabHeaderView(),
						Content = new SharpLab.CredentialsLockerSilverlight.Views.CardView()
					};
					return newTabItem;

				});
		}

		public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture) {
			throw new NotImplementedException();
		}

		#endregion
	}
}

 ItemsSource="{Binding Path=CardViewModels, Converter={StaticResource CardVMCol2TabItemColConverter}}"

using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
using System.Threading;

namespace ThreadExceptionBehavior {
	static class Program {
		/// <summary>
		/// アプリケーションのメイン エントリ ポイントです。
		/// </summary>
		[STAThread]
		static void Main() {

			Application.ThreadException += new System.Threading.ThreadExceptionEventHandler(Application_ThreadException);
			Thread.GetDomain().UnhandledException += new UnhandledExceptionEventHandler(Program_UnhandledException);

			Application.EnableVisualStyles();
			Application.SetCompatibleTextRenderingDefault(false);
			Application.Run(new Form1());
		}

		static void Program_UnhandledException(object sender, UnhandledExceptionEventArgs e) {
			Exception ex = e.ExceptionObject as Exception;
			MessageBox.Show(ex.Message);
		}

		static void Application_ThreadException(object sender, System.Threading.ThreadExceptionEventArgs e) {
			MessageBox.Show(e.Exception.Message);
		}
	}
}

using System;
using System.Windows.Forms;

namespace ThreadExceptionBehavior {
	public partial class Form1 : Form {
		public Form1() {
			InitializeComponent();
		}

		private delegate void SampleDelegate();

		private void button1_Click(object sender, EventArgs e) {
			//非同期スレッドの実行
			SampleDelegate a = new SampleDelegate(ThreadMethod);
			a.BeginInvoke(null, null);
		}

		private void ThreadMethod() {
			//意図的に起こした例外
			throw new Exception("非同期スレッドで起こった例外です。");
		}
	}
}

using System;
using System.Windows.Forms;

namespace ThreadExceptionBehavior {
	public partial class Form1 : Form {
		public Form1() {
			InitializeComponent();
		}

		private delegate void SampleDelegate();

		private void button1_Click(object sender, EventArgs e) {
			//非同期スレッドの実行
			SampleDelegate a = new SampleDelegate(ThreadMethod);
			a.BeginInvoke(null, null);
		}

		private void ThreadMethod() {
			if (this.InvokeRequired) {
				//メインスレッドに呼び戻して実行
				this.BeginInvoke(new SampleDelegate(ThreadMethod));
				return;
			}
			throw new Exception("非同期スレッドで起こった例外です。");
		}
	}
}

using System;
using System.Windows.Forms;

namespace ThreadExceptionBehavior {
	public partial class Form1 : Form {
		public Form1() {
			InitializeComponent();
		}

		private delegate void SampleDelegate();

		private void button1_Click(object sender, EventArgs e) {
			//非同期スレッドの実行
			SampleDelegate a = new SampleDelegate(ThreadMethod);
			a.BeginInvoke(null, null);
		}

		private void ThreadMethod() {
			try {

				//何らかの重たい処理

				throw new Exception("非同期スレッドで起こった例外です。");
			}
			catch(Exception e){
				this.BeginInvoke((MethodInvoker)delegate() {
					throw new ApplicationException("サブスレッドで例外が発生しました。", e);
				});
			}
		}
	}
}

// This source code is licensed by Microsoft under Ms-PL license.
using System;
using System.Collections.Generic;
using System.Windows;
using System.Windows.Input;

namespace WpfModelViewApplication1.Commands
{
    /// <summary>
    /// <para>
    ///     This class allows delegating the commanding logic to methods passed as parameters,
    ///     and enables a View to bind commands to objects that are not part of the element tree.
    /// </para>
    /// <para>
    ///     このクラスはパラメータとして渡されたメソッドへのコマンドのロジックの委譲を実現します。
    ///     また、Viewが要素ツリーに含まれないオブジェクトにコマンドをバインドすることを可能にします。
    /// </para>
    /// </summary>
    public class DelegateCommand : ICommand
    {
        #region Constructors

        /// <summary>
        ///     Constructor
        /// </summary>
        public DelegateCommand(Action executeMethod)
            : this(executeMethod, null, false)
        {
        }

        /// <summary>
        ///     Constructor
        /// </summary>
        public DelegateCommand(Action executeMethod, Func<bool> canExecuteMethod)
            : this(executeMethod, canExecuteMethod, false)
        {
        }

        /// <summary>
        ///     Constructor
        /// </summary>
        public DelegateCommand(Action executeMethod, Func<bool> canExecuteMethod, bool isAutomaticRequeryDisabled)
        {
            if (executeMethod == null)
            {
                throw new ArgumentNullException("executeMethod");
            }

            _executeMethod = executeMethod;
            _canExecuteMethod = canExecuteMethod;
            _isAutomaticRequeryDisabled = isAutomaticRequeryDisabled;
        }

        #endregion

        #region Public Methods

        /// <summary>
        /// <para>
        ///     Method to determine if the command can be executed
        /// </para>
        /// <para>
        ///     コマンドが実行可能かを返す
        /// </para>
        /// </summary>
        public bool CanExecute()
        {
            if (_canExecuteMethod != null)
            {
                return _canExecuteMethod();
            }
            return true;
        }

        /// <summary>
        /// <para>
        ///     Execution of the command
        /// </para>
        /// <para>
        ///     コマンドを実行する
        /// </para>
        /// </summary>
        public void Execute()
        {
            if (_executeMethod != null)
            {
                _executeMethod();
            }
        }

        /// <summary>
        /// <para>
        ///     Property to enable or disable CommandManager's automatic requery on this command
        /// </para>
        /// <para>
        ///     CommandManagerのこのコマンドに対する自動再要求の有効/無効を設定する
        /// </para>
        /// </summary>
        public bool IsAutomaticRequeryDisabled
        {
            get
            {
                return _isAutomaticRequeryDisabled;
            }
            set
            {
                if (_isAutomaticRequeryDisabled != value)
                {
                    if (value)
                    {
                        CommandManagerHelper.RemoveHandlersFromRequerySuggested(_canExecuteChangedHandlers);
                    }
                    else
                    {
                        CommandManagerHelper.AddHandlersToRequerySuggested(_canExecuteChangedHandlers);
                    }
                    _isAutomaticRequeryDisabled = value;
                }
            }
        }

        /// <summary>
        /// <para>
        ///     Raises the CanExecuteChaged event
        /// </para>
        /// <para>
        ///     CanExecuteChangedイベントを発生させる
        /// </para>
        /// </summary>
        public void RaiseCanExecuteChanged()
        {
            OnCanExecuteChanged();
        }

        /// <summary>
        /// <para>
        ///     Protected virtual method to raise CanExecuteChanged event
        /// </para>
        /// <para>
        ///     CanExecuteChangedイベントを発生させるprotected virtualメソッド
        /// </para>
        /// </summary>
        protected virtual void OnCanExecuteChanged()
        {
            CommandManagerHelper.CallWeakReferenceHandlers(_canExecuteChangedHandlers);
        }

        #endregion

        #region ICommand Members

        /// <summary>
        /// <para>
        ///     ICommand.CanExecuteChanged implementation
        /// </para>
        /// <para>
        ///     ICommand.CanExecuteChangedの実装
        /// </para>
        /// </summary>
        public event EventHandler CanExecuteChanged
        {
            add
            {
                if (!_isAutomaticRequeryDisabled)
                {
                    CommandManager.RequerySuggested += value;
                }
                CommandManagerHelper.AddWeakReferenceHandler(ref _canExecuteChangedHandlers, value, 2);
            }
            remove
            {
                if (!_isAutomaticRequeryDisabled)
                {
                    CommandManager.RequerySuggested -= value;
                }
                CommandManagerHelper.RemoveWeakReferenceHandler(_canExecuteChangedHandlers, value);
            }
        }

        bool ICommand.CanExecute(object parameter)
        {
            return CanExecute();
        }

        void ICommand.Execute(object parameter)
        {
            Execute();
        }

        #endregion

        #region Data

        private readonly Action _executeMethod = null;
        private readonly Func<bool> _canExecuteMethod = null;
        private bool _isAutomaticRequeryDisabled = false;
        private List<WeakReference> _canExecuteChangedHandlers;

        #endregion
    }

    /// <summary>
    /// <para>
    ///     This class allows delegating the commanding logic to methods passed as parameters,
    ///     and enables a View to bind commands to objects that are not part of the element tree.
    /// </para>
    /// <para>
    ///     このクラスはパラメータとして渡されたメソッドへのコマンドのロジックの委譲を実現します。
    ///     また、Viewが要素ツリーに含まれないオブジェクトにコマンドをバインドすることを可能にします。
    /// </para>
    /// </summary>
    /// <typeparam name="T">Type of the parameter passed to the delegates</typeparam>
    public class DelegateCommand<T> : ICommand
    {
        #region Constructors

        /// <summary>
        ///     Constructor
        /// </summary>
        public DelegateCommand(Action<T> executeMethod)
            : this(executeMethod, null, false)
        {
        }

        /// <summary>
        ///     Constructor
        /// </summary>
        public DelegateCommand(Action<T> executeMethod, Func<T, bool> canExecuteMethod)
            : this(executeMethod, canExecuteMethod, false)
        {
        }

        /// <summary>
        ///     Constructor
        /// </summary>
        public DelegateCommand(Action<T> executeMethod, Func<T, bool> canExecuteMethod, bool isAutomaticRequeryDisabled)
        {
            if (executeMethod == null)
            {
                throw new ArgumentNullException("executeMethod");
            }

            _executeMethod = executeMethod;
            _canExecuteMethod = canExecuteMethod;
            _isAutomaticRequeryDisabled = isAutomaticRequeryDisabled;
        }

        #endregion

        #region Public Methods

        /// <summary>
        /// <para>
        ///     Method to determine if the command can be executed
        /// </para>
        /// <para>
        ///     コマンドが実行可能かを返す
        /// </para>
        /// </summary>
        public bool CanExecute(T parameter)
        {
            if (_canExecuteMethod != null)
            {
                return _canExecuteMethod(parameter);
            }
            return true;
        }

        /// <summary>
        /// <para>
        ///     Execution of the command
        /// </para>
        /// <para>
        ///     コマンドを実行する
        /// </para>
        /// </summary>
        public void Execute(T parameter)
        {
            if (_executeMethod != null)
            {
                _executeMethod(parameter);
            }
        }

        /// <summary>
        /// <para>
        ///     Raises the CanExecuteChaged event
        /// </para>
        /// <para>
        ///     CanExecuteChangedイベントを発生させる
        /// </para>
        /// </summary>
        public void RaiseCanExecuteChanged()
        {
            OnCanExecuteChanged();
        }

        /// <summary>
        /// <para>
        ///     Protected virtual method to raise CanExecuteChanged event
        /// </para>
        /// <para>
        ///     CanExecuteChangedイベントを発生させるprotected virtualメソッド
        /// </para>
        /// </summary>
        protected virtual void OnCanExecuteChanged()
        {
            CommandManagerHelper.CallWeakReferenceHandlers(_canExecuteChangedHandlers);
        }

        /// <summary>
        /// <para>
        ///     Property to enable or disable CommandManager's automatic requery on this command
        /// </para>
        /// <para>
        ///     CommandManagerのこのコマンドに対する自動再要求の有効/無効を設定する
        /// </para>
        /// </summary>
        public bool IsAutomaticRequeryDisabled
        {
            get
            {
                return _isAutomaticRequeryDisabled;
            }
            set
            {
                if (_isAutomaticRequeryDisabled != value)
                {
                    if (value)
                    {
                        CommandManagerHelper.RemoveHandlersFromRequerySuggested(_canExecuteChangedHandlers);
                    }
                    else
                    {
                        CommandManagerHelper.AddHandlersToRequerySuggested(_canExecuteChangedHandlers);
                    }
                    _isAutomaticRequeryDisabled = value;
                }
            }
        }

        #endregion

        #region ICommand Members

        /// <summary>
        /// <para>
        ///     ICommand.CanExecuteChanged implementation
        /// </para>
        /// <para>
        ///     ICommand.CanExecuteChangedの実装
        /// </para>
        /// </summary>
        public event EventHandler CanExecuteChanged
        {
            add
            {
                if (!_isAutomaticRequeryDisabled)
                {
                    CommandManager.RequerySuggested += value;
                }
                CommandManagerHelper.AddWeakReferenceHandler(ref _canExecuteChangedHandlers, value, 2);
            }
            remove
            {
                if (!_isAutomaticRequeryDisabled)
                {
                    CommandManager.RequerySuggested -= value;
                }
                CommandManagerHelper.RemoveWeakReferenceHandler(_canExecuteChangedHandlers, value);
            }
        }

        bool ICommand.CanExecute(object parameter)
        {
            // if T is of value type and the parameter is not
            // set yet, then return false if CanExecute delegate
            // exists, else return true

            // Tが値型でかつ、parameterがセットされていない場合、
            // CanExecuteデリゲートが存在するならfalseを返します。
            // そうでなければtrueを返します。
            if (parameter == null &&
                typeof(T).IsValueType)
            {
                return (_canExecuteMethod == null);
            }
            return CanExecute((T)parameter);
        }

        void ICommand.Execute(object parameter)
        {
            Execute((T)parameter);
        }

        #endregion

        #region Data

        private readonly Action<T> _executeMethod = null;
        private readonly Func<T, bool> _canExecuteMethod = null;
        private bool _isAutomaticRequeryDisabled = false;
        private List<WeakReference> _canExecuteChangedHandlers;

        #endregion
    }

    /// <summary>
    /// <para>
    ///     This class contains methods for the CommandManager that help avoid memory leaks by
    ///     using weak references.
    /// </para>
    /// <para>
    ///     このクラスはCommandManagerに対する、弱参照を使うことでメモリリークを防ぐ助けとなるメソッドを含んでいます。
    /// </para>
    /// </summary>
    internal class CommandManagerHelper
    {
        internal static void CallWeakReferenceHandlers(List<WeakReference> handlers)
        {
            if (handlers != null)
            {
                // Take a snapshot of the handlers before we call out to them since the handlers
                // could cause the array to me modified while we are reading it.

                // 我々が私への配列を読んでいる間にハンドラはそれの変更を引き起こしうるので、
                // それらを呼び出す前にハンドラのスナップショットをとります。

                EventHandler[] callees = new EventHandler[handlers.Count];
                int count = 0;

                for (int i = handlers.Count - 1; i >= 0; i--)
                {
                    WeakReference reference = handlers[i];
                    EventHandler handler = reference.Target as EventHandler;
                    if (handler == null)
                    {
                        // Clean up old handlers that have been collected
                        // 収集されたハンドラを削除します
                        handlers.RemoveAt(i);
                    }
                    else
                    {
                        callees[count] = handler;
                        count++;
                    }
                }

                // Call the handlers that we snapshotted

                // スナップショットをとったハンドラを呼びます
                for (int i = 0; i < count; i++)
                {
                    EventHandler handler = callees[i];
                    handler(null, EventArgs.Empty);
                }
            }
        }

        internal static void AddHandlersToRequerySuggested(List<WeakReference> handlers)
        {
            if (handlers != null)
            {
                foreach (WeakReference handlerRef in handlers)
                {
                    EventHandler handler = handlerRef.Target as EventHandler;
                    if (handler != null)
                    {
                        CommandManager.RequerySuggested += handler;
                    }
                }
            }
        }

        internal static void RemoveHandlersFromRequerySuggested(List<WeakReference> handlers)
        {
            if (handlers != null)
            {
                foreach (WeakReference handlerRef in handlers)
                {
                    EventHandler handler = handlerRef.Target as EventHandler;
                    if (handler != null)
                    {
                        CommandManager.RequerySuggested -= handler;
                    }
                }
            }
        }

        internal static void AddWeakReferenceHandler(ref List<WeakReference> handlers, EventHandler handler)
        {
            AddWeakReferenceHandler(ref handlers, handler, -1);
        }

        internal static void AddWeakReferenceHandler(ref List<WeakReference> handlers, EventHandler handler, int defaultListSize)
        {
            if (handlers == null)
            {
                handlers = (defaultListSize > 0 ? new List<WeakReference>(defaultListSize) : new List<WeakReference>());
            }

            handlers.Add(new WeakReference(handler));
        }

        internal static void RemoveWeakReferenceHandler(List<WeakReference> handlers, EventHandler handler)
        {
            if (handlers != null)
            {
                for (int i = handlers.Count - 1; i >= 0; i--)
                {
                    WeakReference reference = handlers[i];
                    EventHandler existingHandler = reference.Target as EventHandler;
                    if ((existingHandler == null) || (existingHandler == handler))
                    {
                        // Clean up old handlers that have been collected
                        // in addition to the handler that is to be removed.

                        // 削除されるハンドラに加えて、収集された古いハンドラ
                        // を削除します。
                        handlers.RemoveAt(i);
                    }
                }
            }
        }
    }
}

devenv /InstallVSTemplates 

private RelayCommand _startSearchCommand;

public ICommand StartSearchCommand {
    get {
        if (_startSearchCommand == null) {
            _startSearchCommand = new RelayCommand(param => Model.SearchItemAsync(Keyword, null, 15, 0), null);
        }
        return _startSearchCommand;
    }
}

public ICommand StartSearchCommand {
    get {
        return _startSearchCommand = _startSearchCommand ?? new RelayCommand(param => Model.SearchItemAsync(Keyword, null, 15, 0), null);
    }
}

using System.Windows;
using System.Windows.Input;
using Microsoft.Expression.Interactivity;
using System.Windows.Controls;

namespace SharpLab.IKnow.ItemBankPane {
	public class ExecuteCommandOnEnterKeyDownBehavior : Behavior<TextBox> {
	}
}

using System.Windows;
using System.Windows.Input;
using Microsoft.Expression.Interactivity;
using System.Windows.Controls;

namespace SharpLab.IKnow.ItemBankPane {
	public class ExecuteCommandOnEnterKeyDownBehavior : Behavior<TextBox> {

		protected override void OnAttached() {
			base.OnAttached();

			this.AssociatedObject.KeyDown += OnKeyDown;
		}

		protected override void OnDetaching() {
			base.OnDetaching();

			this.AssociatedObject.KeyDown -= OnKeyDown;
		}

		void OnKeyDown(object sender, KeyEventArgs e) {

		}
	}
}

using System.Windows;
using System.Windows.Input;
using Microsoft.Expression.Interactivity;
using System.Windows.Controls;

namespace SharpLab.IKnow.ItemBankPane {
	public class ExecuteCommandOnEnterKeyDownBehavior : Behavior<TextBox> {

		public string Command {
			get {
				return (string)GetValue(CommandProperty);
			}
			set {
				SetValue(CommandProperty, value);
			}
		}

		public static readonly DependencyProperty CommandProperty =
									DependencyProperty.Register("Command",
										typeof(string),
										typeof(ExecuteCommandOnEnterKeyDownBehavior));

		protected override void OnAttached() {
			base.OnAttached();

			this.AssociatedObject.KeyDown += OnKeyDown;
		}

		protected override void OnDetaching() {
			base.OnDetaching();

			this.AssociatedObject.KeyDown -= OnKeyDown;
		}

		void OnKeyDown(object sender, KeyEventArgs e) {
		}
	}
}

using System.Windows;
using System.Windows.Input;
using Microsoft.Expression.Interactivity;
using System.Windows.Controls;

namespace SharpLab.IKnow.ItemBankPane {
	public class ExecuteCommandOnEnterKeyDownBehavior : Behavior<TextBox> {

		public string Command {
			get {
				return (string)GetValue(CommandProperty);
			}
			set {
				SetValue(CommandProperty, value);
			}
		}

		public static readonly DependencyProperty CommandProperty =
									DependencyProperty.Register("Command",
										typeof(string),
										typeof(ExecuteCommandOnEnterKeyDownBehavior));

		protected override void OnAttached() {
			base.OnAttached();

			this.AssociatedObject.KeyDown += OnKeyDown;
		}

		protected override void OnDetaching() {
			base.OnDetaching();

			this.AssociatedObject.KeyDown -= OnKeyDown;
		}

		void OnKeyDown(object sender, KeyEventArgs e) {
			if (e.Key == Key.Enter) {
				string path = Command;
				object dataContext = AssociatedObject.DataContext;
				ICommand command = dataContext.GetType().GetProperty(path).GetValue(dataContext, null) as ICommand;

				if (command != null && command.CanExecute(AssociatedObject)) {
					command.Execute(AssociatedObject);
				}
			}
		}
	}
}

namespace Microsoft.Expression.Interactivity.Layout {}

<UserControl
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:i="clr-namespace:Microsoft.Expression.Interactivity;assembly=Microsoft.Expression.Interactivity" xmlns:SLPreviewBehaviorsLibrary="clr-namespace:SLPreviewBehaviorsLibrary;assembly=SLPreviewBehaviorsLibrary" x:Class="Silverlight3Testbed.MainPage"
    Width="400" Height="300" mc:Ignorable="d">
	<UserControl.Resources>
		<Storyboard x:Name="Storyboard1" AutoReverse="True" RepeatBehavior="Forever">
			<DoubleAnimationUsingKeyFrames BeginTime="00:00:00" Storyboard.TargetName="button" Storyboard.TargetProperty="(UIElement.Projection).(PlaneProjection.RotationX)">
				<EasingDoubleKeyFrame KeyTime="00:00:00" Value="0"/>
				<EasingDoubleKeyFrame KeyTime="00:00:03" Value="180"/>
			</DoubleAnimationUsingKeyFrames>
			<DoubleAnimationUsingKeyFrames BeginTime="00:00:00" Storyboard.TargetName="button" Storyboard.TargetProperty="(UIElement.Projection).(PlaneProjection.RotationY)" Duration="00:00:00.0010000">
				<EasingDoubleKeyFrame KeyTime="00:00:00" Value="0"/>
			</DoubleAnimationUsingKeyFrames>
			<DoubleAnimationUsingKeyFrames BeginTime="00:00:00" Storyboard.TargetName="button" Storyboard.TargetProperty="(UIElement.Projection).(PlaneProjection.RotationZ)" Duration="00:00:00.0010000">
				<EasingDoubleKeyFrame KeyTime="00:00:00" Value="0"/>
			</DoubleAnimationUsingKeyFrames>
		</Storyboard>
	</UserControl.Resources>
    <Grid x:Name="LayoutRoot" Background="White">
    	<Button x:Name="button" Height="57" Margin="84,86,196,0" VerticalAlignment="Top" Content="Button">
    		<Button.Projection>
    			<PlaneProjection RotationX="0" RotationY="0" RotationZ="0"/>
    		</Button.Projection>
    		<i:Interaction.Triggers>
    			<i:EventTrigger EventName="Click">
    				<SLPreviewBehaviorsLibrary:PlayStoryboardAction StoryboardName="Storyboard1"/>
    			</i:EventTrigger>
    		</i:Interaction.Triggers>
    	</Button>

    </Grid>
</UserControl>

<?php
/*
Plugin Name:wp-idslug
Plugin URI:http://www.sharplab.net/
Description:新規エントリの投稿時にエントリのスラッグにidをセットします。
Author:shiroica
Version:1.00
Author URI:http://blog.sharplab.net/
*/

function sharplab_wpidslug_rewriteNewPost($id){

	$currentState = get_post($id);
	if($currentState->post_name != $currentState->ID){
		$post = array();
		$post['ID'] = $currentState->ID;
		$post['post_name'] = $currentState->ID;
		wp_update_post($post);
	}

}

add_filter('save_post','sharplab_wpidslug_rewriteNewPost')

?>

/%category%/%post_id%/

/%category%/%postname%/

/%year%/%monthnum%/%postname%/

<UserControl x:Class="SharpLab.IKnow.ItemBankPane.ItemBankPaneView"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="clr-namespace:SharpLab.IKnow.ItemBankPane"
	>
    <UserControl.Resources>
    	<ResourceDictionary>
			<local:ItemBankPaneViewModel x:Key="viewModel" />
		</ResourceDictionary>
	</UserControl.Resources>
	<UserControl.DataContext>
		<Binding Mode="OneTime" Source="{StaticResource viewModel}" />
	</UserControl.DataContext>
	<DockPanel>
		<ToolBar DockPanel.Dock="Top" Height="30" VerticalAlignment="Top">
			<TextBox local:TextBoxBehavior.Command="{Binding Mode=OneTime, Path=StartSearchCommand}"  HorizontalAlignment="Left" Text="{Binding Mode=TwoWay, UpdateSourceTrigger=PropertyChanged, Path=Keyword}" VerticalAlignment="Top" Width="184" />
			<Button Command="{Binding Mode=OneTime, Path=StartSearchCommand}" Content="Search"></Button>
		</ToolBar>
		<ContentControl>
				<local:ResultPageView DataContext="{Binding Mode=OneTime, Path=ResultPage}" />
		</ContentControl>
	</DockPanel>
</UserControl>

<UserControl x:Class="SharpLab.IKnow.ItemBankPane.ResultPageView"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
	xmlns:local="clr-namespace:SharpLab.IKnow.ItemBankPane"
	xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" mc:Ignorable="d" d:DesignWidth="300" d:DesignHeight="300"
    >
	<UserControl.Resources>
		<ResourceDictionary>
			<ResourceDictionary.MergedDictionaries>
				<ResourceDictionary Source="Resources/ResultPageResources.xaml"/>
				<ResourceDictionary Source="Resources/VocabularyViewerStyle.xaml"/>
			</ResourceDictionary.MergedDictionaries>
		</ResourceDictionary>
	</UserControl.Resources>
	<Grid DockPanel.Dock="Bottom">
		<Grid.RowDefinitions>
			<RowDefinition />
			<RowDefinition Height="35" />
		</Grid.RowDefinitions>
		<Grid.ColumnDefinitions>
			<ColumnDefinition />
			<ColumnDefinition Width="40" />
			<ColumnDefinition />
		</Grid.ColumnDefinitions>
		<ListBox Name="VocabularyViewer" Grid.Row="0" Grid.ColumnSpan="3" ItemsSource="{Binding Mode=OneWay, NotifyOnTargetUpdated=true, Path=Items}" Style="{StaticResource VocabularyViewerStyle}" />
		<Button Grid.Row="1"  Grid.Column="0" Margin="6,6,6,6" Command="{Binding Mode=OneTime, Path=NavigatePrevPageCommand}" Content="Prev"/>
		<Button Grid.Row="1" Grid.Column="2" Margin="6,6,6,6" Command="{Binding Mode=OneTime, Path=NavigateNextPageCommand}" Content="Next"/>
		<TextBlock Grid.Row="1" Grid.Column="1" Text="{Binding Mode=OneWay, Path=PageCounter}" HorizontalAlignment="Center" VerticalAlignment="Center" />
	</Grid>
</UserControl>

<UserControl x:Class="SharpLab.IKnow.ItemBankPane.ItemView"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="clr-namespace:SharpLab.IKnow.ItemBankPane"
	>

	<UserControl.Resources>
		<ResourceDictionary>
			<ResourceDictionary.MergedDictionaries>
				<ResourceDictionary Source="Resources/PlusButton.xaml"/>
				<ResourceDictionary Source="Resources/PlayButton.xaml"/>
				<ResourceDictionary Source="Resources/SentenceListViewerStyle.xaml"/>
			</ResourceDictionary.MergedDictionaries>
		</ResourceDictionary>
	</UserControl.Resources>

	<DockPanel>
		<Expander x:Name="Sentences" DockPanel.Dock="Bottom" TabIndex="3" Visibility="{Binding Mode=OneTime, Path=SentencesVisility}" >
			<Expander.Header>
				<TextBlock Text="Example Sentences:" />
			</Expander.Header>
			<ItemsControl Name="SentenceListViewer" ItemsSource="{Binding Mode=OneTime, Path=Sentences}" Style="{StaticResource SentenceListViewerStyle}"  />
		</Expander>
		<!--DropDown="{DynamicResource VocabularyViewerItemContextMenu}"-->
		<local:DropDownButton DockPanel.Dock="Right" Width="24" Height="24" Style="{StaticResource PlusButtonStyle}"  TabIndex="1" Margin="0,0,8,0" />
		<DockPanel DockPanel.Dock="Top" LastChildFill="true">
			<MediaElement x:Name="mp3Player" LoadedBehavior="Manual" Source="{Binding Mode=OneTime, Path=CueSound}" Width="0"  Height="0"  />
			<Button DockPanel.Dock="Left" Width="18" Height="18" Margin="2,0,4,0" TabIndex="0" Style="{StaticResource PlayButtonStyle}" Command="{Binding Mode=OneTime, Path=PlaySoundCommand}" CommandParameter="{Binding ElementName=mp3Player}" />
			<ContentControl Content="{Binding Mode=OneTime, Path=CueText}" IsTabStop="False" />
		</DockPanel>
		<TextBlock DockPanel.Dock="Top" FontSize="12" Margin="20,0,0,0" Text="{Binding Mode=OneTime, Path=Meaning}" TextWrapping="Wrap" />
	</DockPanel>
</UserControl>

<UserControl x:Class="SharpLab.IKnow.ItemBankPane.SentenceView"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
	xmlns:local="clr-namespace:SharpLab.IKnow.ItemBankPane"
	>
	<UserControl.Resources>
		<local:StringToTextBlockConverter x:Key="StringToTextBlockConverter" />
	</UserControl.Resources>

	<UserControl.Content>
		<Binding Path="Text" Mode="OneTime"  Converter="{StaticResource StringToTextBlockConverter}" />
	</UserControl.Content>
</UserControl>

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Input;
using System.Windows.Controls;
using System.Windows;

namespace SharpLab.IKnow.ItemBankPane {
	public class TextBoxBehavior {

		#region Command

		public static ICommand GetCommand(TextBox textBox) {
			return (ICommand)textBox.GetValue(CommandProperty);
		}

		public static void SetCommand(
		  TextBox textBox, bool value) {
			textBox.SetValue(CommandProperty, value);
		}

		public static readonly DependencyProperty CommandProperty =
			DependencyProperty.RegisterAttached(
			"Command",
			typeof(ICommand),
			typeof(TextBoxBehavior),
			new UIPropertyMetadata(null, OnCommandPropertyChanged));

		static void OnCommandPropertyChanged(DependencyObject depObj, DependencyPropertyChangedEventArgs e) {
			TextBox textBox = depObj as TextBox;
			if (textBox == null)
				return;

			if (e.NewValue is ICommand == false)
				return;

			ICommand command = (ICommand)e.NewValue;

			textBox.KeyDown += new KeyEventHandler(OnTextBoxKeyDown);
		}

		static void OnTextBoxKeyDown(object sender, KeyEventArgs e) {
			TextBox textBox = (TextBox)e.OriginalSource;
			ICommand command = TextBoxBehavior.GetCommand(textBox);
			if (e.Key == Key.Enter && command != null && command.CanExecute(TextBoxBehavior.GetCommandParameter(textBox))) {
				command.Execute(TextBoxBehavior.GetCommandParameter(textBox));
			}
		}

		#endregion

		#region CommandParameter

		public static object GetCommandParameter(TextBox textBox) {
			return textBox.GetValue(CommandParameterProperty);
		}

		public static void SetCommandParameter(
		  TextBox textBox, object value) {
			textBox.SetValue(CommandParameterProperty, value);
		}

		public static readonly DependencyProperty CommandParameterProperty =
			DependencyProperty.RegisterAttached(
			"CommandParameter",
			typeof(object),
			typeof(TextBoxBehavior),
			new UIPropertyMetadata(null));

		#endregion
	}
}

<TextBox v:TextBoxBehavior.Command="{Binding Path=StartSearchCommand}" />