//#define DEBUG_TRACE
using System;
using System.Collections;
using System.Diagnostics;
using System.Reflection;
using System.Windows;
using System.Windows.Controls;

namespace ClassLibrary1
{
	[Obfuscation(Exclude = true)]
	internal static class CloneObject
	{
		// Extension for any class object
		internal static TT DeepClone<TT>(this TT source)
		{ // Jim McCurdy's DeepClone
			TT clone = CloneRecursive(source);

			if (clone is FrameworkElement)
			{
				FrameworkElement cloneElement = (clone as FrameworkElement);
				cloneElement.Arrange(new Rect(0, 0, cloneElement.ActualWidth, cloneElement.ActualHeight));
			}

			return clone;
		}

		private static TT CloneRecursive<TT>(TT source)
		{
			if (source == null || source.GetType().IsValueType)
				return source;

			// Common types that do not have parameterless constructors
			if (source is string || source is Type || source is Uri || source is DependencyProperty)
				return source;

			TT clone = CloneCreate(source);
			if (clone == null)
				return source;

			if (source is IList && clone is IList)
				CloneList(source as IList, clone as IList);
			else
				CloneProperties(source, clone);

			return clone;
		}

		private static TT CloneCreate<TT>(TT source)
		{
			try
			{
#if DEBUG_TRACE
				string.Format("Clone create object Type={0}", 
					SimpleType(source.GetType())).Trace();
#endif
				Array sourceArray = (source as Array);
				if (sourceArray == null)
					return (TT)Activator.CreateInstance(source.GetType());
				if (sourceArray.Rank == 1)
					return (TT)(object)Array.CreateInstance(source.GetType().GetElementType(),
						sourceArray.GetLength(0));
				if (sourceArray.Rank == 2)
					return (TT)(object)Array.CreateInstance(source.GetType().GetElementType(),
						sourceArray.GetLength(0), sourceArray.GetLength(1));
			}
			catch (Exception ex)
			{
				if (ex.Message.Contains("No parameterless constructor"))
					return default(TT);
				string.Format("Can't create object Type={0}", SimpleType(source.GetType())).Trace();
				ex.DebugOutput();
			}

			return default(TT);
		}

		private static void CloneProperties(object source, object clone)
		{
			// The binding flags indicate what properties we will clone
			// Unfortunately, we cannot clone "internal" or "protected" properties
			BindingFlags flags = 
				BindingFlags.Instance | BindingFlags.FlattenHierarchy | BindingFlags.Public;

			// Clone dependency properties
			Type loopType = source.GetType();
			while (loopType != null && loopType != typeof(DependencyObject))
			{
				FieldInfo[] fieldInfoArray = loopType.GetFields(flags | BindingFlags.Static);
				foreach (FieldInfo field in fieldInfoArray)
					CloneDependencyProperty(source as DependencyObject, clone as DependencyObject, field);

				loopType = loopType.BaseType;
			}

			// Clone CLR properties
			PropertyInfo[] properties = source.GetType().GetProperties(flags);
			foreach (PropertyInfo property in properties)
				CloneProperty(source, clone, property);
		}

		private static void CloneDependencyProperty(DependencyObject sourceObject, 
			DependencyObject cloneObject, FieldInfo field)
		{
			try
			{
				if (sourceObject == null || cloneObject == null)
					return;
				if (field.IsPrivate || (field.Attributes & FieldAttributes.Private) != 0)
					return;
				if (!field.IsStatic || (field.Attributes & FieldAttributes.Static) == 0)
					return;

				// Blacklisted properties that can't (or shouldn't) be set
				if (field.Name == "NameProperty" && sourceObject is FrameworkElement) return;

				DependencyProperty dp = field.GetValue(sourceObject) as DependencyProperty;
				if (dp == null) // Event DependencyProperties will be null
					return;

				object sourceValue = sourceObject.GetValue(dp);
				if (sourceValue == null)
					return;
#if DEBUG_TRACE
				string.Format("Clone dependency property Name={0}, Value={2} for source Type={1}", 
					field.Name, SimpleType(sourceObject.GetType()), sourceValue).Trace();
#endif
				// Blacklisted properties that can't (or don't need to be) cloned
				bool doClone = true;
				if (field.Name == "DataContextProperty") doClone = false;
				//if (field.Name == "TargetPropertyProperty") doClone = false;

				object cloneValue = (doClone ? CloneRecursive(sourceValue) : sourceValue);
				cloneObject.SetValue(dp, cloneValue);
			}
			catch (Exception ex)
			{
				if (ex.Message.Contains("read-only"))
					return;
				if (ex.Message.Contains("read only"))
					return;
				if (ex.Message.Contains("does not fall within the expected range"))
					return;
				string.Format("Can't clone dependency property Name={0}, for source Type={1}", 
					field.Name, SimpleType(sourceObject.GetType())).Trace();
				ex.DebugOutput();
			}
		}

		private static void CloneProperty(object source, object clone, PropertyInfo property)
		{
			try
			{
				// Blacklisted properties that can't (or shouldn't) be set
				if (property.Name == "Name" && source is FrameworkElement) return;
				if (property.Name == "InputScope" && source is TextBox) return; // Can't get
				if (property.Name == "Watermark" && source is TextBox) return; // Can't get
				if (property.Name == "Source" && source is ResourceDictionary) return; // Can't set
				if (property.Name == "TargetType" && source is ControlTemplate) return; // Can't set

				bool publicSetter = (source.GetType().GetMethod("set_" + property.Name) != null);
				bool isList = (property.PropertyType.GetInterface("IList", true) != null);
				bool canWrite = property.CanWrite && publicSetter;
				bool canHandleWrite = canWrite || isList;
				if (!property.CanRead || !canHandleWrite || property.GetIndexParameters().Length != 0)
					return;

				object sourceValue = property.GetValue(source, null);
				if (sourceValue == null)
					return;

				if (!canWrite && isList)
				{
					IList cloneList = property.GetValue(clone, null) as IList;
					if (cloneList != null)
						CloneList(sourceValue as IList, cloneList);
					return;
				}
#if DEBUG_TRACE
				string.Format("Clone property Type={0}, Name={1}, Value={3} for source Type={2}", 
					SimpleType(property.PropertyType), property.Name, SimpleType(source.GetType()), 
					sourceValue).Trace();
#endif
				// Blacklisted properties that can't (or don't need to be) cloned
				bool doClone = true;
				if (source is FrameworkElement && property.Name == "DataContext") doClone = false;
				//if (property.Name == "TargetProperty") doClone = false;

				object cloneValue = (doClone ? CloneRecursive(sourceValue) : sourceValue);
				property.SetValue(clone, cloneValue, null); // possible MethodAccessException
			}
			catch (Exception ex)
			{
				string.Format("Can't clone property Type={0}, Name={1}, for source Type={2}", 
					SimpleType(property.PropertyType), property.Name, SimpleType(source.GetType())).Trace();
				ex.DebugOutput();
			}
		}

		private static void CloneList(IList sourceList, IList cloneList)
		{
			try
			{
				IEnumerator sourceEnumerator = sourceList.GetEnumerator();
				Array sourceArray = sourceList as Array;
				Array cloneArray = cloneList as Array;
				int dim0 = (sourceArray != null && sourceArray.Rank > 0 ? sourceArray.GetLowerBound(0) : 0);
				int dim1 = (sourceArray != null && sourceArray.Rank > 1 ? sourceArray.GetLowerBound(1) : 0);

				while (sourceEnumerator.MoveNext())
				{
					object sourceValue = sourceEnumerator.Current;
#if DEBUG_TRACE
					string.Format("Clone IList item {0}", sourceValue).Trace();
#endif
					object cloneValue = CloneRecursive(sourceValue);
					if (sourceArray == null)
						cloneList.Add(cloneValue);
					else
					if (sourceArray.Rank == 1)
						cloneArray.SetValue(cloneValue, dim0++);
					else
					if (sourceArray.Rank == 2)
					{
						cloneArray.SetValue(cloneValue, dim0, dim1);
						if (++dim1 > sourceArray.GetUpperBound(1))
						{
							dim1 = sourceArray.GetLowerBound(1);
							if (++dim0 > sourceArray.GetUpperBound(0))
								dim0 = sourceArray.GetLowerBound(0);
						}
					}
				}
			}
			catch (Exception ex)
			{
				string.Format("Can't clone IList item Type={0}", SimpleType(sourceList.GetType())).Trace();
				ex.DebugOutput();
			}
		}

		private static string SimpleType(Type type)
		{
			string typeName = type.ToString();
			int index = typeName.LastIndexOf('[');
			if (index < 0)
				return typeName.Substring(typeName.LastIndexOf('.') + 1);

			string collectionName = typeName.Substring(index);
			collectionName = collectionName.Substring(collectionName.LastIndexOf('.') + 1);
			typeName = typeName.Substring(0, index);
			typeName = typeName.Substring(typeName.LastIndexOf('.') + 1);
			return typeName + '[' + collectionName;
		}
	}

	internal static class Extensions
	{
		// Extension for Exception  
		internal static void DebugOutput(this Exception ex)
		{
#if DEBUG
			Debug.WriteLine(ex.GetType().ToString() + ": " + ex.Message + Environment.NewLine);
#endif
		}

		// Extension for string  
		internal static void Trace(this string message)
		{
			Debug.WriteLine(message);
		}
	}
}

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Windows;
using System.Windows.Automation.Peers;
using System.Windows.Automation.Provider;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media;

namespace ClassLibrary
{
	public static class MouseWheelProps
	{
		// The Enabled attached property
		public static readonly DependencyProperty EnabledProperty = 
			DependencyProperty.RegisterAttached("Enabled", typeof(bool), typeof(MouseWheelProps),
				new PropertyMetadata(false, OnEnabledPropertyChanged));

		public static bool GetEnabled(FrameworkElement element)
		{
			return (bool)element.GetValue(EnabledProperty);
		}

		public static void SetEnabled(FrameworkElement element, bool value)
		{
			element.SetValue(EnabledProperty, value);
		}

		private static void OnEnabledPropertyChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
		{
			UIElement element = sender as UIElement;
			if (element == null)
				return;
			bool enabled = (bool)e.NewValue;
			if (enabled)
				element.MouseWheel += OnMouseWheel;
			else
				element.MouseWheel -= OnMouseWheel;
		}

		private static void OnMouseWheel(object sender, MouseWheelEventArgs e)
		{
			if (e.Handled)
				return;

			UIElement element = sender as UIElement;
			if (element == null)
				return;

			AutomationPeer peer = FrameworkElementAutomationPeer.FromElement(element);
			if (peer == null)
				peer = FrameworkElementAutomationPeer.CreatePeerForElement(element);
			if (peer == null)
				return;

			// try to get the scroll provider or the range provider
			IScrollProvider m_ScrollProvider = peer.GetPattern(PatternInterface.Scroll) as IScrollProvider;
			IRangeValueProvider m_RangeValueProvider = null;
			if ((element is Control) && (element as Control).HasFocus())
				m_RangeValueProvider = peer.GetPattern(PatternInterface.RangeValue) as IRangeValueProvider;
			if (m_ScrollProvider == null && m_RangeValueProvider == null)
				return;

			// set scroll amount
			const double kMultiplier = 5.0; // x times the default
			const double kFactor = kMultiplier / (30 * 120);
			double delta = e.Delta;
			delta *= kFactor;
			int direction = Math.Sign(delta);

			bool shiftKey = (Keyboard.Modifiers & ModifierKeys.Shift) != 0;
			bool controlKey = (Keyboard.Modifiers & ModifierKeys.Control) != 0;

			if (m_ScrollProvider != null)
			{
				e.Handled = true;
#if true
				if (m_ScrollProvider.VerticallyScrollable && !controlKey)
				{
					double percent = m_ScrollProvider.VerticalScrollPercent - (delta * m_ScrollProvider.VerticalViewSize);
					if (percent < 0) percent = 0;
					if (percent > 100) percent = 100;
					m_ScrollProvider.SetScrollPercent(m_ScrollProvider.HorizontalScrollPercent, percent);
				}
				else
				if (m_ScrollProvider.HorizontallyScrollable && controlKey)
				{
					double percent = m_ScrollProvider.HorizontalScrollPercent - (delta * m_ScrollProvider.HorizontalViewSize);
					if (percent < 0) percent = 0;
					if (percent > 100) percent = 100;
					m_ScrollProvider.SetScrollPercent(percent, m_ScrollProvider.VerticalScrollPercent);
				}
#else
				ScrollAmount scrollAmount = (direction < 0) ? ScrollAmount.SmallIncrement : ScrollAmount.SmallDecrement;
				if (m_ScrollProvider.VerticallyScrollable && !controlKey)
					m_ScrollProvider.Scroll(ScrollAmount.NoAmount, scrollAmount);
				else
				if (m_ScrollProvider.HorizontallyScrollable && controlKey)
					m_ScrollProvider.Scroll(scrollAmount, ScrollAmount.NoAmount);
#endif
			}

			if (m_RangeValueProvider != null)
			{
				e.Handled = true;
				double newValue = m_RangeValueProvider.Value + (direction < 0 ? -m_RangeValueProvider.LargeChange : m_RangeValueProvider.LargeChange);
				if (newValue >= m_RangeValueProvider.Minimum && newValue <= m_RangeValueProvider.Maximum)
					m_RangeValueProvider.SetValue(newValue);
			}
		}
	}

	internal static class ExtensionMethods
	{
		// Extension for UIElement
		internal static bool HasFocus(this UIElement element)
		{
			if (element == null)
				return false;

			DependencyObject focusedElement = FocusManager.GetFocusedElement() as DependencyObject;
			while (focusedElement != null)
			{
				if (element == focusedElement)
					return true;
				focusedElement = VisualTreeHelper.GetParent(focusedElement);
			}

			return false;
		}
	}
}

<UserControl x:Class="SilverlightApplication.MainPage"
	xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
	xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
	xmlns:app="clr-namespace:SilverlightApplication"
	xmlns:DataGrid="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Data"
>
	<Grid>
		<DataGrid:DataGrid c:MouseWheelProps.Enabled="True" />
	</Grid>
</UserContro>

<UserControl x:Class="SilverlightApplication.MainPage"
	xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
	xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
	xmlns:app="clr-namespace:SilverlightApplication"
	xmlns:DataGrid="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Data"
>
	<Grid>
		<Grid.Resources>
			<Style x:Key="CommonDataGrid" TargetType="DataGrid:DataGrid">
				<Setter Property="c:MouseWheelProps.Enabled" Value="True" />
			</Style>
		</Grid.Resources>
		<DataGrid:DataGrid Style="{StaticResource CommonDataGrid}" />
	</Grid>
</UserContro>

using System;
using System.IO;
using System.Reflection;
using System.Windows;
using System.Windows.Documents;
using System.Windows.Markup;
using System.Windows.Media.Imaging;
using System.Windows.Resources;
using System.Xml;

namespace ClassLibrary
{
	// Get resource files, or resource file streams, either from...
	//  o  an assembly in the XAP (Resource build action)
	//  o  the XAP itself (Content build action)
	//
	// Typical usage:
	//
	// Get content directly: bitmaps, file text, fonts, XAML, or XML
	//
	//		BitmapImage bitmap1 = ResourceFile.GetBitmap("Images/Clouds.jpg", From.App);
	//
	// Get content from a ZIP:
	//
	//		BitmapImage bitmap2 = ResourceFile.GetBitmapFromZip("Content/Zips/Files.zip", "Clouds.jpg", From.App);
	//
	// Get content streams:
	//
	//		Stream bitmapStream = ResourceFile.GetStream("Images/Clouds.jpg", From.App);
	//		Stream zipStream = ResourceFile.GetStream("Content/Zips/Files.zip", From.App);

	internal static class ResourceFile
	{
		// Get a bitmap from an assembly or the XAP
		internal static BitmapImage GetBitmap(string relativeUri, From assembly)
		{
			Stream stream = GetStream(relativeUri, assembly);
			return GetBitmapFromStream(stream);
		}

		// Get a bitmap from a zip file in an assembly or the XAP
		internal static BitmapImage GetBitmapFromZip(string relativeZipUri, string relativeUri, From assembly)
		{
			Stream stream = GetStreamFromZip(relativeZipUri, relativeUri, assembly);
			return GetBitmapFromStream(stream);
		}

		// Get a bitmap from a stream
		internal static BitmapImage GetBitmapFromStream(Stream stream)
		{
			if (stream == null)
				return null;

			BitmapImage bitmap = new BitmapImage();
			bitmap.SetSource(stream);
			return bitmap;
		}

		// Get file text from an assembly or the XAP
		internal static string GetFileText(string relativeUri, From assembly)
		{
			Stream stream = GetStream(relativeUri, assembly);
			return GetFileTextFromStream(stream);
		}

		// Get file text from a zip file in an assembly or the XAP
		internal static string GetFileTextFromZip(string relativeZipUri, string relativeUri, From assembly)
		{
			Stream stream = GetStreamFromZip(relativeZipUri, relativeUri, assembly);
			return GetFileTextFromStream(stream);
		}

		// Get file text from a stream
		internal static string GetFileTextFromStream(Stream stream)
		{
			if (stream == null)
				return null;

			using (StreamReader reader = new StreamReader(stream))
			{
				if (reader == null)
					return null;
				return reader.ReadToEnd();
			}
		}

		// Get a font from an assembly or the XAP
		internal static FontSource GetFont(string relativeUri, From assembly)
		{
			Stream stream = GetStream(relativeUri, assembly);
			return GetFontFromStream(stream);
		}

		// Get a font from a zip file in an assembly or the XAP
		internal static FontSource GetFontFromZip(string relativeZipUri, string relativeUri, From assembly)
		{
			Stream stream = GetStreamFromZip(relativeZipUri, relativeUri, assembly);
			return GetFontFromStream(stream);
		}

		// Get a font from a stream
		internal static FontSource GetFontFromStream(Stream stream)
		{
			if (stream == null)
				return null;

			return new FontSource(stream);
		}

		// Get XAML from an assembly or the XAP
		internal static UIElement GetXaml(string relativeUri, From assembly)
		{
			Stream stream = GetStream(relativeUri, assembly);
			return GetXamlFromStream(stream);
		}

		// Get XAML from a zip file in an assembly or the XAP
		internal static UIElement GetXamlFromZip(string relativeZipUri, string relativeUri, From assembly)
		{
			Stream stream = GetStreamFromZip(relativeZipUri, relativeUri, assembly);
			return GetXamlFromStream(stream);
		}

		// Get XAML from a stream
		internal static UIElement GetXamlFromStream(Stream stream)
		{
			if (stream == null)
				return null;

			return XamlReader.Load(GetFileTextFromStream(stream)) as UIElement;
		}

		// Get an XML Reader from an assembly or the XAP
		internal static XmlReader GetXmlReader(string relativeUri, From assembly)
		{
			Stream stream = GetStream(relativeUri, assembly);
			return GetXmlReaderFromStream(stream);
		}

		// Get an XML Reader from a zip file in an assembly or the XAP
		internal static XmlReader GetXmlReaderFromZip(string relativeZipUri, string relativeUri, From assembly)
		{
			Stream stream = GetStreamFromZip(relativeZipUri, relativeUri, assembly);
			return GetXmlReaderFromStream(stream);
		}

		// Get an XML Reader from a stream
		internal static XmlReader GetXmlReaderFromStream(Stream stream)
		{
			XmlReaderSettings settings = new XmlReaderSettings();
			settings.DtdProcessing = DtdProcessing.Ignore;
			settings.IgnoreWhitespace = false;
			settings.IgnoreProcessingInstructions = true;
			settings.IgnoreComments = true;
			try
			{
				return XmlReader.Create(stream, settings);
			}
			catch (Exception ex)
			{
				MessageBox.Show(ex.Message, "Alert", MessageBoxButton.OK);
				return null;
			}
		}

		// Get an XML text string from an XmlReader
		internal static string GetXmlFromXmlReader(XmlReader xmlReader)
		{
			return (xmlReader != null ? xmlReader.ReadOuterXml() : null);
		}

		// Get a resource file stream info from an assembly or the XAP
		internal static StreamResourceInfo GetStreamInfo(string relativeUri, From assembly)
		{
			StreamResourceInfo streamInfo = Application.GetResourceStream(new Uri(relativeUri, UriKind.Relative));
			if (streamInfo != null) // found in the XAP
				return streamInfo;

			string componentFormat = assembly.Name + ";component/{0}";
			string assemblyUri = string.Format(componentFormat, relativeUri);
			streamInfo = Application.GetResourceStream(new Uri(assemblyUri, UriKind.Relative));
			if (streamInfo != null) // found in the assembly
				return streamInfo;

			// Last chance!
			// Resource files added to a VS project as "links" (Add / Existing Item / Add As Link)
			// must be accessed without a path
			int pathMarker = relativeUri.LastIndexOf('/');
			if (pathMarker < 0)
				return null;

			assemblyUri = string.Format(componentFormat, relativeUri.Substring(pathMarker + 1));
			streamInfo = Application.GetResourceStream(new Uri(assemblyUri, UriKind.Relative));
			if (streamInfo != null) // found in the assembly
				return streamInfo;

			return null; // not found
		}

		// Get a resource file stream from an assembly or the XAP
		internal static Stream GetStream(string relativeUri, From assembly)
		{
			StreamResourceInfo streamInfo = GetStreamInfo(relativeUri, assembly);
			if (streamInfo == null)
				return null;

			return streamInfo.Stream;
		}

		// Get a resource file stream from inside a ZIP stream
		internal static Stream GetStreamFromZip(string relativeZipUri, string relativeUri, From assembly)
		{
			Stream zipStream = GetStream(relativeZipUri, assembly);
			if (zipStream == null)
				return null;

			return GetStreamFromZipStream(zipStream, relativeUri);
		}

		// Get a resource file stream from inside a ZIP stream
		internal static Stream GetStreamFromZipStream(Stream zipStream, string relativeUri)
		{
			if (zipStream == null)
				return null;

			StreamResourceInfo zipInfo = new StreamResourceInfo(zipStream, null);
			StreamResourceInfo streamInfo = Application.GetResourceStream(zipInfo, new Uri(relativeUri, UriKind.Relative));
			if (streamInfo == null)
				streamInfo = Application.GetResourceStream(new Uri(relativeUri, UriKind.Relative));
			if (streamInfo == null)
				return null;

			return streamInfo.Stream;
		}
	}

	// Calls to access file resources are assisted by a tiny static class called "From"
	// which is used to indicate the assembly that contains resource files.
	//	From.App - the current application assembly
	//	From.This - the caller's assembly
	//	From.Library - a library assembly
	//	From.Type<ClassLibrary> - an assembly containing a known type
	internal class From
	{
		internal Assembly Assembly { get; set; }
		internal string Name { get { return (Assembly != null ? Assembly.FullName.Substring(0, Assembly.FullName.IndexOf(',')) : null); } }

		// From current application assembly
		internal static From App { get { return new From() { Assembly = Application.Current.GetType().Assembly }; } }

		// From the caller's assembly
		internal static From This { get { return new From() { Assembly = Assembly.GetCallingAssembly() }; } }

		// From a library assembly
		internal static From Library { get { return new From() { Assembly = Assembly.GetExecutingAssembly() }; } }

		// From an assembly containing a known type
		internal static From Type<TT>() { return new From() { Assembly = typeof(TT).Assembly }; }
	}
}

	<TextBlock x:Name="x_TestText" FontFamily="CacMoose.ttf#CAC Moose" /> 
or… 
	<TextBlock x:Name="x_TestText" FontFamily="Content/Zips/Files.zip#CAC Moose" />