Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Xml.Linq/System/Xml/Linq/XComponentModel.cs

@@ -0,0 +1,463 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Xml.Linq;
+
+namespace MS.Internal.Xml.Linq.ComponentModel
+{
+
+    [SuppressMessage("Microsoft.Performance", "CA1812:AvoidUninstantiatedInternalClasses", Justification="False positive.")]
+    class XTypeDescriptionProvider<T> : TypeDescriptionProvider
+    {
+        public XTypeDescriptionProvider() : base(TypeDescriptor.GetProvider(typeof(T))) {
+        }
+
+        public override ICustomTypeDescriptor GetTypeDescriptor(Type type, object instance) {
+            return new XTypeDescriptor<T>(base.GetTypeDescriptor(type, instance));
+        }
+    }
+
+    class XTypeDescriptor<T> : CustomTypeDescriptor
+    {
+        public XTypeDescriptor(ICustomTypeDescriptor parent) : base(parent) {
+        }
+
+        public override PropertyDescriptorCollection GetProperties() {
+            return GetProperties(null);
+        }
+
+        public override PropertyDescriptorCollection GetProperties(Attribute[] attributes) {
+            PropertyDescriptorCollection properties = new PropertyDescriptorCollection(null);
+            if (attributes == null) {
+                if (typeof(T) == typeof(XElement)) {
+                    properties.Add(new XElementAttributePropertyDescriptor());
+                    properties.Add(new XElementDescendantsPropertyDescriptor());
+                    properties.Add(new XElementElementPropertyDescriptor());
+                    properties.Add(new XElementElementsPropertyDescriptor());
+                    properties.Add(new XElementValuePropertyDescriptor());
+                    properties.Add(new XElementXmlPropertyDescriptor());
+                }
+                else if (typeof(T) == typeof(XAttribute)) {
+                    properties.Add(new XAttributeValuePropertyDescriptor());
+                }
+            }
+            foreach (PropertyDescriptor property in base.GetProperties(attributes)) {
+                properties.Add(property);
+            }
+            return properties;
+        }
+    }
+
+    abstract class XPropertyDescriptor<T, TProperty> : PropertyDescriptor where T : XObject
+    {
+        public XPropertyDescriptor(string name) : base(name, null) {
+        }
+
+        public override Type ComponentType {
+            get { return typeof(T); }
+        }
+
+        public override bool IsReadOnly {
+            get { return true; }
+        }
+
+        public override Type PropertyType {
+            get { return typeof(TProperty); }
+        }
+
+        public override bool SupportsChangeEvents {
+            get { return true; }
+        }
+
+        public override void AddValueChanged(object component, EventHandler handler) {
+            bool hasValueChangedHandler = GetValueChangedHandler(component) != null;
+            base.AddValueChanged(component, handler);
+            if (hasValueChangedHandler) return; 
+            T c = component as T;
+            if (c != null && GetValueChangedHandler(component) != null) {
+                c.Changing += new EventHandler<XObjectChangeEventArgs>(OnChanging);
+                c.Changed += new EventHandler<XObjectChangeEventArgs>(OnChanged);
+            }
+        }
+
+        public override bool CanResetValue(object component) {
+            return false;
+        }
+
+        public override void RemoveValueChanged(object component, EventHandler handler) {
+            base.RemoveValueChanged(component, handler);
+            T c = component as T;
+            if (c != null && GetValueChangedHandler(component) == null) {
+                c.Changing -= new EventHandler<XObjectChangeEventArgs>(OnChanging);
+                c.Changed -= new EventHandler<XObjectChangeEventArgs>(OnChanged);
+            }
+        }
+
+        public override void ResetValue(object component) {
+        }
+
+        public override void SetValue(object component, object value) {
+        }
+
+        public override bool ShouldSerializeValue(object component) {
+            return false; 
+        }
+
+        protected virtual void OnChanged(object sender, XObjectChangeEventArgs args) {
+        }
+
+        protected virtual void OnChanging(object sender, XObjectChangeEventArgs args) {
+        }
+    }
+
+    class XElementAttributePropertyDescriptor : XPropertyDescriptor<XElement, object>
+    {
+        XDeferredSingleton<XAttribute> value;
+        XAttribute changeState;
+
+        public XElementAttributePropertyDescriptor() : base("Attribute") {
+        }
+
+        public override object GetValue(object component) {
+            return value = new XDeferredSingleton<XAttribute>((e, n) => e.Attribute(n), component as XElement, null);
+        }
+
+        protected override void OnChanged(object sender, XObjectChangeEventArgs args) {
+            if (value == null) return;
+            switch (args.ObjectChange) {
+                case XObjectChange.Add:
+                    XAttribute a = sender as XAttribute;
+                    if (a != null && value.element == a.parent && value.name == a.Name) {
+                        OnValueChanged(value.element, EventArgs.Empty);
+                    }
+                    break;
+                case XObjectChange.Remove:
+                    a = sender as XAttribute;
+                    if (a != null && changeState == a) {
+                        changeState = null;
+                        OnValueChanged(value.element, EventArgs.Empty);
+                    }
+                    break;
+            }
+        }
+
+        protected override void OnChanging(object sender, XObjectChangeEventArgs args) {
+            if (value == null) return;
+            switch (args.ObjectChange) {
+                case XObjectChange.Remove:
+                    XAttribute a = sender as XAttribute;
+                    changeState = a != null && value.element == a.parent && value.name == a.Name ? a : null;
+                    break;
+            }
+        }
+    }
+
+    class XElementDescendantsPropertyDescriptor : XPropertyDescriptor<XElement, IEnumerable<XElement>>
+    {
+        XDeferredAxis<XElement> value;
+        XName changeState;
+
+        public XElementDescendantsPropertyDescriptor() : base("Descendants") {
+        }
+
+        public override object GetValue(object component) {
+            return value = new XDeferredAxis<XElement>((e, n) => n != null ? e.Descendants(n) : e.Descendants(), component as XElement, null);
+        }
+
+        protected override void OnChanged(object sender, XObjectChangeEventArgs args) {
+            if (value == null) return;
+            switch (args.ObjectChange) {
+                case XObjectChange.Add:
+                case XObjectChange.Remove:
+                    XElement e = sender as XElement;
+                    if (e != null && (value.name == e.Name || value.name == null)) {
+                        OnValueChanged(value.element, EventArgs.Empty);
+                    }
+                    break;
+                case XObjectChange.Name:
+                    e = sender as XElement;
+                    if (e != null && value.element != e && value.name != null && (value.name == e.Name || value.name == changeState)) {
+                        changeState = null;
+                        OnValueChanged(value.element, EventArgs.Empty);
+                    }
+                    break;
+            }
+        }
+
+        protected override void OnChanging(object sender, XObjectChangeEventArgs args) {
+            if (value == null) return;
+            switch (args.ObjectChange) {
+                case XObjectChange.Name:
+                    XElement e = sender as XElement;
+                    changeState = e != null ? e.Name : null;
+                    break;
+            }
+        }
+    }
+
+    class XElementElementPropertyDescriptor : XPropertyDescriptor<XElement, object>
+    {
+        XDeferredSingleton<XElement> value;
+        XElement changeState;
+
+        public XElementElementPropertyDescriptor() : base("Element") {
+        }
+
+        public override object GetValue(object component) {
+            return value = new XDeferredSingleton<XElement>((e, n) => e.Element(n), component as XElement, null);
+        }
+
+        protected override void OnChanged(object sender, XObjectChangeEventArgs args) {
+            if (value == null) return;
+            switch (args.ObjectChange) {
+                case XObjectChange.Add:
+                    XElement e = sender as XElement;
+                    if (e != null && value.element == e.parent && value.name == e.Name && value.element.Element(value.name) == e) {
+                        OnValueChanged(value.element, EventArgs.Empty);
+                    }
+                    break;
+                case XObjectChange.Remove:
+                    e = sender as XElement;
+                    if (e != null && changeState == e) {
+                        changeState = null;
+                        OnValueChanged(value.element, EventArgs.Empty);
+                    }
+                    break;
+                case XObjectChange.Name:
+                    e = sender as XElement;
+                    if (e != null) {
+                        if (value.element == e.parent && value.name == e.Name && value.element.Element(value.name) == e) {
+                            OnValueChanged(value.element, EventArgs.Empty);
+                        }
+                        else if (changeState == e) {
+                            changeState = null;
+                            OnValueChanged(value.element, EventArgs.Empty);
+                        }
+                    }
+                    break;
+            }
+        }
+
+        protected override void OnChanging(object sender, XObjectChangeEventArgs args) {
+            if (value == null) return;
+            switch (args.ObjectChange) {
+                case XObjectChange.Remove:
+                case XObjectChange.Name:
+                    XElement e = sender as XElement;
+                    changeState = e != null && value.element == e.parent && value.name == e.Name && value.element.Element(value.name) == e ? e : null;
+                    break;
+            }
+        }
+    }
+
+    class XElementElementsPropertyDescriptor : XPropertyDescriptor<XElement, IEnumerable<XElement>>
+    {
+        XDeferredAxis<XElement> value;
+        object changeState;
+
+        public XElementElementsPropertyDescriptor() : base("Elements") {
+        }
+
+        public override object GetValue(object component) {
+            return value = new XDeferredAxis<XElement>((e, n) => n != null ? e.Elements(n) : e.Elements(), component as XElement, null);
+        }
+
+        protected override void OnChanged(object sender, XObjectChangeEventArgs args) {
+            if (value == null) return;
+            switch (args.ObjectChange) {
+                case XObjectChange.Add:
+                    XElement e = sender as XElement;
+                    if (e != null && value.element == e.parent && (value.name == e.Name || value.name == null)) {
+                        OnValueChanged(value.element, EventArgs.Empty);
+                    }
+                    break;
+                case XObjectChange.Remove:
+                    e = sender as XElement;
+                    if (e != null && value.element == (changeState as XContainer) && (value.name == e.Name || value.name == null)) {
+                        changeState = null;
+                        OnValueChanged(value.element, EventArgs.Empty);
+                    }
+                    break;
+                case XObjectChange.Name:
+                    e = sender as XElement;
+                    if (e != null && value.element == e.parent && value.name != null && (value.name == e.Name || value.name == (changeState as XName))) {
+                        changeState = null;
+                        OnValueChanged(value.element, EventArgs.Empty);
+                    }
+                    break;
+            }
+        }
+
+        protected override void OnChanging(object sender, XObjectChangeEventArgs args) {
+            if (value == null) return;
+            switch (args.ObjectChange) {
+                case XObjectChange.Remove:
+                    XElement e = sender as XElement;
+                    changeState = e != null ? e.parent : null;
+                    break;
+                case XObjectChange.Name:
+                    e = sender as XElement;
+                    changeState = e != null ? e.Name : null;
+                    break;
+            }
+        }
+    }
+
+    class XElementValuePropertyDescriptor : XPropertyDescriptor<XElement, string>
+    {
+        XElement element;
+
+        public XElementValuePropertyDescriptor() : base("Value") {
+        }
+
+        public override bool IsReadOnly {
+            get { return false; }
+        }
+
+        public override object GetValue(object component) {
+            element = component as XElement;
+            if (element == null) return string.Empty; 
+            return element.Value;
+        }
+
+        public override void SetValue(object component, object value) {
+            element = component as XElement;
+            if (element == null) return;
+            element.Value = value as string;
+        }
+
+        protected override void OnChanged(object sender, XObjectChangeEventArgs args) {
+            if (element == null) return;
+            switch (args.ObjectChange) {
+                case XObjectChange.Add:
+                case XObjectChange.Remove:
+                    if (sender is XElement || sender is XText) {
+                        OnValueChanged(element, EventArgs.Empty);
+                    }
+                    break;
+                case XObjectChange.Value:
+                    if (sender is XText) {
+                        OnValueChanged(element, EventArgs.Empty);
+                    } 
+                    break;
+            }
+        }
+    }
+
+    class XElementXmlPropertyDescriptor : XPropertyDescriptor<XElement, string>
+    {
+        XElement element;
+
+        public XElementXmlPropertyDescriptor() : base("Xml") {
+        }
+
+        public override object GetValue(object component) {
+            element = component as XElement;
+            if (element == null) return string.Empty; 
+            return element.ToString(SaveOptions.DisableFormatting);
+        }
+
+        protected override void OnChanged(object sender, XObjectChangeEventArgs args) {
+            if (element == null) return;
+            OnValueChanged(element, EventArgs.Empty);
+        }
+    }
+
+    class XAttributeValuePropertyDescriptor : XPropertyDescriptor<XAttribute, string>
+    {
+        XAttribute attribute;
+
+        public XAttributeValuePropertyDescriptor() : base("Value") {
+        }
+
+        public override bool IsReadOnly {
+            get { return false; }
+        }
+
+        public override object GetValue(object component) {
+            attribute = component as XAttribute;
+            if (attribute == null) return string.Empty;
+            return attribute.Value;
+        }
+
+        public override void SetValue(object component, object value) {
+            attribute = component as XAttribute;
+            if (attribute == null) return; 
+            attribute.Value = value as string;
+        }
+
+        protected override void OnChanged(object sender, XObjectChangeEventArgs args) {
+            if (attribute == null) return;
+            if (args.ObjectChange == XObjectChange.Value) {
+                OnValueChanged(attribute, EventArgs.Empty);
+            }
+        }
+    }
+
+    class XDeferredAxis<T> : IEnumerable<T>, IEnumerable where T : XObject
+    {
+        Func<XElement, XName, IEnumerable<T>> func;
+        internal XElement element;
+        internal XName name;
+
+        public XDeferredAxis(Func<XElement, XName, IEnumerable<T>> func, XElement element, XName name) {
+            if (func == null) throw new ArgumentNullException("func");
+            if (element == null) throw new ArgumentNullException("element");
+            this.func = func;
+            this.element = element;
+            this.name = name;
+        }
+
+        public IEnumerator<T> GetEnumerator() {
+            return func(element, name).GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator() {
+            return GetEnumerator();
+        }
+
+        public IEnumerable<T> this[string expandedName] {
+            get {
+                if (expandedName == null) throw new ArgumentNullException("expandedName");
+                if (name == null) {
+                    name = expandedName;
+                }
+                else if (name != expandedName) {
+                    return Enumerable.Empty<T>();
+                }
+                return this;
+            }
+        }
+    }
+
+    class XDeferredSingleton<T> where T : XObject
+    {
+        Func<XElement, XName, T> func;
+        internal XElement element;
+        internal XName name;
+
+        public XDeferredSingleton(Func<XElement, XName, T> func, XElement element, XName name) {
+            if (func == null) throw new ArgumentNullException("func");
+            if (element == null) throw new ArgumentNullException("element");
+            this.func = func;
+            this.element = element;
+            this.name = name;
+        }
+
+        public T this[string expandedName] {
+            get {
+                if (expandedName == null) throw new ArgumentNullException("expandedName");
+                if (name == null) {
+                    name = expandedName;
+                }
+                else if (name != expandedName) {
+                    return null;
+                }
+                return func(element, name);
+            }
+        }
+    }
+}