WPF Control Factory

using System;
using System.ComponentModel;
using System.Windows;
using System.Windows.Threading;

namespace Pfz.WpfControls
{
	/// <summary>
	/// A control bound to a property of an object.
	/// </summary>
	/// <typeparam name="ObjectType">The type of the DataSource property.</typeparam>
	public class PropertyBoundControl<ObjectType>:
		PropertyBoundControlBase,
		IDataSourceChangedHandler,
		IIsReadOnlyChangedHandler
	{
		private ValueControl fValueControl = new ValueControl();
		
		/// <summary>
		/// Creates a new PropertyBoundControl instance.
		/// </summary>
		public PropertyBoundControl()
		{
			fValueControl.ValueChanged += p_ValueControl_ValueChanged;
			fValueControl.ValueChangeThrownException += p_ValueControl_ValueChangeThrownException;
			Content = fValueControl;
		}

		void p_ValueControl_ValueChangeThrownException(object sender, ValueExceptionEventArgs args)
		{
			args.RoutedEvent = ValueControl.ValueChangeThrownExceptionEvent;
			RaiseEvent(args);
		}

		private void p_ValueControl_ValueChanged(object sender, ValueChangedEventArgs args)
		{
			OnValueChanged(args);
		
			object value = Value;
			var binding = fPropertyBinding;
			if (binding == null)
				return;
			
			var property = binding.Property;
			if (property == null)
				return;
			
			var dataSource = DataSource;
			if (dataSource == null)
				return;
			
			if (p_IsReadOnly())
				return;
				
			property.SetValue(dataSource, value, null);
		}
		
		private PropertyBinding fPropertyBinding;
		
		/// <summary>
		/// Gets or sets the PropertyBinding of this control.
		/// </summary>
		public PropertyBinding PropertyBinding
		{
			get
			{
				return fPropertyBinding;
			}
			set
			{
				fPropertyBinding = value;
				p_MustRecreate();
			}
		}
		private bool fCanShowDisplayName = true;
		
		/// <summary>
		/// Gets or sets a value indicating is the DisplayName can be shown.
		/// </summary>
		[DefaultValue(true)]
		public bool CanShowDisplayName
		{
			get
			{
				return fCanShowDisplayName;
			}
			set
			{
				if (value == fCanShowDisplayName)
					return;

				fCanShowDisplayName = value;
				
				if (value)
				{
					var binding = fPropertyBinding;
					if (binding == null)
						fValueControl.DisplayName = null;
					else
						fValueControl.DisplayName = binding.ToString();
				}
				else
					fValueControl.DisplayName = null;
			}
		}
		
		/// <summary>
		/// Gets or sets the object that is read/written as the data-source.
		/// </summary>
		public ObjectType DataSource
		{
			get
			{
				var result = BoundControl.GetDataSource(this);
				if (!(result is ObjectType))
					return default(ObjectType);
				
				return (ObjectType)result;
			}
			set
			{
				BoundControl.SetDataSource(this, value);
			}
		}

		/// <summary>
		/// Gets or sets a value indicating if this control is/should-be read-only.
		/// </summary>
		public bool IsReadOnly
		{
			get
			{
				return BoundControl.GetIsReadOnly(this);
			}
			set
			{
				BoundControl.SetIsReadOnly(this, value);
			}
		}
		
		/// <summary>
		/// Gets or sets the value of this controls.
		/// </summary>
		public override object Value
		{
			get
			{
				return fValueControl.Value;
			}
			set
			{
				fValueControl.Value = value;
			}
		}
		
		/// <summary>
		/// Reads (refreshes) the value of the control from the data-source.
		/// </summary>
		public override void ReadFromDataSource()
		{
			var dataSource = DataSource;
			if (dataSource == null)
			{
				fValueControl.Clear();
				fValueControl.IsReadOnly = true;
				return;
			}
			
			fValueControl.IsReadOnly = p_IsReadOnly();
			fValueControl.Value = p_GetBoundValue();
		}

		private bool p_IsReadOnly()
		{
			var binding = fPropertyBinding;
			if (binding == null)
				return true;
			
			var property = binding.Property;
			if (property == null)
				return true;
			
			if (!property.CanWrite)
				return true;
				
			return IsReadOnly || BoundControl.IsDataSourceReadOnly(DataSource);
		}
		private object p_GetBoundValue()
		{
			var dataSource = DataSource;
			if (dataSource == null)
				return null;
			
			var binding = fPropertyBinding;
			if (binding == null)
				return null;
			
			var property = binding.Property;
			if (property == null)
				return null;
			
			return property.GetValue(dataSource, null);
		}
		
		private bool fMustRecreate;
		private void p_MustRecreate()
		{
			if (fMustRecreate)
				return;
			
			fMustRecreate = true;
			Dispatcher.BeginInvoke(new Action(p_RecreateNow));
		}
		private void p_RecreateNow()
		{
			fMustRecreate = false;
			
			var binding = fPropertyBinding;
			if (binding == null)
			{
				fValueControl.DataType = null;
				fValueControl.DisplayName = null;
				return;
			}
			
			if (fCanShowDisplayName)
				fValueControl.DisplayName = binding.ToString();
			else
				fValueControl.DisplayName = null;
				
			var property = binding.Property;
			if (property != null)
				fValueControl.DataType = property.PropertyType;
			
			ReadFromDataSource();
		}
		
		/// <summary>
		/// Method invoked when the value of this control changes.
		/// </summary>
		protected virtual void OnValueChanged(ValueChangedEventArgs args)
		{
			args.RoutedEvent = ValueControl.ValueChangedEvent;
			RaiseEvent(args);
		}
		
		/// <summary>
		/// Event invoked when the value of this control changes.
		/// </summary>
		public event EventHandler<ValueChangedEventArgs> ValueChanged
		{
			add
			{
				AddHandler(ValueControl.ValueChangedEvent, value);
			}
			remove
			{
				RemoveHandler(ValueControl.ValueChangedEvent, value);
			}
		}
		
		/// <summary>
		/// Event invoked when an exception is thrown during the process of 
		/// ValueChange.
		/// </summary>
		public event EventHandler<ValueExceptionEventArgs> ValueChangeThrownException
		{
			add
			{
				AddHandler(ValueControl.ValueChangeThrownExceptionEvent, value);
			}
			remove
			{
				RemoveHandler(ValueControl.ValueChangeThrownExceptionEvent, value);
			}
		}

		#region IDataSourceChangedHandler Members
			void IDataSourceChangedHandler.OnDataSourceChanged(DependencyPropertyChangedEventArgs args)
			{
				if (!fMustRecreate)
					ReadFromDataSource();
			}
		#endregion
		#region IIsReadOnlyChangedHandler Members
			void IIsReadOnlyChangedHandler.OnIsReadOnlyChanged(DependencyPropertyChangedEventArgs args)
			{
				fValueControl.IsReadOnly = p_IsReadOnly();
			}
		#endregion
	}
	
	/// <summary>
	/// A property-bound control that uses the DataSource as a System.Object.
	/// </summary>
	public sealed class ObjectPropertyBoundControl:
		PropertyBoundControl<object>
	{
	}
}