WPF Control Factory

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

namespace Pfz.WpfControls
{
	/// <summary>
	/// Controls that can be bound to a full record.
	/// </summary>
	public class ObjectBoundControl<ObjectType>:
		UserControl,
		IDataSourceChangedHandler,
		IIsReadOnlyChangedHandler
	{
		internal StackPanel fStackPanel;
		
		/// <summary>
		/// Creates a new RecordBoundControl.
		/// </summary>
		public ObjectBoundControl()
		{
			fStackPanel = new StackPanel();
			Content = fStackPanel;
			fPropertyBindings.CollectionChanged += fBoundProperties_CollectionChanged;
		}

		private bool fMustRecreate;
		void fBoundProperties_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
		{
			p_MustRecreate();
		}
		private void p_MustRecreate()
		{
			if (fMustRecreate)
				return;
			
			fStackPanel.Children.Clear();
			fMustRecreate = true;
			Dispatcher.BeginInvoke(new Action(p_RunMustRecreate));
		}
		private void p_RunMustRecreate()
		{
			if (!fMustRecreate)
				return;
				
			fMustRecreate = false;

			var children = fStackPanel.Children;
			children.Clear();
			
			var propertyBindings = fPropertyBindings;
			foreach(var propertyBinding in propertyBindings)
			{
				if (propertyBinding == null)
				{
					children.Add(new Separator());
					continue;
				}
				
				var control = new PropertyBoundControl<ObjectType>();
				control.PropertyBinding = propertyBinding;
				control.IsReadOnly = IsReadOnly;
				children.Add(control);
			}
			
			var args = new RoutedEventArgs(ObjectBoundControl.PropertyBoundControlsCreatedEvent);
			RaiseEvent(args);
		}
	
		/// <summary>
		/// Gets or sets the record to which this control is bound-to.
		/// </summary>
		[Browsable(false)]
		public ObjectType DataSource
		{
			get
			{
				object result = BoundControl.GetDataSource(this);
				if (result is ObjectType)
					return (ObjectType)result;
				
				return default(ObjectType);
			}
			set
			{
				BoundControl.SetDataSource(this, value);
			}
		}
		
		/// <summary>
		/// Gets or sets a value indicating if this control is read-only.
		/// </summary>
		[DefaultValue(false)]
		public bool IsReadOnly
		{
			get
			{
				return BoundControl.GetIsReadOnly(this);
			}
			set
			{
				BoundControl.SetIsReadOnly(this, value);
			}
		}
		
		private ObservableCollection<PropertyBinding> fPropertyBindings = new ObservableCollection<PropertyBinding>();
		
		/// <summary>
		/// Gets or sets the propeties this control will display.
		/// Example as string property:
		/// FullTypeName.* (which will get all properties)
		/// FullTypeName:PropertyName;OtherPropertyName
		/// FullTypeName:PropertyName=Display name;OtherPropertyName=Other display name
		/// FullTypeName.PropertyName=Display name;OtherFullTypeName.PropertyName=Other display name
		/// </summary>
		[TypeConverter(typeof(PropertyBindingsTypeConverter))]
		public ObservableCollection<PropertyBinding> PropertyBindings
		{
			get
			{
				return fPropertyBindings;
			}
			set
			{
				if (value == fPropertyBindings)
					return;
					
				fPropertyBindings.Clear();
				if (value != null)
					foreach(var item in value)
						fPropertyBindings.Add(item);
			}
		}

		private IEnumerable<PropertyBinding> p_AsBoundProperties(PropertyInfo[] propertyInfos)
		{
			foreach(var propertyInfo in propertyInfos)
				yield return new PropertyBinding { Property = propertyInfo };
		}

		/// <summary>
		/// Refreshes (re-reads) the data in all internal controls.
		/// </summary>
		public void RefreshData()
		{
			fRefreshDataNeeded = false;
			
			bool isReadOnly = IsReadOnly;
			foreach(var control in fStackPanel.Children)
			{
				var valueControl = control as PropertyBoundControl<ObjectType>;
				if (valueControl != null)
				{
					valueControl.IsReadOnly = isReadOnly;
					valueControl.ReadFromDataSource();
				}
			}
		}
		
		private bool fRefreshDataNeeded;
		private void p_RefreshDataNeeded()
		{
			if (fRefreshDataNeeded)
				return;
				
			fRefreshDataNeeded = true;
			Dispatcher.Invoke(new Action(RefreshData));
		}
		
		/// <summary>
		/// Event invoked whenever the child-controls are (re-)created.
		/// </summary>
		public event RoutedEventHandler PropertyBoundControlsCreated
		{
			add
			{
				AddHandler(ObjectBoundControl.PropertyBoundControlsCreatedEvent, value);
			}
			remove
			{
				RemoveHandler(ObjectBoundControl.PropertyBoundControlsCreatedEvent, value);
			}
		}
		
		#region IReadOnlyChangedHandler Members
			void IIsReadOnlyChangedHandler.OnIsReadOnlyChanged(DependencyPropertyChangedEventArgs args)
			{
				p_RefreshDataNeeded();
			}
		#endregion
		#region IDataSourceChangedHandler Members
			void IDataSourceChangedHandler.OnDataSourceChanged(DependencyPropertyChangedEventArgs args)
			{
				RefreshData();
			}
		#endregion
	}
	
	/// <summary>
	/// Non-generic version of ObjectBoundControl. It's here because
	/// Xaml does not support generic-classes and because the events
	/// are better registered only once, as non-generic.
	/// </summary>
	public sealed class ObjectBoundControl:
		ObjectBoundControl<object>
	{
		/// <summary>
		/// Event invoked when the ObjectBoundControl finishes creating all
		/// it's property-bound controls.
		/// </summary>
		public static readonly RoutedEvent PropertyBoundControlsCreatedEvent =
			EventManager.RegisterRoutedEvent
			(
				"PropertyBoundControlsCreated",
				RoutingStrategy.Direct,
				typeof(RoutedEventHandler),
				typeof(ObjectBoundControl)
			);
	}
}