WpfDesigner/WpfDesign.XamlDom/Project/XamlObject.cs

// Copyright (c) 2019 AlphaSierraPapa for the SharpDevelop Team
// 
// Permission is hereby granted, free of charge, to any person obtaining a copy of this
// software and associated documentation files (the "Software"), to deal in the Software
// without restriction, including without limitation the rights to use, copy, modify, merge,
// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
// to whom the Software is furnished to do so, subject to the following conditions:
// 
// The above copyright notice and this permission notice shall be included in all copies or
// substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Windows.Markup;
using System.Xml;
using System.Windows.Data;
using System.Windows;
using System.Xaml;

namespace ICSharpCode.WpfDesign.XamlDom
{
	/// <summary>
	/// Represents a xaml object element.
	/// </summary>
	[DebuggerDisplay("XamlObject: {Instance}")]
	public sealed class XamlObject : XamlPropertyValue
	{
		XamlDocument document;
		XmlElement element;
		Type elementType;
		object instance;
		List<XamlProperty> properties = new List<XamlProperty>();
		string contentPropertyName;
		XamlProperty nameProperty;
		string runtimeNameProperty;

		/// <summary>For use by XamlParser only.</summary>
		internal XamlObject(XamlDocument document, XmlElement element, Type elementType, object instance)
		{
			this.document = document;
			this.element = element;
			this.elementType = elementType;
			this.instance = instance;

			this.contentPropertyName = GetContentPropertyName(elementType);
			XamlSetTypeConverter = GetTypeConverterDelegate(elementType);

			ServiceProvider = new XamlObjectServiceProvider(this);
			CreateWrapper();
			
			var rnpAttrs = elementType.GetCustomAttributes(typeof(RuntimeNamePropertyAttribute), true) as RuntimeNamePropertyAttribute[];
			if (rnpAttrs != null && rnpAttrs.Length > 0 && !String.IsNullOrEmpty(rnpAttrs[0].Name)) {
				runtimeNameProperty = rnpAttrs[0].Name;
			}
		}
		
		/// <summary>For use by XamlParser only.</summary>
		internal void AddProperty(XamlProperty property)
		{
			#if DEBUG
			if (property.IsAttached == false) {
				foreach (XamlProperty p in properties) {
					if (p.IsAttached == false && p.PropertyName == property.PropertyName)
						throw new XamlLoadException("duplicate property:" + property.PropertyName);
				}
			}
			#endif
			properties.Add(property);
		}
		
		#region XamlPropertyValue implementation
		internal override object GetValueFor(XamlPropertyInfo targetProperty)
		{
			if (IsMarkupExtension) {
				var value = ProvideValue();
				if (value is string && targetProperty != null && targetProperty.ReturnType != typeof(string)) {
					return XamlParser.CreateObjectFromAttributeText((string)value, targetProperty, this);
				}
				return value;
			} else {
				return instance;
			}
		}
		
		internal override XmlNode GetNodeForCollection()
		{
			return element;
		}
		#endregion
		
		XamlObject parentObject;
		
		/// <summary>
		/// Gets the parent object.
		/// </summary>
		public XamlObject ParentObject {
			get {
				return parentObject;
			}
			internal set { parentObject = value; }
		}
		
		internal override void OnParentPropertyChanged()
		{
			parentObject = (ParentProperty != null) ? ParentProperty.ParentObject : null;
			base.OnParentPropertyChanged();
		}

		public XmlElement XmlElement {
			get { return element; }
		}

		public PositionXmlElement PositionXmlElement
		{
			get { return element as PositionXmlElement; }
		}

		XmlAttribute xmlAttribute;

		internal XmlAttribute XmlAttribute {
			get { return xmlAttribute; }
			set {
				xmlAttribute = value;
				element = VirtualAttachTo(XmlElement, value.OwnerElement);
			}
		}

		string GetPrefixOfNamespace(string ns, XmlElement target)
		{
			if (target.NamespaceURI == ns)
				return null;
			var prefix = target.GetPrefixOfNamespace(ns);
			if (!string.IsNullOrEmpty(prefix))
				return prefix;
			var obj = this;
			while (obj != null)
			{
				prefix = obj.XmlElement.GetPrefixOfNamespace(ns);
				if (!string.IsNullOrEmpty(prefix))
					return prefix;
				obj = obj.ParentObject;
			}
			return null;
		}
		
		XmlElement VirtualAttachTo(XmlElement e, XmlElement target)
		{
			var prefix = GetPrefixOfNamespace(e.NamespaceURI, target);
			
			XmlElement newElement = e.OwnerDocument.CreateElement(prefix, e.LocalName, e.NamespaceURI);

			foreach (XmlAttribute a in target.Attributes) {
				if (a.Prefix == "xmlns" || a.Name == "xmlns") {
					newElement.Attributes.Append(a.Clone() as XmlAttribute);
				}
			}

			while (e.HasChildNodes) {
				newElement.AppendChild(e.FirstChild);
			}

			XmlAttributeCollection ac = e.Attributes;
			while (ac.Count > 0) {
				newElement.Attributes.Append(ac[0]);
			}
			
			return newElement;
		}
		
		/// <summary>
		/// Gets the name of the content property for the specified element type, or null if not available.
		/// </summary>
		/// <param name="elementType">The element type to get the content property name for.</param>
		/// <returns>The name of the content property for the specified element type, or null if not available.</returns>
		internal static string GetContentPropertyName(Type elementType)
		{
			var contentAttrs = elementType.GetCustomAttributes(typeof(ContentPropertyAttribute), true) as ContentPropertyAttribute[];
			if (contentAttrs != null && contentAttrs.Length > 0) {
				return contentAttrs[0].Name;
			}
			
			return null;
		}

		internal delegate void TypeConverterDelegate(Object targetObject, XamlSetTypeConverterEventArgs eventArgs);

		internal TypeConverterDelegate XamlSetTypeConverter { get; private set; }

		internal static TypeConverterDelegate GetTypeConverterDelegate(Type elementType)
		{
			var attrs = elementType.GetCustomAttributes(typeof(XamlSetTypeConverterAttribute), true) as XamlSetTypeConverterAttribute[];
			if (attrs != null && attrs.Length > 0)
			{
				var name = attrs[0].XamlSetTypeConverterHandler;
				var method=elementType.GetMethod(name, BindingFlags.Static|BindingFlags.Public|BindingFlags.NonPublic);

				return (TypeConverterDelegate) TypeConverterDelegate.CreateDelegate(typeof(TypeConverterDelegate), method);
			}

			return null;
		}

		private XamlType _systemXamlTypeForProperty = null;
		
		/// <summary>
		/// Gets a <see cref="XamlType"/> representing the <see cref="XamlObject.ElementType"/>.
		/// </summary>
		public XamlType SystemXamlTypeForProperty
		{
			get
			{
				if (_systemXamlTypeForProperty == null)
					_systemXamlTypeForProperty = new XamlType(this.ElementType, this.ServiceProvider.SchemaContext);
				return _systemXamlTypeForProperty;
			}
		}

		internal override void AddNodeTo(XamlProperty property)
		{
			XamlObject holder;
			if (!UpdateXmlAttribute(true, out holder)) {
				property.AddChildNodeToProperty(element);
			}
			UpdateMarkupExtensionChain();
		}
		
		internal override void RemoveNodeFromParent()
		{
			if (XmlAttribute != null) {
				XmlAttribute.OwnerElement.RemoveAttribute(XmlAttribute.Name);
				xmlAttribute = null;
			} else {
				XamlObject holder;
				if (!UpdateXmlAttribute(false, out holder)) {
					element.ParentNode.RemoveChild(element);
				}
			}
			//TODO: PropertyValue still there
			//UpdateMarkupExtensionChain();
		}

		//TODO: reseting path property for binding doesn't work in XamlProperty
		//use CanResetValue()
		internal void OnPropertyChanged(XamlProperty property)
		{
			XamlObject holder;
			if (!UpdateXmlAttribute(false, out holder)) {
				if (holder != null &&
				    holder.XmlAttribute != null) {
					holder.XmlAttribute.OwnerElement.RemoveAttributeNode(holder.XmlAttribute);
					holder.xmlAttribute = null;
					holder.ParentProperty.AddChildNodeToProperty(holder.element);
					
					bool isThisUpdated = false;
					foreach(XamlObject propXamlObject in holder.Properties.Where((prop) => prop.IsSet).Select((prop) => prop.PropertyValue).OfType<XamlObject>()) {
						XamlObject innerHolder;
						bool updateResult = propXamlObject.UpdateXmlAttribute(true, out innerHolder);
						Debug.Assert(updateResult || innerHolder == null);
						
						if (propXamlObject == this)
							isThisUpdated = true;
					}
					if (!isThisUpdated)
						this.UpdateXmlAttribute(true, out holder);
				}
			}
			UpdateMarkupExtensionChain();
			
			if (!element.HasChildNodes && !element.IsEmpty) {
				element.IsEmpty = true;
			}
			
			if (property == NameProperty) {
				if (NameChanged != null)
					NameChanged(this, EventArgs.Empty);
			}
		}
		
		void UpdateChildMarkupExtensions(XamlObject obj)
		{
			foreach (var prop in obj.Properties) {
				if (prop.IsSet) {
					var propXamlObject = prop.PropertyValue as XamlObject;
					if (propXamlObject != null) {
						UpdateChildMarkupExtensions(propXamlObject);
					}
				} else if (prop.IsCollection) {
					foreach (var propXamlObject in prop.CollectionElements.OfType<XamlObject>()) {
						UpdateChildMarkupExtensions(propXamlObject);
					}
				}
			}

			if (obj.IsMarkupExtension && obj.ParentProperty != null) {
				obj.ParentProperty.UpdateValueOnInstance();
			}
		}

		void UpdateMarkupExtensionChain()
		{
			UpdateChildMarkupExtensions(this);

			var obj = this.ParentObject;
			while (obj != null && obj.IsMarkupExtension && obj.ParentProperty != null) {
				obj.ParentProperty.UpdateValueOnInstance();
				obj = obj.ParentObject;
			}
		}

		bool UpdateXmlAttribute(bool force, out XamlObject holder)
		{
			holder = FindXmlAttributeHolder();
			if (holder == null && force && IsMarkupExtension) {
				holder = this;
			}
			if (holder != null && MarkupExtensionPrinter.CanPrint(holder)) {
				var s = MarkupExtensionPrinter.Print(holder);
				holder.XmlAttribute = holder.ParentProperty.SetAttribute(s);
				return true;
			}
			return false;
		}

		XamlObject FindXmlAttributeHolder()
		{
			var obj = this;
			while (obj != null && obj.IsMarkupExtension) {
				if (obj.XmlAttribute != null) {
					return obj;
				}
				obj = obj.ParentObject;
			}
			return null;
		}
		
		/// <summary>
		/// Gets the XamlDocument where this XamlObject is declared in.
		/// </summary>
		public XamlDocument OwnerDocument {
			get { return document; }
		}
		
		/// <summary>
		/// Gets the instance created by this object element.
		/// </summary>
		public object Instance {
			get { return instance; }
		}

		/// <summary>
		/// Gets whether this instance represents a MarkupExtension.
		/// </summary>
		public bool IsMarkupExtension {
			get { return instance is MarkupExtension; }
		}

		/// <summary>
		/// Gets whether there were load errors for this object.
		/// </summary>
		public bool HasErrors { get; internal set; }

		/// <summary>
		/// Gets the type of this object element.
		/// </summary>
		public Type ElementType {
			get { return elementType; }
		}
		
		/// <summary>
		/// Gets a read-only collection of properties set on this XamlObject.
		/// This includes both attribute and element properties.
		/// </summary>
		public IList<XamlProperty> Properties {
			get {
				return properties.AsReadOnly();
			}
		}

		/// <summary>
		/// Gets the name of the content property.
		/// </summary>
		public string ContentPropertyName {
			get {
				return contentPropertyName;
			}
		}
		
		/// <summary>
		/// Gets which property name of the type maps to the XAML x:Name attribute.
		/// </summary>
		public string RuntimeNameProperty {
			get {
				return runtimeNameProperty;
			}
		}

		/// <summary>
		/// Gets which property of the type maps to the XAML x:Name attribute.
		/// </summary>
		public XamlProperty NameProperty {
			get {
				if(nameProperty == null && runtimeNameProperty != null)
					nameProperty = FindOrCreateProperty(runtimeNameProperty);
				
				return nameProperty;
			}
		}
		
		/// <summary>
		/// Gets/Sets the name of this XamlObject.
		/// </summary>
		public string Name {
			get
			{
				string name = GetXamlAttribute("Name");
				
				if (String.IsNullOrEmpty(name)) {
					if (NameProperty != null && NameProperty.IsSet)
						name = (string)NameProperty.ValueOnInstance;
				}
				
				if (name == String.Empty)
					name = null;
				
				return name;
			}
			set
			{
				if (String.IsNullOrEmpty(value))
					this.SetXamlAttribute("Name", null);
				else
					this.SetXamlAttribute("Name", value);
			}
		}

		/// <summary>
		/// Finds the specified property, or creates it if it doesn't exist.
		/// </summary>
		public XamlProperty FindOrCreateProperty(string propertyName)
		{
			if (propertyName == null)
				throw new ArgumentNullException("propertyName");
			
//			if (propertyName == ContentPropertyName)
//				return
			
			foreach (XamlProperty p in properties) {
				if (!p.IsAttached && p.PropertyName == propertyName)
					return p;
			}
			PropertyDescriptorCollection propertyDescriptors = TypeDescriptor.GetProperties(instance);
			PropertyDescriptor propertyInfo = propertyDescriptors[propertyName];
			XamlProperty newProperty;

			if (propertyInfo == null) {
				propertyDescriptors = TypeDescriptor.GetProperties(this.elementType);
				propertyInfo = propertyDescriptors[propertyName];
			}

			if (propertyInfo != null) {
				newProperty = new XamlProperty(this, new XamlNormalPropertyInfo(propertyInfo));
			} else {
				EventDescriptorCollection events = TypeDescriptor.GetEvents(instance);
				EventDescriptor eventInfo = events[propertyName];

				if (eventInfo == null) {
					events = TypeDescriptor.GetEvents(this.elementType);
					eventInfo = events[propertyName];
				}

				if (eventInfo != null) {
					newProperty = new XamlProperty(this, new XamlEventPropertyInfo(eventInfo));
				} else {
					throw new ArgumentException("The property '" + propertyName + "' doesn't exist on " + elementType.FullName, "propertyName");
				}
			}
			properties.Add(newProperty);
			return newProperty;
		}
		
		/// <summary>
		/// Finds the specified property, or creates it if it doesn't exist.
		/// </summary>
		public XamlProperty FindOrCreateAttachedProperty(Type ownerType, string propertyName)
		{
			if (ownerType == null)
				throw new ArgumentNullException("ownerType");
			if (propertyName == null)
				throw new ArgumentNullException("propertyName");
			
			foreach (XamlProperty p in properties) {
				if (p.IsAttached && p.PropertyTargetType == ownerType && p.PropertyName == propertyName)
					return p;
			}
			XamlPropertyInfo info = XamlParser.TryFindAttachedProperty(ownerType, propertyName);
			if (info == null) {
				throw new ArgumentException("The attached property '" + propertyName + "' doesn't exist on " + ownerType.FullName, "propertyName");
			}
			XamlProperty newProperty = new XamlProperty(this, info);
			properties.Add(newProperty);
			return newProperty;
		}
		
		/// <summary>
		/// Gets an attribute in the x:-namespace.
		/// </summary>
		public string GetXamlAttribute(string name)
		{
			var value = element.GetAttribute(name, XamlConstants.XamlNamespace);

			if (string.IsNullOrEmpty(value)) {
				value = element.GetAttribute(name, XamlConstants.Xaml2009Namespace);
			}

			return value;
		}
		
		/// <summary>
		/// Sets an attribute in the x:-namespace.
		/// </summary>
		public void SetXamlAttribute(string name, string value)
		{
			XamlProperty runtimeNameProperty = null;
			bool isNameChange = false;
			
			if (name == "Name") {
				isNameChange = true;
				string oldName = GetXamlAttribute("Name");
				
				if (String.IsNullOrEmpty(oldName)) {
					runtimeNameProperty = this.NameProperty;
					if (runtimeNameProperty != null) {
						if (runtimeNameProperty.IsSet)
							oldName = (string)runtimeNameProperty.ValueOnInstance;
						else
							runtimeNameProperty = null;
					}
				}
				
				if (String.IsNullOrEmpty(oldName))
					oldName = null;
				
				NameScopeHelper.NameChanged(this, oldName, value);
			}

			if (value == null)
				element.RemoveAttribute(name, XamlConstants.XamlNamespace);
			else
			{
				var prefix = element.GetPrefixOfNamespace(XamlConstants.XamlNamespace);
				var prefix2009 = element.GetPrefixOfNamespace(XamlConstants.Xaml2009Namespace);
			
				if (!string.IsNullOrEmpty(prefix))
				{
					var attribute = element.OwnerDocument.CreateAttribute(prefix, name, XamlConstants.XamlNamespace);
					attribute.InnerText = value;
					element.SetAttributeNode(attribute);
				}
				else if (!string.IsNullOrEmpty(prefix2009))
				{
					var attribute = element.OwnerDocument.CreateAttribute(prefix, name, XamlConstants.Xaml2009Namespace);
					attribute.InnerText = value;
					element.SetAttributeNode(attribute);
				}
				else
					element.SetAttribute(name, XamlConstants.XamlNamespace, value);
			}
			
			if (isNameChange) {
				bool nameChangedAlreadyRaised = false;
				if (runtimeNameProperty != null) {
					var handler = new EventHandler((sender, e) => nameChangedAlreadyRaised = true);
					this.NameChanged += handler;
					
					try {
						runtimeNameProperty.Reset();
					}
					finally {
						this.NameChanged -= handler;
					}
				}
				
				if (NameChanged != null && !nameChangedAlreadyRaised)
					NameChanged(this, EventArgs.Empty);
			}
		}

		/// <summary>
		/// Gets/Sets the <see cref="XamlObjectServiceProvider"/> associated with this XamlObject.
		/// </summary>
		public XamlObjectServiceProvider ServiceProvider { get; set; }

		MarkupExtensionWrapper wrapper;

		void CreateWrapper()
		{
			if (Instance is BindingBase) {
				wrapper = new BindingWrapper(this);
			} else if (Instance is StaticResourceExtension) {
				wrapper = new StaticResourceWrapper(this);
			}
			
			if (wrapper == null && IsMarkupExtension) {
				var markupExtensionWrapperAttribute = Instance.GetType().GetCustomAttributes(typeof(MarkupExtensionWrapperAttribute), false).FirstOrDefault() as MarkupExtensionWrapperAttribute;
				if(markupExtensionWrapperAttribute != null) {
					wrapper = MarkupExtensionWrapper.CreateWrapper(markupExtensionWrapperAttribute.MarkupExtensionWrapperType, this);
				}
				else {
					wrapper = MarkupExtensionWrapper.TryCreateWrapper(Instance.GetType(), this);
				}
			}
		}

		object ProvideValue()
		{
			if (wrapper != null) {
				return wrapper.ProvideValue();
			}
			if (this.ParentObject != null && this.ParentObject.ElementType == typeof (Setter) && this.ElementType == typeof(DynamicResourceExtension))
				return Instance;
			return (Instance as MarkupExtension).ProvideValue(ServiceProvider);
		}

		internal string GetNameForMarkupExtension()
		{
			string markupExtensionName = XmlElement.Name;
			
			// By convention a markup extension class name typically includes an "Extension" suffix.
			// When you reference the markup extension in XAML the "Extension" suffix is optional.
			// If present remove it to avoid bloating the XAML.
			if (markupExtensionName.EndsWith("Extension", StringComparison.Ordinal)) {
				markupExtensionName = markupExtensionName.Substring(0, markupExtensionName.Length - 9);
			}
			
			return markupExtensionName;
		}
		
		/// <summary>
		/// Is raised when the name of this XamlObject changes.
		/// </summary>
		public event EventHandler NameChanged;
	}

	class BindingWrapper : MarkupExtensionWrapper
	{
		public BindingWrapper(XamlObject xamlObject)
			: base(xamlObject)
		{
		}
		
		public override object ProvideValue()
		{
			var target = XamlObject.Instance as BindingBase;
			Debug.Assert(target != null);
			//TODO: XamlObject.Clone()
			var b = CopyBinding(target);
			return b.ProvideValue(XamlObject.ServiceProvider);
		}
		
		BindingBase CopyBinding(BindingBase target)
		{
			BindingBase b;
			if (target != null) {
				b = (BindingBase)Activator.CreateInstance(target.GetType());
			} else {
				b = new Binding();
			}
			
			foreach (PropertyDescriptor pd in TypeDescriptor.GetProperties(target)) {
				if (pd.IsReadOnly) {
					if (pd.Name.Equals("Bindings", StringComparison.Ordinal)) {
						var bindings = (Collection<BindingBase>)pd.GetValue(target);
						var newBindings = (Collection<BindingBase>)pd.GetValue(b);

						foreach (var binding in bindings) {
							newBindings.Add(CopyBinding(binding));
						}
					}

					continue;
				}
				try {
					var val1 = pd.GetValue(b);
					var val2 = pd.GetValue(target);
					if (object.Equals(val1, val2)) continue;
					pd.SetValue(b, val2);
				} catch {}
			}
			
			return b;
		}
	}

	class StaticResourceWrapper : MarkupExtensionWrapper
	{
		public StaticResourceWrapper(XamlObject xamlObject)
			: base(xamlObject)
		{
		}
		
		public override object ProvideValue()
		{
			var target = XamlObject.Instance as StaticResourceExtension;
			return XamlObject.ServiceProvider.Resolver.FindResource(target.ResourceKey);
		}
	}
}