internal void RegisterNamedItem (XamlObjectElement element, string name)
		{
			IDictionary rd = CurrentDictionary (element);
			if (rd != null && element.X_Key != null) {
				throw ParseException ("The name already exists in the tree.");
			}

			if (element.X_Name != null) {
				throw ParseException ("Cannot specify both Name and x:Name attributes.");
			}

			element.X_Name = name;

			FrameworkElement fe = element.FrameworkElement;
			if (fe != null)
				fe.SetNameOnScope (name, NameScope);
		}

		public static XamlAttachedPropertySetter Create (XamlObjectElement element, Accessors accessors)
		{
			if (accessors == null)
				return null;
			return new XamlAttachedPropertySetter (element, accessors);
		}

		public override void SetValue (XamlObjectElement obj, object value)
		{
			var mutable = value as MutableObject;
			if (mutable != null)
				value = mutable.Object;

			if (!typeof (Binding).IsAssignableFrom (Type)) {
				Binding binding = value as Binding;
				if (binding != null) {
					SetBinding (binding, Element.Object);
					return;
				}
			}

			if (!typeof (TemplateBindingExpression).IsAssignableFrom (Type)) {
				TemplateBindingExpression tb = value as TemplateBindingExpression;
				if (tb != null) {
					SetTemplateBinding (tb, obj.Object);
					return;
				}
			}

			if (value == null || Type.IsAssignableFrom (value.GetType ())) {
				Accessors.Setter (Element.Object, ConvertValue (Type, value));
				return;
			}
				
			if (typeof (IList).IsAssignableFrom (Type)) {
				AddToCollection (value);
				return;
			}

			throw new XamlParseException (
				string.Format ("XamlAttachedPropertySetter.SetValue: Could not set value '{0}' to the attached property '{1}.{2}'",
					value,
					Accessors.DeclaringType,
					Accessors.Name)
			);
		}

		public XamlReflectionEventSetter (XamlObjectElement element, object target, EventInfo evnt) : base (element, evnt.Name,
				Helper.GetConverterFor (evnt, evnt.EventHandlerType))
		{
			this.target = target;
			this.evnt = evnt;
		}

		public XamlNamePropertySetter (XamlObjectElement element, DependencyObject target) : base (element, "Name", null)
		{
			this.target = target;
		}

		XamlReflectionPropertySetter (XamlObjectElement element, object target, Accessors accessors) : base (element, accessors.Name, accessors.ConverterCreator == null ? null : accessors.ConverterCreator ())
		{
			this.target = target;
			this.accessors = accessors;

			if (target is MutableObject)
				is_mutable = true;
		}

		private void AddToCollection (XamlObjectElement obj, object value)
		{
			IList list = accessors.Getter (target) as IList;
			if (list == null) {
				throw Parser.ParseException ("Collection property in non collection type.");
			}

			list.Add (value);
		}

		private void ParseXAttribute (XamlObjectElement element)
		{
			switch (reader.LocalName) {
			case "Key":
				RegisterKeyItem (element, element.Parent, reader.Value);
				return;
			case "Name":
				RegisterNamedItem (element, reader.Value);
				return;
			case "Class":
				// The class attribute is handled when we initialize the element
				return;
			default:
				throw ParseException ("Unknown x: attribute ({0}).", reader.LocalName);
			}
		}

		private object ParseAttributeValue (XamlObjectElement element, XamlPropertySetter property)
		{
			object value = null;

			if (IsMarkupExpression (reader.Value))
				value = ParseAttributeMarkup (element, property);
			else {
				value = XamlTypeConverter.ConvertObject (this, element, property.Type, property.Converter, property.Name, reader.Value);
			}

			return value;
		}

		private void ParseElementAttributes (XamlObjectElement element)
		{
			if (!reader.HasAttributes)
				return;

			try {
				int ac = reader.AttributeCount;
				for (int i = 0; i < reader.AttributeCount; i++) {
					reader.MoveToAttribute (i);
					ParseAttribute (element);
				}
			} finally {
				// We do this in a finally so error reporting doesn't get all jacked up
				reader.MoveToElement();
			}
		}

		private void ParseAttribute (XamlObjectElement element)
		{
			if (IsMcAttribute ()) {
				ParseMcAttribute (element);
				return;
			}
			if (IsXmlnsMapping ()) {
				ParseXmlnsMapping (element);
				return;
			}

			if (IsXAttribute ()) {
				ParseXAttribute (element);
				return;
			}

			if (IsXmlDirective ()) {
				ParseXmlDirective (element);
				return;
			}

			if (IsIgnorable ()) {
				return;
			}

			XamlPropertySetter prop = element.LookupProperty (reader);
			if (prop == null)
				throw ParseException ("The property {0} was not found.", reader.LocalName);
			object value = ParseAttributeValue (element, prop);
			prop.SetValue (value);
		}

		private void ParseTextBlockText (XamlObjectElement block)
		{
		}

		private void ParseTemplateElement ()
		{
			Type t = ResolveType ();
			if (t == null)
				throw ParseException ("Unable to find the type {0}", t);
			object o = InstantiateType (t);

			XamlObjectElement element = new XamlObjectElement (this, reader.LocalName, o);
			OnElementBegin (element);
			
			ParseElementAttributes (element);

			string template_xml = reader.ReadInnerXml ();
			
			FrameworkTemplate template = o as FrameworkTemplate;

			unsafe {
				template.SetXamlBuffer (ParseTemplate, CreateXamlContext (template), template_xml);
			}

			//
			// ReadInnerXml will read our closing </ControlTemplate> tag also, so we manually close things
			//
			OnElementEnd ();
		}

		private void ParseObjectElement ()
		{
			Type t = ResolveType ();
			if (t == null)
				throw ParseException ("Unable to find the type {0}.", reader.LocalName);

			object o = InstantiateType (t);

			XamlObjectElement element = new XamlObjectElement (this, reader.LocalName, o);

			SetElementTemplateScopes (element);
			OnElementBegin (element);
			
			ParseElementAttributes (element);

			// This is a self closing element ie <Rectangle />
			if (reader.IsEmptyElement)
				OnElementEnd ();
		}

		private object ParseAttributeMarkup (XamlObjectElement element, XamlPropertySetter property)
		{
			MarkupExpressionParser parser = new SL4MarkupExpressionParser (element.Object, property.Name, this, element);

			string expression = reader.Value;
			object o = parser.ParseExpression (ref expression);
			return o;
		}

		private void SetElementTemplateScopes (XamlObjectElement element)
		{
			// This whole thing is basically copied from xaml.cpp AddCreatedItem

			DependencyObject el_dob = element.Object as DependencyObject;
			if (el_dob == null)
				return;

			// When instantiating a template, some elements are created which are not explicitly
			// mentioned in the xaml. Therefore we need to keep walking up the tree until we find
			// the last element which we set a value for Control::IsTemplateItem and propagate
			// it from there.


			XamlElement instance = CurrentElement;

			while (instance != null) {

				XamlObjectElement oe = element as XamlObjectElement;
				if (oe == null) {
					instance = instance.Parent;
					continue;
				}

				DependencyObject dob = oe.Object as DependencyObject;
				if (dob == null) {
					instance = instance.Parent;
					continue;
				}

				if (dob.ReadLocalValue (Control.IsTemplateItemProperty) == null) {
					instance = instance.Parent;
					continue;
				}

				el_dob.SetValue (Control.IsTemplateItemProperty, dob.GetValue (Control.IsTemplateItemProperty));
				el_dob.TemplateOwner = dob.TemplateOwner;

				break;
			}
		
			if (instance == null) {
				el_dob.SetValue (Control.IsTemplateItemProperty, Context.IsExpandingTemplate);
				el_dob.TemplateOwner = Context.TemplateBindingSource;
			}

			if (el_dob.GetValue (Control.IsTemplateItemProperty) != null) {
				UserControl uc = el_dob as UserControl;
				if (uc != null) {
				        // I can't come up with a test to verify this fix. However, it does
				        // fix a crasher in olympics when trying to play a new video from
				        // the recommendations list after the curreont video finishes
					NameScope ns = NameScope.GetNameScope (uc);
					NameScope.SetNameScope (uc.Content, ns);
					NameScope.SetNameScope (uc.Resources, ns);
				}
				NameScope.SetNameScope (el_dob, NameScope);
			}
		}

		public XamlReflectionPropertySetter (XamlObjectElement element, object target, PropertyInfo prop) : base (element, prop.Name, Helper.GetConverterFor (prop, prop.PropertyType))
		{
			this.target = target;
			this.prop = prop;
		}

		private void AddToDictionary (XamlObjectElement obj, object value)
		{
			IDictionary rd = accessors.Getter (target) as IDictionary;
			if (rd == null)
				throw Parser.ParseException ("Collection property in non collection type.");

			string key = obj.GetDictionaryKey ();
			if (key == null)
				throw Parser.ParseException ("You must specify an x:Key or x:Name for elements in a ResourceDictionary");

			rd.Add (key, value);
		}

		public override void SetValue (XamlObjectElement obj, object value)
		{
			// We do this first to cover the case where you are setting a list to a list or
			// a resource dictionary to a resource dictionary, binding to a binding, ect
			// as opposed to adding items to the list or dictionary.
			if (Type.IsAssignableFrom (value.GetType ())) {
				prop.SetValue (target, ConvertValue (Type, value), null);
				return;
			}

			{
				Binding binding = value as Binding;
				if (binding != null) {
					SetBinding (binding);
					return;
				}
			}

			{
				TemplateBindingExpression tb = value as TemplateBindingExpression;
				if (tb != null) {
					SetTemplateBinding (tb);
					return;
				}
			}

			if (typeof (IList).IsAssignableFrom (Type)) {
				AddToCollection (obj, value);
				return;
			}

			if (typeof (IDictionary).IsAssignableFrom (Type)) {
				AddToDictionary (obj, value);
				return;
			}

			throw Parser.ParseException ("Unable to set property {0} to value {1}.", Name, value);
		}

		private void AddToDictionary (XamlObjectElement obj, object value)
		{
			IDictionary rd = prop.GetValue (target, null) as IDictionary;
			if (rd == null)
				throw Parser.ParseException ("Collection property in non collection type.");

			rd.Add (obj.X_Key, value);
		}