Updates referencesource to .NET 4.7

[mono.git] / mcs / class / referencesource / System.Web.DataVisualization / Common / Utilities / XmlSerializer.cs

//-------------------------------------------------------------
// <copyright company=\92Microsoft Corporation\92>
//   Copyright © Microsoft Corporation. All Rights Reserved.
// </copyright>
//-------------------------------------------------------------
// @owner=alexgor, deliant
//=================================================================
//  File:               XmlSerializer.cs
//
//  Namespace:  System.Web.UI.WebControls[Windows.Forms].Charting.Utilities
//
//      Classes:        XmlFormatSerializer, BinaryFormatSerializer
//                              SerializerBase, SerializationVisibilityAttribute
//
//  Purpose:    
//  
//  Chart serializer allows persisting of all chart data and 
//  settings into the stream or file using XML or binary format. 
//  This data can be later loaded back into the chart completely 
//  restoring its state. Serialize can also be used to reset chart 
//  control state to its default values. 
//  
//  Both XML and Binary serialization methods use reflection to 
//  discover class properties which need to be serialized. Only 
//  properties with non-default values are persisted. Full Trust 
//  is required to use chartserialization.
//  
//  SerializeBase class implements all the chart serializer 
//  properties and methods to reset chart content. XmlFormatSerializer 
//  and BinaryFormatSerializer classes derive from the SerializeBase 
//  class and provide saving and loading functionality for XML and 
//  binary format.
//  
//  By default, all chart content is Saved, Loaded or Reset, but 
//  this can be changed using serializer Content, SerializableContent 
//  and NonSerializableContent properties. Content property allows a 
//  simple way to serialize everything, appearance or just chart data. 
//  
//  SerializableContent and NonSerializableContent properties provide 
//  more control over what is beign persisted and they override the 
//  Content property settings. Each of the properties is a string 
//  which is a comma-separated listing of all chart properties to be 
//  serialized. The syntax of this property is "Class.Property[,Class.Property]", 
//  and wildcards may be used (represented by an asterisk). For example, 
//  to serialize all chart BackColor properties set this property to 
//  "*.BackColor".
//  
//      Reviewed:       AG - August 7, 2002
//              AG - Microsoft 6, 2007
//
//===================================================================


#region Used Namespaces

using System;
using System.Xml;
using System.Reflection;
using System.Collections;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.ComponentModel;
using System.IO;
using System.Text;
using System.Globalization;
using System.Diagnostics.CodeAnalysis;
using System.Collections.Specialized;
using System.Security;

#if Microsoft_CONTROL
    using System.Windows.Forms.DataVisualization.Charting.ChartTypes;
#else
    using System.Web.UI.WebControls;
    using System.Web.UI.DataVisualization.Charting.ChartTypes;
#endif

#endregion

#if Microsoft_CONTROL
        namespace System.Windows.Forms.DataVisualization.Charting.Utilities
#else
        namespace System.Web.UI.DataVisualization.Charting.Utilities
#endif
{
        #region Serialization enumerations

        /// <summary>
        /// Enumeration which describes how to persist property during the serialization
        /// </summary>
        internal enum SerializationVisibility
        {
                /// <summary>
                /// Do not serialize
                /// </summary>
                Hidden,

                /// <summary>
                /// Serialize as XML attribute
                /// </summary>
                Attribute,

                /// <summary>
                /// Serialize as XML element
                /// </summary>
                Element
        }

    /// <summary>
    /// Determines chart current serialization status.
    /// </summary>
    internal enum SerializationStatus
    {
        /// <summary>
        /// Chart is not serializing
        /// </summary>
        None,

        /// <summary>
        /// Chart is loading
        /// </summary>
        Loading,

        /// <summary>
        /// Chart is saving
        /// </summary>
        Saving,

        /// <summary>
        /// Chart is resetting
        /// </summary>
        Resetting
    }

        #endregion

        /// <summary>
        /// Attribute which describes how to persist property during the serialization.
        /// </summary>
        [AttributeUsage(AttributeTargets.All)]
        internal sealed class SerializationVisibilityAttribute : System.Attribute 
        {
                #region Fields

                // Visibility style
                private SerializationVisibility _visibility = SerializationVisibility.Attribute;

                #endregion

                #region Constructor

                /// <summary>
                /// Public constructor
                /// </summary>
                /// <param name="visibility">Serialization visibility.</param>
                internal SerializationVisibilityAttribute(SerializationVisibility visibility)
                {
            this._visibility = visibility;
                }

                #endregion

                #region Properties

                /// <summary>
                /// Serialization visibility property
                /// </summary>
                public SerializationVisibility Visibility
                {
                        get 
                        {
                return _visibility;
                        }
            //set
            //{
            //    _visibility = value;
            //}
                }

                #endregion
        }
        
        /// <summary>
        /// Base class of the serializers. Common properties and methods for all serializers.
        /// </summary>
        internal abstract class SerializerBase
        {
                #region Fields

                /// <summary>
                /// Indicates that unknown properties and elements are ignored
                /// </summary>
                private bool                                    _isUnknownAttributeIgnored = false;

                /// <summary>
                /// Indicates that serializer works in template creation mode
                /// </summary>
                private bool                                    _isTemplateMode = false;

                /// <summary>
                /// Indicates that object properties are reset before loading
                /// </summary>
                private bool                                    _isResetWhenLoading = true;

                /// <summary>
                /// Comma separated list of serializable (Save/Load/Reset) properties. "ClassName.PropertyName"
                /// </summary>
                private string                                  _serializableContent = "";

                /// <summary>
                /// Comma separated list of NON serializable (Save/Load/Reset) properties. "ClassName.PropertyName"
                /// </summary>
                private string                                  _nonSerializableContent = "";
                        
                /// <summary>
                /// Font converters used while serializing/deserializing 
                /// </summary>
                internal static FontConverter           fontConverter = new FontConverter();

                /// <summary>
                /// Color converters used while serializing/deserializing 
                /// </summary>
                internal static ColorConverter          colorConverter = new ColorConverter();

                /// <summary>
                /// Hash code provider.
                /// </summary>
        protected static StringComparer hashCodeProvider = StringComparer.OrdinalIgnoreCase;

        /// <summary>
        /// Contains chart specific converters
        /// </summary>
        HybridDictionary _converterDict = new HybridDictionary();


                #endregion

                #region Public properties

                /// <summary>
                /// Indicates that unknown properties and elements will be 
                /// ignored without throwing an exception.
                /// </summary>
                internal bool IsUnknownAttributeIgnored
                {
                        get
                        {
                return _isUnknownAttributeIgnored;
                        }
                        set
                        {
                _isUnknownAttributeIgnored = value;
                        }
                }

                /// <summary>
                /// Indicates that serializer works in template creation mode
                /// </summary>
        internal bool IsTemplateMode
                {
                        get
                        {
                return _isTemplateMode;
                        }
                        set
                        {
                _isTemplateMode = value;
                        }
                }

                /// <summary>
                /// Indicates that object properties are reset to default
                /// values before loading.
                /// </summary>
        internal bool IsResetWhenLoading
                {
                        get
                        {
                                return _isResetWhenLoading;
                        }
                        set
                        {
                                _isResetWhenLoading = value;
                        }
                }

                /// <summary>
                /// Comma separated list of serializable (Save/Load/Reset) properties. 
                /// "ClassName.PropertyName,[ClassName.PropertyName]".
                /// </summary>
        internal string SerializableContent
                {
                        get
                        {
                                return _serializableContent;
                        }
                        set
                        {
                                _serializableContent = value;

                                // Reset list
                                serializableContentList = null;
                        }
                }

                /// <summary>
                /// Comma separated list of serializable (Save/Load/Reset) properties. 
                /// "ClassName.PropertyName,[ClassName.PropertyName]".
                /// </summary>
        internal string NonSerializableContent
                {
                        get
                        {
                                return _nonSerializableContent;
                        }
                        set
                        {
                                _nonSerializableContent = value;

                                // Reset list
                                nonSerializableContentList = null;
                        }
                }

                #endregion

                #region Resetting methods
        
                /// <summary>
                /// Reset properties of the object to default values.
                /// </summary>
                /// <param name="objectToReset">Object to be reset.</param>
                virtual internal void ResetObjectProperties(object objectToReset)
                {
                        // Reset object properties
                        ResetObjectProperties(objectToReset, null, GetObjectName(objectToReset));
                }

                /// <summary>
                /// Reset properties of the object to default values.
                /// Method is called recursively to reset child objects properties.
                /// </summary>
                /// <param name="objectToReset">Object to be reset.</param>
                /// <param name="parent">Parent of the reset object.</param>
                /// <param name="elementName">Object element name.</param>
        virtual internal void ResetObjectProperties(object objectToReset, object parent, string elementName)
                {
                        // Check input parameters
                        if(objectToReset == null)
                        {
                                return;
                        }

            IList list = objectToReset as IList;

                        // Check if object is a list
                        if(list != null && IsSerializableContent(elementName, parent))
                        {
                                // Reset list by clearing all the items
                                list.Clear();
                                return;
                        }

                        // Retrive properties list of the object
                        PropertyInfo[] properties = objectToReset.GetType().GetProperties();
                        if(properties != null)
                        {
                                // Loop through all properties and reset public properties
                                foreach(PropertyInfo pi in properties)
                                {
                                        // Get property descriptor
                                        PropertyDescriptor pd = TypeDescriptor.GetProperties(objectToReset)[pi.Name];

                                        // Check XmlFormatSerializerStyle attribute
                                        if(pd != null)
                                        {
                                                SerializationVisibilityAttribute        styleAttribute = (SerializationVisibilityAttribute)pd.Attributes[typeof(SerializationVisibilityAttribute)];
                                                if(styleAttribute != null)
                                                {
                                                        // Hidden property
                                                        if(styleAttribute.Visibility == SerializationVisibility.Hidden)
                                                        {
                                                                continue;
                                                        }
                                                }
                                        }

                                        // Check if this property should be reset
                                        bool resetProperty = IsSerializableContent(pi.Name, objectToReset);

                                        // Skip inherited properties from the root object
                                        if(IsChartBaseProperty(objectToReset, parent, pi))
                                        {
                                                continue;
                                        }

                                        // Reset list
                                        if(pi.CanRead && pi.PropertyType.GetInterface("IList", true) != null)
                                        {
                                                if(resetProperty)
                                                {
                                                        // Check if collection has "Reset" method
                                                        bool resetComplete = false;
                                                        MethodInfo mi = objectToReset.GetType().GetMethod("Reset" + pi.Name, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
                                                        if(mi != null)
                                                        {
                                                                mi.Invoke(objectToReset, null);
                                                                resetComplete = true;
                                                        }

                                                        // Reset list by clearing all the items
                                                        if(!resetComplete)
                                                        {
                                                                ((IList)pi.GetValue(objectToReset, null)).Clear();
                                                        }
                                                }
                                                else
                                                {
                                                        // Reset objects of the list
                                                        foreach(object listObject in ((IList)pi.GetValue(objectToReset, null)))
                                                        {
                                                                ResetObjectProperties(listObject, objectToReset, this.GetObjectName(listObject));
                                                        }
                                                }
                                        }

                                                // Reset public properties with Get and Set methods
                                        else if(pi.CanRead && pi.CanWrite)
                                        {
                                                // Skip indexes
                                                if(pi.Name == "Item")
                                                {
                                                        continue;
                                                }

                        // Skip Names
                        if (pi.Name == "Name")
                        {
                            continue;
                        }

                                                // Reset inner properies
                                                if(ShouldSerializeAsAttribute(pi, objectToReset))
                                                {
                                                        if(resetProperty)
                                                        {
                                                                // Reset the property using property descriptor
                                                                
                                                                if(pd != null)
                                                                {
                                                                        // Get property object
                                                                        object objectProperty = pi.GetValue(objectToReset, null);

                                                                        // Get default value of the property
                                                                        DefaultValueAttribute defValueAttribute = (DefaultValueAttribute)pd.Attributes[typeof(DefaultValueAttribute)];
                                                                        if(defValueAttribute != null)
                                                                        {
                                                                                if(objectProperty == null)
                                                                                {
                                                                                        if(defValueAttribute.Value != null)
                                                                                        {
                                                                                                pd.SetValue(objectToReset, defValueAttribute.Value);
                                                                                        }
                                                                                }
                                                                                else if(! objectProperty.Equals(defValueAttribute.Value))
                                                                                {
                                                                                        pd.SetValue(objectToReset, defValueAttribute.Value);
                                                                                }
                                                                        }
                                                                        else
                                                                        {
                                                                                // Check if property has "Reset" method
                                        MethodInfo mi = objectToReset.GetType().GetMethod("Reset" + pi.Name, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
                                                                                if(mi != null)
                                                                                {
                                                                                        mi.Invoke(objectToReset, null);
                                                                                }
                                                                        }
                                                                }
                                                        }
                                                }
                                                else
                                                {
                                                        // Reset inner object
                                                        ResetObjectProperties(pi.GetValue(objectToReset, null), objectToReset, pi.Name);
                                                }
                                        }
                                }
                        }
                        return;
                }


                #endregion

                #region Abstract Serialization/Deserialization methods

                /// <summary>
                /// Serialize specified object into the destination object.
                /// </summary>
                /// <param name="objectToSerialize">Object to be serialized.</param>
                /// <param name="destination">Destination of the serialization.</param>
        internal abstract void Serialize(object objectToSerialize, object destination);
                
                /// <summary>
                /// Deserialize specified object from the source object.
                /// </summary>
                /// <param name="objectToDeserialize">Object to be deserialized.</param>
                /// <param name="source">Source of the deserialization.</param>
        internal abstract void Deserialize(object objectToDeserialize, object source);

                #endregion

                #region Protected helper methods

                /// <summary>
                /// Converts specified font object into a string.
                /// </summary>
                /// <param name="font">Font object to convert.</param>
                /// <returns>String that contains font data.</returns>
                internal static string FontToString(Font font)
                {
                        // Save basic properties persisted by font converter
                        string fontData = (string)SerializerBase.fontConverter.ConvertToInvariantString(font);

                        // Persist properties not serialiazed by the converter
                        if(font.GdiCharSet != 1)
                        {
                                fontData += ", GdiCharSet=" + font.GdiCharSet.ToString(System.Globalization.CultureInfo.InvariantCulture);
                        }
                        if(font.GdiVerticalFont)
                        {
                                fontData += ", GdiVerticalFont";
                        }

                        return fontData;
                }

                /// <summary>
                /// Converts string data into a font object.
                /// </summary>
                /// <param name="fontString">String with font data.</param>
                /// <returns>Newly created font object.</returns>
                internal static Font FontFromString(string fontString)
                {
                        // Check if string contains non-standard values "GdiCharSet" or "GdiVerticalFont"
                        string standardData = fontString;
                        byte gdiCharSet = 1;
                        bool gdiVerticalFont = false;
                        int charIndex = fontString.IndexOf(", GdiCharSet=", StringComparison.Ordinal);
                        if(charIndex >= 0)
                        {
                                // Read value
                                string val = fontString.Substring(charIndex + 13);
                int commaIndex = val.IndexOf(",", StringComparison.Ordinal);
                                if(commaIndex >= 0)
                                {
                                        val = val.Substring(0, commaIndex);
                                }

                                gdiCharSet = (byte)Int32.Parse(val, System.Globalization.CultureInfo.InvariantCulture);

                                // Truncate standard data string
                                if(standardData.Length > charIndex)
                                {
                                        standardData = standardData.Substring(0, charIndex);
                                }
                        }
            charIndex = fontString.IndexOf(", GdiVerticalFont", StringComparison.Ordinal);
                        if(charIndex >= 0)
                        {
                                gdiVerticalFont = true;

                                // Truncate standard data string
                                if(standardData.Length > charIndex)
                                {
                                        standardData = standardData.Substring(0, charIndex);
                                }
                        }

                        // Create Font object from standard parameters
                        Font font = (Font)SerializerBase.fontConverter.ConvertFromInvariantString(standardData);

                        // check if non-standard parameters provided
                        if(gdiVerticalFont || gdiCharSet != 1)
                        {
                                Font newFont = new Font(
                                        font.Name,
                                        font.SizeInPoints,
                                        font.Style,
                                        GraphicsUnit.Point,
                                        gdiCharSet,
                                        gdiVerticalFont);

                                font.Dispose();

                                return newFont;
                        }

                        return font;
                }

                /// <summary>
                /// Returns a hash code of a specified string.
                /// </summary>
                /// <param name="str">String to get the hash code for.</param>
                /// <returns>String hash code.</returns>
                internal static short GetStringHashCode(string str)
                {
                        return (short)(hashCodeProvider.GetHashCode(str) + str.Length * 2);
                }

                /// <summary>
                /// Reads hash ID from the specified binary reader.
                /// </summary>
                /// <param name="reader">Binary reader to get the data from.</param>
                /// <returns>Property name or collection member type ID.</returns>
        internal Int16 ReadHashID(BinaryReader reader)
                {
                        // For later versions return ID without transformations
                        return reader.ReadInt16();
                }

                /// <summary>
                /// Checks if property belongs to the base class of the chart "Control".
                /// </summary>
                /// <param name="objectToSerialize">Serializable object.</param>
                /// <param name="parent">Object parent.</param>
                /// <param name="pi">Serializable property information.</param>
                /// <returns>True if property belongs to the base class.</returns>
        internal bool IsChartBaseProperty(object objectToSerialize, object parent, PropertyInfo pi)
                {
                        bool    result = false;

                        // Check only for the root object
                        if(parent == null)
                        {
                                Type    currentType = objectToSerialize.GetType();
                                while(currentType != null)
                                {
                                        if(pi.DeclaringType == currentType)
                                        {
                                                result = false;
                                                break;
                                        }

                                        // Check if it's a chart class
                                        if( currentType == typeof(Chart))
                                        {
                                                result = true;
                                                break;
                                        }
                                
                                        // Get base class type
                                        currentType = currentType.BaseType;
                                }
                        }

                        return result;
                }


                /// <summary>
                /// Converts Image object into the BASE64 encoded string
                /// </summary>
                /// <param name="image">Image to convert.</param>
                /// <returns>BASE64 encoded image data.</returns>
                internal static string ImageToString(System.Drawing.Image image)
                {
                        // Save image into the stream using BASE64 encoding
                        MemoryStream imageStream = new MemoryStream();
                        image.Save(imageStream, ImageFormat.Png);
                        imageStream.Seek(0, SeekOrigin.Begin);

                        // Create XmlTextWriter and save image in BASE64
                        StringBuilder stringBuilder = new StringBuilder();
                        XmlTextWriter textWriter = new XmlTextWriter(new StringWriter(stringBuilder, CultureInfo.InvariantCulture));
                        byte[] imageByteData = imageStream.ToArray();
                        textWriter.WriteBase64(imageByteData, 0, imageByteData.Length);

                        // Close image stream
                        textWriter.Close();
                        imageStream.Close();

                        return stringBuilder.ToString();
                }

                /// <summary>
                /// Converts BASE64 encoded string to image.
                /// </summary>
                /// <param name="data">BASE64 encoded data.</param>
                /// <returns>Image.</returns>
        internal static System.Drawing.Image ImageFromString(string data)
                {
                        // Create XML text reader
                        byte[]  buffer = new byte[1000];
                        MemoryStream imageStream = new MemoryStream();
                        XmlTextReader textReader = new XmlTextReader(new StringReader("<base64>" + data + "</base64>"));

                        // Read tags and BASE64 encoded data
                        textReader.Read();
                        int bytesRead = 0;
                        while((bytesRead = textReader.ReadBase64(buffer, 0, 1000)) > 0)
                        {
                                imageStream.Write(buffer, 0, bytesRead);
                        }
                        textReader.Read();

                        // Create image from stream
                        imageStream.Seek(0, SeekOrigin.Begin);
            System.Drawing.Image tempImage = System.Drawing.Image.FromStream(imageStream);
                        System.Drawing.Bitmap image = new Bitmap(tempImage);    // !!! .Net bug when image source stream is closed - can create brush using the image
            image.SetResolution(tempImage.HorizontalResolution, tempImage.VerticalResolution); //The bitmap created using the constructor does not copy the resolution of the image

                        // Close image stream
                        textReader.Close();
                        imageStream.Close();

                        return image;
                }

                /// <summary>
                /// Get the name of the object class
                /// </summary>
                /// <param name="obj">Object to get the name of.</param>
                /// <returns>Name of the object class (without namespace).</returns>
                internal string GetObjectName(object obj)
                {
            string name = obj.GetType().ToString();
                        return name.Substring(name.LastIndexOf('.') + 1);
                }

        /// <summary>
        /// Create new empty item for the list.
        /// AxisName of the objects is determined by the return type of the indexer.
        /// </summary>
        /// <param name="list">List used to detect type of the item objects.</param>
        /// <param name="itemTypeName">Name of collection type.</param>
        /// <param name="itemName">Optional item name to return.</param>
        /// <param name="reusedObject">Indicates that object with specified name was already in the collection and it being reused.</param>
        /// <returns>New list item object.</returns>
        internal object GetListNewItem(IList list, string itemTypeName, ref string itemName, ref bool reusedObject)
                {
                        // Get type of item in collection
                        Type itemType = null;
                        if(itemTypeName.Length > 0)
                        {
                itemType = Type.GetType(typeof(Chart).Namespace + "." + itemTypeName, false, true);
                        }

                        reusedObject = false;
                        PropertyInfo pi = list.GetType().GetProperty("Item", itemType, new Type[] {typeof(string)} );
            MethodInfo mi = list.GetType().GetMethod("IndexOf", new Type[] { typeof(String) });
                        ConstructorInfo ci = null;
                        if(pi != null)
                        {
                                // Try to get object by name using the indexer
                                if(itemName != null && itemName.Length > 0)
                                {
                    bool itemChecked = false;
                    if (mi != null)
                    {
                        try
                        {
                            int index = -1;
                            object oindex = mi.Invoke(list, new object[] { itemName });
                            if (oindex is int)
                            {
                                index = (int)oindex;
                                itemChecked = true;
                            }
                            if (index != -1)
                            {
                                object objByName = list[index];
                                if (objByName != null)
                                {
                                    // Remove found object from the list
                                    list.Remove(objByName);

                                    // Return found object
                                    reusedObject = true;
                                    return objByName;
                                }
                            }
                        }
                        catch (ArgumentException)
                        {
                        }
                        catch (TargetException)
                        {
                        }
                        catch (TargetInvocationException)
                        {
                        }
                    }
                    if (!itemChecked)
                    {
                        object objByName = null;
                        try
                        {
                            objByName = pi.GetValue(list, new object[] { itemName });
                        }
                        catch (ArgumentException)
                        {
                            objByName = null;
                        }
                        catch (TargetException)
                        {
                            objByName = null;
                        }
                        catch (TargetInvocationException)
                        {
                            objByName = null;
                        }

                        if (objByName != null)
                        {
                            try
                            {
                                // Remove found object from the list
                                list.Remove(objByName);
                            }
                            catch (NotSupportedException)
                            {
                            }

                            // Return found object
                            reusedObject = true;
                            return objByName;
                        }
                    }
                                        itemName = null;
                                }

                        }
            // Get the constructor of the type returned by indexer
            if (itemType != null)
            {
                ci = itemType.GetConstructor(Type.EmptyTypes);
            }
            else
            {
                ci = pi.PropertyType.GetConstructor(Type.EmptyTypes);
            }
            if (ci == null)
            {
                throw (new InvalidOperationException(SR.ExceptionChartSerializerDefaultConstructorUndefined(pi.PropertyType.ToString())));
            }
            return ci.Invoke(null);
                }

        /// <summary>
        /// Returns true if the object property should be serialized as 
        /// parent element attribute. Otherwise as a child element.
        /// </summary>
        /// <param name="pi">Property information.</param>
        /// <param name="parent">Object that the property belongs to.</param>
        /// <returns>True if property should be serialized as attribute.</returns>
        internal bool ShouldSerializeAsAttribute(PropertyInfo pi, object parent)
                {
                        // Check if SerializationVisibilityAttribute is set
                        if(parent != null)
                        {
                                PropertyDescriptor pd = TypeDescriptor.GetProperties(parent)[pi.Name];
                                if(pd != null)
                                {
                                        SerializationVisibilityAttribute        styleAttribute = (SerializationVisibilityAttribute)pd.Attributes[typeof(SerializationVisibilityAttribute)];
                                        if(styleAttribute != null)
                                        {
                                                if(styleAttribute.Visibility == SerializationVisibility.Attribute)
                                                {
                                                        return true;
                                                }
                                                else if(styleAttribute.Visibility == SerializationVisibility.Element)
                                                {
                                                        return false;
                                                }
                                        }
                                }
                        }

                        // If a simple type - serialize as property
                        if(!pi.PropertyType.IsClass)
                        {
                                return true;
                        }

                        // Some classes are serialized as properties
                        if(pi.PropertyType == typeof(string) ||
                                pi.PropertyType == typeof(Font) ||
                                pi.PropertyType == typeof(Color) ||
                                pi.PropertyType == typeof(System.Drawing.Image))
                        {
                                return true;
                        }

                        return false;
        }


        /// <summary>
        /// Determines if this property should be serialized as attribute
        /// </summary>
        /// <param name="pi">Property information.</param>
        /// <param name="objectToSerialize">Object that the property belongs to.</param>
        /// <returns>True if should be serialized as attribute</returns>
        internal bool SerializeICollAsAtribute(PropertyInfo pi, object objectToSerialize)
        {
            if (objectToSerialize != null)
            {
                PropertyDescriptor pd = TypeDescriptor.GetProperties(objectToSerialize)[pi.Name];
                if (pd != null)
                {
                    SerializationVisibilityAttribute styleAttribute = (SerializationVisibilityAttribute)pd.Attributes[typeof(SerializationVisibilityAttribute)];
                    if (styleAttribute != null)
                    {
                        if (styleAttribute.Visibility == SerializationVisibility.Attribute)
                        {
                            return true;
                        }
                    }
                }
            }
            return false;
        }

        /// <summary>
                /// Returns true if the object property is serializable.
                /// </summary>
                /// <param name="propertyName">Property name.</param>
                /// <param name="parent">Object that the property belongs to.</param>
                /// <returns>True if property is serializable.</returns>
        internal bool IsSerializableContent(string propertyName, object parent)
        {
                        bool    serializable = true;
                        if(_serializableContent.Length > 0 || _nonSerializableContent.Length > 0)
                        {
                                int             serialzableClassFitType = 0;    // 0 - undefined; 1 - '*'; 2 - 'Back*'; 3 - Exact
                                int             serialzablePropertyFitType = 0; // 0 - undefined; 1 - '*'; 2 - 'Back*'; 3 - Exact
                string ownerClassName = GetObjectName(parent);

                                // Check if property in this class is part of the serializable content
                                serializable = IsPropertyInList(GetSerializableContentList(), ownerClassName, propertyName, out serialzableClassFitType, out serialzablePropertyFitType);

                                // Check if property in this class is part of the NON serializable content
                                if(serializable)
                                {
                                        int             nonSerialzableClassFitType = 0; // 0 - undefined; 1 - '*'; 2 - 'Back*'; 3 - Exact
                                        int             nonSerialzablePropertyFitType = 0;      // 0 - undefined; 1 - '*'; 2 - 'Back*'; 3 - Exact
                                        bool    nonSerializable = IsPropertyInList(GetNonSerializableContentList(), ownerClassName, propertyName, out nonSerialzableClassFitType, out nonSerialzablePropertyFitType);

                                        // If property was found in non serializable content list - check the type priority
                                        // Priority order: Exact match, 'Back*' mask match, '*' all mask match
                                        if(nonSerializable)
                                        {
                                                // Check priority
                                                if((nonSerialzableClassFitType + nonSerialzablePropertyFitType) > 
                                                        (serialzableClassFitType + serialzablePropertyFitType))
                                                {
                                                        serializable = false;
                                                }
                                        }
                                }
                        }

                        return serializable;
                }

        /// <summary>
        /// Checks if property belongs is defined in the mask list.
        /// </summary>
        /// <param name="contentList">Array list of class/property items.</param>
        /// <param name="className">Class name.</param>
        /// <param name="propertyName">Property name.</param>
        /// <param name="classFitType">Return class mask fit type.</param>
        /// <param name="propertyFitType">Return property mask fit type.</param>
        /// <returns>True if property was found in the list.</returns>
                private bool IsPropertyInList(ArrayList contentList, string className, string propertyName, out int classFitType, out int propertyFitType)
                {
                        // Initialize result values
                        classFitType = 0;
                        propertyFitType = 0;

                        if(contentList != null)
                        {
                                // Loop through all items in the list using step 2
                                for(int itemIndex = 0; itemIndex < contentList.Count; itemIndex += 2)
                                {
                                        // Initialize result values
                                        classFitType = 0;
                                        propertyFitType = 0;

                                        // Check if object class and property name match the mask
                                        if(NameMatchMask((ItemInfo)contentList[itemIndex], className, out classFitType))
                                        {
                                                if(NameMatchMask((ItemInfo)contentList[itemIndex + 1], propertyName, out propertyFitType))
                                                {
                                                        return true;
                                                }
                                        }
                                }
                        }

                        return false;
                }

        /// <summary>
        /// Compares class/property name with the specified mask
        /// </summary>
        /// <param name="itemInfo">Class/Property item information.</param>
        /// <param name="objectName">Class/Property name.</param>
        /// <param name="type">AxisName of matching. 0-No Match; 1-'*' any wild card; 2-'Back*' contain wild card; 3-exact match</param>
        /// <returns>True if name match the mask.</returns>
                private bool NameMatchMask(ItemInfo itemInfo, string objectName, out int type)
                {
                        // Initialize type
                        type = 0;

                        // Any class mask
                        if(itemInfo.any)
                        {
                                type = 1;
                                return true;
                        }

                        // Ends with class mask
                        if(itemInfo.endsWith)
                        {
                                if(itemInfo.name.Length <= objectName.Length)
                                {
                                        if(objectName.Substring(0, itemInfo.name.Length) == itemInfo.name)
                                        {
                                                type = 2;
                                                return true;
                                        }
                                }
                        }

                        // Starts with class mask
                        if(itemInfo.startsWith)
                        {
                                if(itemInfo.name.Length <= objectName.Length)
                                {
                                        if(objectName.Substring(objectName.Length - itemInfo.name.Length, itemInfo.name.Length) == itemInfo.name)
                                        {
                                                type = 2;
                                                return true;
                                        }
                                }
                        }

                        // Exact name is specified
                        if(itemInfo.name == objectName)
                        {
                                type = 3;
                                return true;
                        }

                        return false;
                }


        /// <summary>
        /// Finds a converter by property descriptor.
        /// </summary>
        /// <param name="pd">Property descriptor.</param>
        /// <returns>A converter registered in TypeConverterAttribute or by property type</returns>
        internal TypeConverter FindConverter(PropertyDescriptor pd)
        {
            TypeConverter result;
            TypeConverterAttribute typeConverterAttrib = (TypeConverterAttribute)pd.Attributes[typeof(TypeConverterAttribute)];
            if (typeConverterAttrib != null && typeConverterAttrib.ConverterTypeName.Length > 0)
            {
                result = this.FindConverterByType(typeConverterAttrib);
                if (result != null)
                {
                    return result;
                }
                try
                {
                    return pd.Converter;
                }
                catch (SecurityException)
                {
                }
                catch (MethodAccessException)
                {
                }
            }
            return TypeDescriptor.GetConverter(pd.PropertyType);
        }

        /// <summary>
        /// Finds a converter by TypeConverterAttribute.
        /// </summary>
        /// <param name="attr">TypeConverterAttribute.</param>
        /// <returns>TypeConvetrer or null</returns>
        internal TypeConverter FindConverterByType( TypeConverterAttribute attr)
        {
            // In default Inranet zone (partial trust) ConsrtuctorInfo.Invoke (PropertyDescriptor.Converter) 
            // throws SecurityException or MethodAccessException when the converter class is internal.
            // Thats why we have this giant if - elseif here - to create type converters whitout reflection.
            if (_converterDict.Contains(attr.ConverterTypeName))
            {
                return (TypeConverter)_converterDict[attr.ConverterTypeName];
            }
            String typeStr = attr.ConverterTypeName;
            
            if (attr.ConverterTypeName.Contains(",") )
            {
                typeStr = attr.ConverterTypeName.Split(',')[0];
            }

            TypeConverter result = null;

            if (typeStr.EndsWith(".CustomPropertiesTypeConverter", StringComparison.OrdinalIgnoreCase)) { result = new CustomPropertiesTypeConverter(); }
            else if (typeStr.EndsWith(".DoubleNanValueConverter", StringComparison.OrdinalIgnoreCase)) { result = new DoubleNanValueConverter(); }
            else if (typeStr.EndsWith(".DoubleDateNanValueConverter", StringComparison.OrdinalIgnoreCase)) { result = new DoubleDateNanValueConverter(); }
#if !Microsoft_CONTROL
            else if (typeStr.EndsWith(".MapAreaCoordinatesConverter", StringComparison.OrdinalIgnoreCase)) { result = new MapAreaCoordinatesConverter(); }
#endif //Microsoft_CONTROL
            else if (typeStr.EndsWith(".ElementPositionConverter", StringComparison.OrdinalIgnoreCase)) { result = new ElementPositionConverter(); }
            else if (typeStr.EndsWith(".SeriesAreaNameConverter", StringComparison.OrdinalIgnoreCase)) { result = new SeriesAreaNameConverter(); }
            else if (typeStr.EndsWith(".ChartDataSourceConverter", StringComparison.OrdinalIgnoreCase)) { result = new ChartDataSourceConverter(); }
            else if (typeStr.EndsWith(".SeriesDataSourceMemberConverter", StringComparison.OrdinalIgnoreCase)) { result = new SeriesDataSourceMemberConverter(); }
            else if (typeStr.EndsWith(".SeriesLegendNameConverter", StringComparison.OrdinalIgnoreCase)) { result = new SeriesLegendNameConverter(); }
            else if (typeStr.EndsWith(".ChartTypeConverter", StringComparison.OrdinalIgnoreCase)) { result = new ChartTypeConverter(); }
            else if (typeStr.EndsWith(".SeriesNameConverter", StringComparison.OrdinalIgnoreCase)) { result = new SeriesNameConverter(); }
            else if (typeStr.EndsWith(".NoNameExpandableObjectConverter", StringComparison.OrdinalIgnoreCase)) { result = new NoNameExpandableObjectConverter(); }
            else if (typeStr.EndsWith(".DoubleArrayConverter", StringComparison.OrdinalIgnoreCase)) { result = new DoubleArrayConverter(); }
            else if (typeStr.EndsWith(".DataPointValueConverter", StringComparison.OrdinalIgnoreCase)) { result = new DataPointValueConverter(); }
            else if (typeStr.EndsWith(".SeriesYValueTypeConverter", StringComparison.OrdinalIgnoreCase)) { result = new SeriesYValueTypeConverter(typeof(ChartValueType)); }
            else if (typeStr.EndsWith(".ColorArrayConverter", StringComparison.OrdinalIgnoreCase)) { result = new ColorArrayConverter(); }
            else if (typeStr.EndsWith(".LegendAreaNameConverter", StringComparison.OrdinalIgnoreCase)) { result = new LegendAreaNameConverter(); }
            else if (typeStr.EndsWith(".LegendConverter", StringComparison.OrdinalIgnoreCase)) { result = new LegendConverter(); }
            else if (typeStr.EndsWith(".SizeEmptyValueConverter", StringComparison.OrdinalIgnoreCase)) { result = new SizeEmptyValueConverter(); }
            else if (typeStr.EndsWith(".MarginExpandableObjectConverter", StringComparison.OrdinalIgnoreCase)) { result = new MarginExpandableObjectConverter(); }
            else if (typeStr.EndsWith(".IntNanValueConverter", StringComparison.OrdinalIgnoreCase)) { result = new IntNanValueConverter(); }
            else if (typeStr.EndsWith(".AxesArrayConverter", StringComparison.OrdinalIgnoreCase)) { result = new AxesArrayConverter(); }
            else if (typeStr.EndsWith(".AxisLabelDateValueConverter", StringComparison.OrdinalIgnoreCase)) { result = new AxisLabelDateValueConverter(); }
            else if (typeStr.EndsWith(".AxisMinMaxValueConverter", StringComparison.OrdinalIgnoreCase)) { result = new AxisMinMaxValueConverter(); }
            else if (typeStr.EndsWith(".AxisCrossingValueConverter", StringComparison.OrdinalIgnoreCase)) { result = new AxisCrossingValueConverter(); }
            else if (typeStr.EndsWith(".AxisMinMaxAutoValueConverter", StringComparison.OrdinalIgnoreCase)) { result = new AxisMinMaxAutoValueConverter(); }
            else if (typeStr.EndsWith(".StripLineTitleAngleConverter", StringComparison.OrdinalIgnoreCase)) { result = new StripLineTitleAngleConverter(); }
            else if (typeStr.EndsWith(".AxisIntervalValueConverter", StringComparison.OrdinalIgnoreCase)) { result = new AxisIntervalValueConverter(); }
            else if (typeStr.EndsWith(".AxisElementIntervalValueConverter", StringComparison.OrdinalIgnoreCase)) { result = new AxisElementIntervalValueConverter(); }
            else if (typeStr.EndsWith(".AnchorPointValueConverter", StringComparison.OrdinalIgnoreCase)) { result = new AnchorPointValueConverter(); }
            else if (typeStr.EndsWith(".AnnotationAxisValueConverter", StringComparison.OrdinalIgnoreCase)) { result = new AnnotationAxisValueConverter(); }

            if (result != null) _converterDict[attr.ConverterTypeName] = result;
            
            return result;
        }

                #endregion

                #region Serializable content list managment fields, methods and classes

                /// <summary>
                /// Stores information about content item (class or property)
                /// </summary>
                private class ItemInfo
                {
                        public  string          name = "";
                        public  bool            any = false;
                        public  bool            startsWith = false;
                        public  bool            endsWith = false;
                }

                // Storage for serializable content items
                private ArrayList               serializableContentList = null;

                // Storage for non serializable content items
                private ArrayList               nonSerializableContentList = null;

                /// <summary>
                /// Return serializable content list.
                /// </summary>
                /// <returns>Serializable content list.</returns>
                private ArrayList GetSerializableContentList()
                {
                        if(serializableContentList == null)
                        {
                                serializableContentList = new ArrayList();
                                FillContentList(
                                        serializableContentList, 
                                        (this.SerializableContent.Length > 0 ) ? this.SerializableContent : "*.*");
                        }

                        return serializableContentList;
                }

                /// <summary>
                /// Return non serializable content list.
                /// </summary>
                /// <returns>Non serializable content list.</returns>
                private ArrayList GetNonSerializableContentList()
                {
                        if(nonSerializableContentList == null)
                        {
                                nonSerializableContentList = new ArrayList();
                                FillContentList(nonSerializableContentList, this.NonSerializableContent);
                        }

                        return nonSerializableContentList;
                }

                /// <summary>
                /// Fill content list from the string.
                /// </summary>
                /// <param name="list">Array list class.</param>
                /// <param name="content">Content string.</param>
                private void FillContentList(ArrayList list, string content)
                {
                        if(content.Length > 0)
                        {
                                string[]        classPropertyPairs = content.Split(',');
                                foreach(string item in classPropertyPairs)
                                {
                                        // Create two content items: one for the class and one for the property
                                        ItemInfo        classInfo = new ItemInfo();
                                        ItemInfo        propertyInfo = new ItemInfo();

                                        // Find class and property name
                                        int pointIndex = item.IndexOf('.');
                                        if(pointIndex == -1)
                                        {
                        throw (new ArgumentException(SR.ExceptionChartSerializerContentStringFormatInvalid));
                                        }
                                        classInfo.name = item.Substring(0, pointIndex).Trim();
                                        propertyInfo.name = item.Substring(pointIndex + 1).Trim();
                                        if(classInfo.name.Length == 0)
                                        {
                        throw (new ArgumentException(SR.ExceptionChartSerializerClassNameUndefined));
                                        }
                                        if(propertyInfo.name.Length == 0)
                                        {
                        throw (new ArgumentException(SR.ExceptionChartSerializerPropertyNameUndefined));
                                        }

                                        // Make sure property name do not have point character
                                        if(propertyInfo.name.IndexOf('.') != -1)
                                        {
                        throw (new ArgumentException(SR.ExceptionChartSerializerContentStringFormatInvalid));
                                        }

                                        // Check for wildcards in names
                                        CheckWildCars(classInfo);
                                        CheckWildCars(propertyInfo);

                                        // Add class & property items into the array
                                        list.Add(classInfo);
                                        list.Add(propertyInfo);
                                }
                        }
                }

                /// <summary>
                /// Checks wildcards in the name of the item.
                /// Possible values:
                ///             "*"
                ///             "*Name"
                ///             "Name*"
                /// </summary>
                /// <param name="info">Item information class.</param>
                private void CheckWildCars(ItemInfo info)
                {
                        // Any class mask
                        if(info.name == "*")
                        {
                                info.any = true;
                        }

                        // Ends with class mask
                        else if(info.name[info.name.Length - 1] == '*')
                        {
                                info.endsWith = true;
                                info.name = info.name.TrimEnd('*');
                        }

                        // Starts with class mask
                        else if(info.name[0] == '*')
                        {
                                info.startsWith = true;
                                info.name = info.name.TrimStart('*');
                        }
                }

                #endregion
    }

        /// <summary>
        /// Utility class which serialize object using XML format
        /// </summary>
        internal class XmlFormatSerializer : SerializerBase
        {
                #region Serialization public methods

                /// <summary>
                /// Serialize specified object into the stream.
                /// </summary>
                /// <param name="objectToSerialize">Object to be serialized.</param>
                /// <param name="stream">The stream used to write the XML document.</param>

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal void Serialize(object objectToSerialize, Stream stream)
                {
                        Serialize(objectToSerialize, (object)stream);
                }

                /// <summary>
                /// Serialize specified object into the XML writer.
                /// </summary>
                /// <param name="objectToSerialize">Object to be serialized.</param>
                /// <param name="xmlWriter">The XmlWriter used to write the XML document.</param>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal void Serialize(object objectToSerialize, XmlWriter xmlWriter)
                {
                        Serialize(objectToSerialize, (object)xmlWriter);
                }

                /// <summary>
                /// Serialize specified object into the text writer.
                /// </summary>
                /// <param name="objectToSerialize">Object to be serialized.</param>
                /// <param name="textWriter">The TextWriter used to write the XML document.</param>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal void Serialize(object objectToSerialize, TextWriter textWriter)
                {
                        Serialize(objectToSerialize, (object)textWriter);
                }

                /// <summary>
                /// Serialize specified object into the file.
                /// </summary>
                /// <param name="objectToSerialize">Object to be serialized.</param>
                /// <param name="fileName">The file name used to write the XML document.</param>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal void Serialize(object objectToSerialize, string fileName)
                {
                        Serialize(objectToSerialize, (object)fileName);
                }

                #endregion
        
                #region Serialization private methods

                /// <summary>
                /// Serialize specified object into different types of writers using XML format.
                /// Here is what is serialized in the object:
                ///      - all public properties with Set and Get methods
                ///  - all public properties with Get method which derived from ICollection
                /// </summary>
                /// <param name="objectToSerialize">Object to be serialized.</param>
                /// <param name="writer">Defines the serialization destination. Can be Stream, TextWriter, XmlWriter or String (file name).</param>
                
        internal override void Serialize(object objectToSerialize, object writer)
                {
            // the possible writer types
            Stream stream = writer as Stream;
            TextWriter textWriter = writer as TextWriter;
            XmlWriter xmlWriter = writer as XmlWriter;
            string writerStr = writer as string;

                        // Check input parameters
                        if(objectToSerialize == null)
                        {
                                throw(new ArgumentNullException("objectToSerialize"));
                        }
                        if(writer == null)
                        {
                                throw(new ArgumentNullException("writer"));
                        }
                        if(stream == null && textWriter == null && xmlWriter == null && writerStr == null)
                        {
                throw (new ArgumentException(SR.ExceptionChartSerializerWriterObjectInvalid, "writer"));
                        }

                        // Create XML document
                        XmlDocument xmlDocument = new XmlDocument();
                
                        // Create document fragment
                        XmlDocumentFragment docFragment = xmlDocument.CreateDocumentFragment();



                        // Serialize object
                        SerializeObject(objectToSerialize, null, GetObjectName(objectToSerialize), docFragment, xmlDocument);


                        // Append document fragment
                        xmlDocument.AppendChild(docFragment);

                        // Remove empty child nodes
                        RemoveEmptyChildNodes(xmlDocument);

                        // Save XML document into the writer
                        if(stream != null)
                        {
                                xmlDocument.Save(stream);

                                // Flush stream and seek to the beginning
                stream.Flush();
                stream.Seek(0, SeekOrigin.Begin);
                        }

                        if(writerStr != null)
                        {
                                xmlDocument.Save(writerStr);
                        }

                        if(xmlWriter != null)
                        {
                xmlDocument.Save(xmlWriter);
                        }

                        if(textWriter != null)
                        {
                xmlDocument.Save(textWriter);
                        }
                }
        /// <summary>
                /// Serialize specified object into the XML format.
                /// Method is called recursively to serialize child objects.
                /// </summary>
                /// <param name="objectToSerialize">Object to be serialized.</param>
                /// <param name="parent">Parent of the serialized object.</param>
                /// <param name="elementName">Object element name.</param>
                /// <param name="xmlParentNode">The XmlNode of the parent object to serialize the data in.</param>
                /// <param name="xmlDocument">The XmlDocument the parent node belongs to.</param>
        virtual protected void SerializeObject(object objectToSerialize, object parent, string elementName, XmlNode xmlParentNode, XmlDocument xmlDocument)
        {
                        // Check input parameters
                        if(objectToSerialize == null)
                        {
                                return;
                        }

                        // Check if object should be serialized
                        if(parent != null)
                        {
                                PropertyDescriptor pd = TypeDescriptor.GetProperties(parent)[elementName];
                                if(pd != null)
                                {
                                        SerializationVisibilityAttribute        styleAttribute = (SerializationVisibilityAttribute)pd.Attributes[typeof(SerializationVisibilityAttribute)];
                                        if(styleAttribute != null)
                                        {
                                                // Hidden property
                                                if(styleAttribute.Visibility == SerializationVisibility.Hidden)
                                                {
                                                        return;
                                                }
                                        }
                                }
                        }

                        // Check if object is a collection
                        if(objectToSerialize is ICollection)
                        {
                                // Serialize collection
                                SerializeCollection(objectToSerialize, elementName, xmlParentNode, xmlDocument);
                                return;
                        }

                        // Create object element inside the parents node
                        XmlNode xmlNode = xmlDocument.CreateElement(elementName);
                        xmlParentNode.AppendChild(xmlNode);

                        // Write template data into collection items
                        bool templateListItem = false;
            IList parentList = parent as IList;
                        if(this.IsTemplateMode && parentList != null)
                        {
                                // Create "_Template_" attribute
                                XmlAttribute attrib = xmlDocument.CreateAttribute("_Template_");

                                // Check number of items in collection
                if (parentList.Count == 1)
                                {
                                        // If only one iten in collection, set "All" value.
                                        // This means that style of this object should be applied to all
                                        // existing items of the collection.
                                        attrib.Value = "All";
                                }
                                else
                                {
                                        // If there is more than one item, use it's index.
                                        // When loading, style of these items will be applied to existing 
                                        // items in collection in the loop.
                    int itemIndex = parentList.IndexOf(objectToSerialize);
                    attrib.Value = itemIndex.ToString(CultureInfo.InvariantCulture);
                                }

                                // Add "_Template_" attribute into the XML node
                                xmlNode.Attributes.Append(attrib);
                                templateListItem = true;
                        }

            // Retrive properties list of the object
            PropertyInfo[] properties = objectToSerialize.GetType().GetProperties();
            if (properties != null)
            {
                                // Loop through all properties and serialize public properties
                                foreach(PropertyInfo pi in properties)
                                {

                                        // Skip "Name" property from collection items in template mode
                                        if(templateListItem && pi.Name == "Name")
                                        {
                                                continue;
                                        }

                                        // Skip inherited properties from the root object
                                        if(IsChartBaseProperty(objectToSerialize, parent, pi))
                                        {
                                                continue;
                                        }

                    // Check if this property is serializable content
                    if (!IsSerializableContent(pi.Name, objectToSerialize))
                    {
                        continue;
                    }
 
                    // Serialize collection

                    if (pi.CanRead && pi.PropertyType.GetInterface("ICollection", true) != null && !this.SerializeICollAsAtribute(pi, objectToSerialize))
                    {
                        // Check if SerializationVisibilityAttribute is set
                                                bool    serialize = true;
                                                if(objectToSerialize != null)
                                                {
                                                        PropertyDescriptor pd = TypeDescriptor.GetProperties(objectToSerialize)[pi.Name];
                                                        if(pd != null)
                                                        {
                                                                SerializationVisibilityAttribute        styleAttribute = (SerializationVisibilityAttribute)pd.Attributes[typeof(SerializationVisibilityAttribute)];
                                                                if(styleAttribute != null)
                                                                {
                                                                        if(styleAttribute.Visibility == SerializationVisibility.Hidden)
                                                                        {
                                                                                serialize = false;
                                                                        }
                                                                }
                                                        }
                                                }
                                                // Check if collection has "ShouldSerialize" method
                                                MethodInfo mi = objectToSerialize.GetType().GetMethod("ShouldSerialize" + pi.Name, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public );
                                                if(mi != null)
                                                {
                                                        object result = mi.Invoke(objectToSerialize, null);
                                                        if(result is bool && ((bool)result) == false)
                                                        {
                                                                // Do not serialize collection
                                                                serialize = false;
                                                        }
                                                }

                                                // Serialize collection
                                                if(serialize)
                                                {
                                                        SerializeCollection(pi.GetValue(objectToSerialize, null), pi.Name, xmlNode, xmlDocument);
                                                }
                                        }

                                        // Serialize public properties with Get and Set methods
                                        else if(pi.CanRead && pi.CanWrite)
                                        {
                                                // Skip indexes
                                                if(pi.Name == "Item")
                                                {
                                                        continue;
                                                }

                                                // Check if an object should be serialized as a property or as a class
                                                if(ShouldSerializeAsAttribute(pi, objectToSerialize))
                                                {
                                                        // Serialize property
                                                        SerializeProperty(pi.GetValue(objectToSerialize, null), objectToSerialize, pi.Name, xmlNode, xmlDocument);
                                                }
                                                else
                                                {
                                                        // Serialize inner object
                                                        SerializeObject(pi.GetValue(objectToSerialize, null), objectToSerialize, pi.Name, xmlNode, xmlDocument);
                                                }
                                        }
                                }
                        }
                        return;
                }


        /// <summary>
        /// Serializes the data point.
        /// </summary>
        /// <param name="objectToSerialize">The object to serialize.</param>
        /// <param name="xmlParentNode">The XML parent node.</param>
        /// <param name="xmlDocument">The XML document.</param>
        internal void SerializeDataPoint(object objectToSerialize, XmlNode xmlParentNode, XmlDocument xmlDocument)
        {
            // Create object element inside the parents node
            XmlNode xmlNode = xmlDocument.CreateElement(GetObjectName(objectToSerialize));
            xmlParentNode.AppendChild(xmlNode);
            
            DataPoint dataPoint = objectToSerialize as DataPoint;
            if (dataPoint.XValue != 0d && IsSerializableContent("XValue", objectToSerialize))
            {
                XmlAttribute attrib = xmlDocument.CreateAttribute("XValue");
                attrib.Value = GetXmlValue(dataPoint.XValue, dataPoint, "XValue");
                xmlNode.Attributes.Append(attrib);
            }
            if (dataPoint.YValues.Length > 0 && IsSerializableContent("YValues", objectToSerialize))
            {
                XmlAttribute attrib = xmlDocument.CreateAttribute("YValues");
                attrib.Value = GetXmlValue(dataPoint.YValues, dataPoint, "YValues");
                xmlNode.Attributes.Append(attrib);
            }
            if (dataPoint.IsEmpty && IsSerializableContent("IsEmpty", objectToSerialize))
            {
                XmlAttribute attrib = xmlDocument.CreateAttribute("IsEmpty");
                attrib.Value = GetXmlValue(dataPoint.isEmptyPoint, dataPoint, "IsEmpty");
                xmlNode.Attributes.Append(attrib);
            }
            bool hasCustomProperties = false;
            foreach (DictionaryEntry entry in dataPoint.properties)
            {
                if (entry.Key is int)
                {
                    CommonCustomProperties propertyType = (CommonCustomProperties)((int)entry.Key);
                    String properyName = propertyType.ToString();
                    if (IsSerializableContent(properyName, objectToSerialize))
                    {
                        XmlAttribute attrib = xmlDocument.CreateAttribute(properyName);
                        attrib.Value = GetXmlValue(entry.Value, dataPoint, properyName);
                        xmlNode.Attributes.Append(attrib);
                    }
                }
                else
                {
                    hasCustomProperties = true;
                }
            }

            if (hasCustomProperties && !String.IsNullOrEmpty(dataPoint.CustomProperties) && IsSerializableContent("CustomProperties", objectToSerialize))
            {
                XmlAttribute attrib = xmlDocument.CreateAttribute("CustomProperties");
                attrib.Value = GetXmlValue(dataPoint.CustomProperties, dataPoint, "CustomProperties");
                xmlNode.Attributes.Append(attrib);
            }            

        }

                /// <summary>
                /// Serialize specified object into the XML text writer.
                /// Method is called recursively to serialize child objects.
                /// </summary>
                /// <param name="objectToSerialize">Object to be serialized.</param>
                /// <param name="elementName">Object element name.</param>
                /// <param name="xmlParentNode">The XmlNode of the parent object to serialize the data in.</param>
                /// <param name="xmlDocument">The XmlDocument the parent node belongs to.</param>
                virtual protected void SerializeCollection(object objectToSerialize, string elementName, XmlNode xmlParentNode, XmlDocument xmlDocument)
                {
            ICollection collection = objectToSerialize as ICollection;
                        if(collection != null)
                        {
                                // Create object element inside the parents node
                                XmlNode xmlNode = xmlDocument.CreateElement(elementName);
                                xmlParentNode.AppendChild(xmlNode);
                // Enumerate through all objects in collection and serialize them
                                foreach(object obj in collection)
                                {

                    if (obj is DataPoint)
                    {
                        SerializeDataPoint(obj, xmlNode, xmlDocument);
                        continue;
                    }

                    SerializeObject(obj, objectToSerialize, GetObjectName(obj), xmlNode, xmlDocument);
                                }
                        }
                }

                /// <summary>
                /// Serialize specified object into the XML text writer.
                /// Method is called recursively to serialize child objects.
                /// </summary>
                /// <param name="objectToSerialize">Object to be serialized.</param>
                /// <param name="parent">Parent of the serialized object.</param>
                /// <param name="elementName">Object element name.</param>
                /// <param name="xmlParentNode">The XmlNode of the parent object to serialize the data in.</param>
                /// <param name="xmlDocument">The XmlDocument the parent node belongs to.</param>
                virtual protected void SerializeProperty(object objectToSerialize, object parent, string elementName, XmlNode xmlParentNode, XmlDocument xmlDocument)
                {
                        // Check input parameters
                        if(objectToSerialize == null || parent == null)
                        {
                                return;
                        }

                        // Check if property has non-default value
                        PropertyDescriptor pd = TypeDescriptor.GetProperties(parent)[elementName];
                        if(pd != null)
                        {
                                DefaultValueAttribute defValueAttribute = (DefaultValueAttribute)pd.Attributes[typeof(DefaultValueAttribute)];
                                if(defValueAttribute != null)
                                {
                                        if(objectToSerialize.Equals(defValueAttribute.Value))
                                        {
                                                // Do not serialize properties with default values
                                                return;
                                        }
                                }
                                else
                                {
                                        // Check if property has "ShouldSerialize" method
                    MethodInfo mi = parent.GetType().GetMethod("ShouldSerialize" + elementName, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
                                        if(mi != null)
                                        {
                                                object result = mi.Invoke(parent, null);
                                                if(result is bool && ((bool)result) == false)
                                                {
                                                        // Do not serialize properties with default values
                                                        return;
                                                }
                                        }
                                }
                        
                                // Check XmlFormatSerializerStyle attribute
                                SerializationVisibilityAttribute        styleAttribute = (SerializationVisibilityAttribute)pd.Attributes[typeof(SerializationVisibilityAttribute)];
                                if(styleAttribute != null)
                                {
                                        // Hidden property
                                        if(styleAttribute.Visibility == SerializationVisibility.Hidden)
                                        {
                                                return;
                                        }
                                }
                        }

                        // Serialize property as a parents node attribute
                        XmlAttribute attrib = xmlDocument.CreateAttribute(elementName);
                        attrib.Value = GetXmlValue(objectToSerialize, parent, elementName);
                        xmlParentNode.Attributes.Append(attrib);
                }

                /// <summary>
                /// Converts object value into the string.
                /// </summary>
                /// <param name="obj">Object to convert.</param>
                /// <param name="parent">Object parent.</param>
                /// <param name="elementName">Object name.</param>
                /// <returns>Object value as strig.</returns>
                protected string GetXmlValue(object obj, object parent, string elementName)
                {
            string objStr = obj as string;
                        if(objStr != null)
                        {
                return objStr;
                        }

            Font font = obj as Font;
            if(font != null)
                        {
                                return SerializerBase.FontToString(font);
                        }

                        if(obj is Color)
                        {
                                return colorConverter.ConvertToString(null, System.Globalization.CultureInfo.InvariantCulture, obj);
                        }

            Color[] colors = obj as Color[];
                        if(colors != null)
                        {
                                return ColorArrayConverter.ColorArrayToString(colors);
                        }

#if !Microsoft_CONTROL
            if(obj is Unit)
                        {
                Unit unit = (Unit)obj;
                                return unit.Value.ToString(System.Globalization.CultureInfo.InvariantCulture);
                        }
#endif

            System.Drawing.Image image = obj as System.Drawing.Image;
                        if(image != null)
                        {
                                return ImageToString(image);
                        }

                        // Look for the converter set with the attibute
                        PropertyDescriptor pd = TypeDescriptor.GetProperties(parent)[elementName];
                        if(pd != null)
                        {
                TypeConverter converter = this.FindConverter(pd);
                if (converter != null && converter.CanConvertTo(typeof(string)))
                                {
                    return converter.ConvertToString(null, System.Globalization.CultureInfo.InvariantCulture, obj);
                                }
                        }
                        
                        // Try using default string convertion
                        return obj.ToString();
                }

                /// <summary>
                /// Removes all empty nodes from the XML document.
                /// Method is called recursively to remove empty child nodes first.
                /// </summary>
                /// <param name="xmlNode">The node where to start the removing.</param>
                private void RemoveEmptyChildNodes(XmlNode xmlNode)
                {
                        // Loop through all child nodes
                        for(int nodeIndex = 0; nodeIndex < xmlNode.ChildNodes.Count; nodeIndex++)
                        {
                                // Remove empty child nodes of the child
                                RemoveEmptyChildNodes(xmlNode.ChildNodes[nodeIndex]);

                                // Check if there are any non-empty nodes left
                                XmlNode currentNode = xmlNode.ChildNodes[nodeIndex];
                                if( currentNode.ParentNode != null &&
                                        !(currentNode.ParentNode is XmlDocument) )
                                {
                                        if(!currentNode.HasChildNodes && 
                                                (currentNode.Attributes == null ||
                                                currentNode.Attributes.Count == 0))
                                        {
                                                // Remove node
                                                xmlNode.RemoveChild(xmlNode.ChildNodes[nodeIndex]);
                                                --nodeIndex;
                                        }
                                }



                                // Remove node with one "_Template_" attribute
                                if(!currentNode.HasChildNodes && 
                                        currentNode.Attributes.Count == 1 &&
                                        currentNode.Attributes["_Template_"] != null)
                                {
                                        // Remove node
                                        xmlNode.RemoveChild(xmlNode.ChildNodes[nodeIndex]);
                                        --nodeIndex;
                                }



                        }
                }

                #endregion

                #region Deserialization public methods

                /// <summary>
                /// Deserialize specified object from the stream.
                /// </summary>
                /// <param name="objectToDeserialize">Object to be deserialized.</param>
                /// <param name="stream">The stream used to read the XML document from.</param>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
                internal void Deserialize(object objectToDeserialize, Stream stream)
                {
                        Deserialize(objectToDeserialize, (object)stream);
                }

                /// <summary>
                /// Deserialize specified object from the XML reader.
                /// </summary>
                /// <param name="objectToDeserialize">Object to be deserialized.</param>
                /// <param name="xmlReader">The XmlReader used to read the XML document from.</param>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal void Deserialize(object objectToDeserialize, XmlReader xmlReader)
                {
                        Deserialize(objectToDeserialize, (object)xmlReader);
                }

                /// <summary>
                /// Deserialize specified object from the text reader.
                /// </summary>
                /// <param name="objectToDeserialize">Object to be deserialized.</param>
                /// <param name="textReader">The TextReader used to write the XML document from.</param>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal void Deserialize(object objectToDeserialize, TextReader textReader)
                {
                        Deserialize(objectToDeserialize, (object)textReader);
                }

                /// <summary>
                /// Deserialize specified object from the file.
                /// </summary>
                /// <param name="objectToDeserialize">Object to be deserialized.</param>
                /// <param name="fileName">The file name used to read the XML document from.</param>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal void Deserialize(object objectToDeserialize, string fileName)
                {
                        Deserialize(objectToDeserialize, (object)fileName);
                }

                #endregion

                #region Deserialization private methods

                /// <summary>
                /// Deserialize object from different types of readers using XML format.
                /// </summary>
                /// <param name="objectToDeserialize">Object to be deserialized.</param>
                /// <param name="reader">Defines the deserialization data source. Can be Stream, TextReader, XmlReader or String (file name).</param>
        internal override void Deserialize(object objectToDeserialize, object reader)
                {
            // the four possible types of readers
            Stream stream = reader as Stream;
            TextReader textReader = reader as TextReader;
            XmlReader xmlReader = reader as XmlReader;
            string readerStr = reader as string;

                        // Check input parameters
                        if(objectToDeserialize == null)
                        {
                                throw(new ArgumentNullException("objectToDeserialize"));
                        }
                        if(reader == null)
                        {
                                throw(new ArgumentNullException("reader"));
                        }
                        if(stream == null && textReader == null && xmlReader == null && readerStr == null)
                        {
                throw (new ArgumentException(SR.ExceptionChartSerializerReaderObjectInvalid, "reader"));
                        }

                        // Create XML document
                        XmlDocument xmlDocument = new XmlDocument();
            XmlReader xmlBaseReader = null;
            try
            {
                // process files without DTD
                XmlReaderSettings settings = new XmlReaderSettings();
                // settings.ProhibitDtd is obsolete inn NetFx 4.0, the #ifdef stays for compilation under NetFx 3.5.
#if OLD_DTD
                settings.ProhibitDtd = true;
#else
                settings.DtdProcessing = DtdProcessing.Prohibit; //don't allow DTD
#endif
                // Load XML document from the reader
                if (stream != null)
                {
                    xmlBaseReader = XmlReader.Create(stream, settings);
                }
                if (readerStr != null)
                {
                    xmlBaseReader = XmlReader.Create(readerStr, settings);
                }
                if (xmlReader != null)
                {
                    xmlBaseReader = XmlReader.Create(xmlReader, settings);
                }
                if (textReader != null)
                {
                    xmlBaseReader = XmlReader.Create(textReader, settings);
                }

                xmlDocument.Load(xmlBaseReader);

                // Reset properties of the root object
                if (IsResetWhenLoading)
                {
                    ResetObjectProperties(objectToDeserialize);
                }

                // Deserialize object
                DeserializeObject(objectToDeserialize, null, GetObjectName(objectToDeserialize), xmlDocument.DocumentElement, xmlDocument);
            }
            finally
            {
                if (xmlBaseReader != null)
                {
                    ((IDisposable)xmlBaseReader).Dispose();
                }
            }
                }

                /// <summary>
                /// Deserialize object from the XML format.
                /// Method is called recursively to deserialize child objects.
                /// </summary>
                /// <param name="objectToDeserialize">Object to be deserialized.</param>
                /// <param name="parent">Parent of the deserialized object.</param>
                /// <param name="elementName">Object element name.</param>
                /// <param name="xmlParentNode">The XmlNode of the parent object to deserialize the data from.</param>
                /// <param name="xmlDocument">The XmlDocument the parent node belongs to.</param>
                /// <returns>Number of properties set.</returns>
                virtual internal int DeserializeObject(object objectToDeserialize, object parent, string elementName, XmlNode xmlParentNode, XmlDocument xmlDocument)
                {
                        int     setPropertiesNumber = 0;

                        // Check input parameters
                        if(objectToDeserialize == null)
                        {
                                return setPropertiesNumber;
                        }

                        // Loop through all node properties
                        foreach(XmlAttribute attr in xmlParentNode.Attributes)
                        {
                                // Skip template collection item attribute
                                if(attr.Name == "_Template_")
                                {
                                        continue;
                                }

                                // Check if this property is serializable content
                                if(IsSerializableContent(attr.Name, objectToDeserialize))
                                {
                                        SetXmlValue(objectToDeserialize, attr.Name, attr.Value);
                                        ++setPropertiesNumber;
                                }
                        }



                        // Read template data into the collection 
            IList list = objectToDeserialize as IList;

                        if(this.IsTemplateMode && 
                                list != null && 
                                xmlParentNode.FirstChild.Attributes["_Template_"] != null)
                        {
                                // Loop through all items in collection
                                int     itemIndex = 0;
                                foreach(object listItem in list)
                                {
                                        // Find XML node appropriate for the item from the collection
                                        XmlNode listItemNode = null;

                                        // Loop through all child nodes
                                        foreach(XmlNode childNode in xmlParentNode.ChildNodes)
                                        {
                                                string templateString = childNode.Attributes["_Template_"].Value;
                                                if(templateString != null && templateString.Length > 0)
                                                {
                                                        if(templateString == "All")
                                                        {
                                                                listItemNode = childNode;
                                                                break;
                                                        }
                                                        else
                                                        {
                                                                // If there is more items in collection than XML node in template
                                                                // apply items in a loop
                                                                int loopItemIndex = itemIndex;
                                                                while(loopItemIndex > xmlParentNode.ChildNodes.Count - 1)
                                                                {
                                                                        loopItemIndex -= xmlParentNode.ChildNodes.Count;
                                                                }

                                                                // Convert attribute value to index
                                int nodeIndex = int.Parse(templateString, CultureInfo.InvariantCulture);
                                                                if(nodeIndex == loopItemIndex)
                                                                {
                                                                        listItemNode = childNode;
                                                                        break;
                                                                }
                                                        }
                                                }
                                        }

                                        // Load data from the node
                                        if(listItemNode != null)
                                        {
                                                // Load object data
                                                DeserializeObject(listItem, objectToDeserialize, "", listItemNode, xmlDocument);
                                        }

                                        // Increase item index
                                        ++itemIndex;
                                }

                                // No futher loading required
                                return 0;
                        }



                        // Loop through all child elements
                        int     listItemIndex = 0;
                        foreach(XmlNode childNode in xmlParentNode.ChildNodes)
                        {
                // Special handling for the collections
                // Bug VSTS #235707 - The collections IsSerializableContent are already checked as a property in the else statement.
                if (list != null)
                {
                    // Create new item object
                    string itemName = null;
                    if (childNode.Attributes["Name"] != null)
                    {
                        itemName = childNode.Attributes["Name"].Value;
                    }

                    bool reusedObject = false;
                    object listItem = GetListNewItem(list, childNode.Name, ref itemName, ref reusedObject);

                    // Deserialize list item object
                    int itemSetProperties = DeserializeObject(listItem, objectToDeserialize, "", childNode, xmlDocument);
                    setPropertiesNumber += itemSetProperties;

                    // Add item object into the list
                    if (itemSetProperties > 0 || reusedObject)
                    {
                        list.Insert(listItemIndex++, listItem);
                    }
                }

                else
                {
                    // Check if this property is serializable content
                    if (IsSerializableContent(childNode.Name, objectToDeserialize))
                    {
                        // Deserialize the property using property descriptor
                        PropertyDescriptor pd = TypeDescriptor.GetProperties(objectToDeserialize)[childNode.Name];
                        if (pd != null)
                        {
                            object innerObject = pd.GetValue(objectToDeserialize);

                            // Deserialize list item object
                            setPropertiesNumber += DeserializeObject(innerObject, objectToDeserialize, childNode.Name, childNode, xmlDocument);
                        }
                        else if (!IsUnknownAttributeIgnored)
                        {
                            throw (new InvalidOperationException(SR.ExceptionChartSerializerPropertyNameUnknown(childNode.Name, objectToDeserialize.GetType().ToString())));
                        }
                    }
                }
                        }

                        return setPropertiesNumber;
                }

        /// <summary>
        /// Sets a property of an object using name and value as string.
        /// </summary>
        /// <param name="obj">Object to set.</param>
        /// <param name="attrName">Attribute (property) name.</param>
        /// <param name="attrValue">Object value..</param>
        /// <returns>Object value as strig.</returns>
                private void SetXmlValue(object obj, string attrName, string attrValue)
                {
                        PropertyInfo pi = obj.GetType().GetProperty(attrName);
                        if(pi != null)
                        {
                                // Convert string to object value
                                object objValue = attrValue;

                                if(pi.PropertyType == typeof(string))
                                {
                                        objValue = attrValue;
                                }

                                else if(pi.PropertyType == typeof(Font))
                                {
                                        objValue = SerializerBase.FontFromString(attrValue);
                                }

                                else if(pi.PropertyType == typeof(Color))
                                {
                                        objValue = (Color)colorConverter.ConvertFromString(null, System.Globalization.CultureInfo.InvariantCulture, attrValue);
                                }

#if !Microsoft_CONTROL
                                else if(pi.PropertyType == typeof(Unit))
                                {
                                        objValue = new Unit(Int32.Parse(attrValue, System.Globalization.CultureInfo.InvariantCulture));
                                }
#endif

                                else if(pi.PropertyType == typeof(System.Drawing.Image))
                                {
                                        objValue = ImageFromString(attrValue);
                                }

                                else
                                {
                                        // Look for the converter set with the attibute
                                        PropertyDescriptor pd = TypeDescriptor.GetProperties(obj)[attrName];
                                        if(pd != null)
                                        {
                        TypeConverter converter = this.FindConverter(pd);
                        if (converter != null && converter.CanConvertFrom(typeof(string)))
                                                {
                            objValue = converter.ConvertFromString(null, System.Globalization.CultureInfo.InvariantCulture, attrValue);
                                                }
                                        }
                                }

                                // Set object value
                                pi.SetValue(obj, objValue, null);
                        }
                        else if(!IsUnknownAttributeIgnored)
                        {
                                throw(new InvalidOperationException(SR.ExceptionChartSerializerPropertyNameUnknown( attrName,obj.GetType().ToString())));
                        }
                }

                #endregion
        }

        /// <summary>
        /// Utility class which serialize object using binary format
        /// </summary>
        internal class BinaryFormatSerializer : SerializerBase
        {
                #region Serialization methods

                /// <summary>
                /// Serialize specified object into the destination using binary format.
                /// </summary>
                /// <param name="objectToSerialize">Object to be serialized.</param>
                /// <param name="destination">Serialization destination.</param>
        internal override void Serialize(object objectToSerialize, object destination)
        {
            // Check input parameters
            if (objectToSerialize == null)
            {
                throw (new ArgumentNullException("objectToSerialize"));
            }
            if (destination == null)
            {
                throw (new ArgumentNullException("destination"));
            }

            string destinationStr = destination as string;
            if (destinationStr != null)
            {
                Serialize(objectToSerialize, destinationStr);
                return;
            }

            Stream stream = destination as Stream;
            if (stream != null)
            {
                Serialize(objectToSerialize, stream);
                return;
            }

            BinaryWriter binaryWriter = destination as BinaryWriter;
            if (binaryWriter != null)
            {
                Serialize(objectToSerialize, binaryWriter);
                return;
            }

            throw (new ArgumentException(SR.ExceptionChartSerializerDestinationObjectInvalid, "destination"));
        }

                /// <summary>
                /// Serialize specified object into the file using binary format.
                /// </summary>
                /// <param name="objectToSerialize">Object to be serialized.</param>
                /// <param name="fileName">File name to serialize the data in.</param>
        internal void Serialize(object objectToSerialize, string fileName)
                {
                        FileStream stream = new FileStream(fileName, FileMode.Create);
                        Serialize(objectToSerialize, new BinaryWriter(stream));
                        stream.Close();
                }


                /// <summary>
                /// Serialize specified object into the stream using binary format.
                /// </summary>
                /// <param name="objectToSerialize">Object to be serialized.</param>
                /// <param name="stream">Defines the serialization destination.</param>
                internal void Serialize(object objectToSerialize, Stream stream)
                {
                        Serialize(objectToSerialize, new BinaryWriter(stream));
                }

                /// <summary>
                /// Serialize specified object into different types of writers using binary format.
                /// Here is what is serialized in the object:
                ///      - all public properties with Set and Get methods
                ///  - all public properties with Get method which derived from ICollection
                /// </summary>
                /// <param name="objectToSerialize">Object to be serialized.</param>
                /// <param name="writer">Defines the serialization destination.</param>
                internal void Serialize(object objectToSerialize, BinaryWriter writer)
                {
                        // Check input parameters
                        if(objectToSerialize == null)
                        {
                                throw(new ArgumentNullException("objectToSerialize"));
                        }
                        if(writer == null)
                        {
                                throw(new ArgumentNullException("writer"));
                        }

                        // Write bnary format header into the stream, which consist of 15 characters
                        char[]  header = new char[15] {'D', 'C', 'B', 'F', '4', '0', '0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0'};
                        writer.Write(header);
                        

                        // Serialize object
                        SerializeObject(objectToSerialize, null, GetObjectName(objectToSerialize), writer);


                        // Flush the writer stream
                        writer.Flush();

                        // Reset stream position
                        writer.Seek(0, SeekOrigin.Begin);
                }

                /// <summary>
                /// Serialize specified object into the binary format.
                /// Method is called recursively to serialize child objects.
                /// </summary>
                /// <param name="objectToSerialize">Object to be serialized.</param>
                /// <param name="parent">Parent of the serialized object.</param>
                /// <param name="elementName">Object element name.</param>
                /// <param name="writer">Binary writer object.</param>
        virtual internal void SerializeObject(object objectToSerialize, object parent, string elementName, BinaryWriter writer)
                {
                        // Check input parameters
                        if(objectToSerialize == null)
                        {
                                return;
                        }

                        // Check if object should be serialized
                        if(parent != null)
                        {
                                PropertyDescriptor pd = TypeDescriptor.GetProperties(parent)[elementName];
                                if(pd != null)
                                {
                                        SerializationVisibilityAttribute        styleAttribute = (SerializationVisibilityAttribute)pd.Attributes[typeof(SerializationVisibilityAttribute)];
                                        if(styleAttribute != null)
                                        {
                                                // Hidden property
                                                if(styleAttribute.Visibility == SerializationVisibility.Hidden)
                                                {
                                                        return;
                                                }
                                        }
                                }
                        }

                        // Check if object is a collection
                        if(objectToSerialize is ICollection)
                        {
                                // Serialize collection
                                SerializeCollection(objectToSerialize, elementName, writer);
                                return;
                        }

                        // Write object ID (hash of the name) into the writer
                        writer.Write(SerializerBase.GetStringHashCode(elementName));

                        // Remember position where object data is started
                        long elementStartPosition = writer.Seek(0, SeekOrigin.Current);

                        // Retrive properties list of the object
                        ArrayList       propNamesList = new ArrayList();
                        PropertyInfo[] properties = objectToSerialize.GetType().GetProperties();
                        if(properties != null)
                        {
                                // Loop through all properties and serialize public properties
                                foreach(PropertyInfo pi in properties)
                                {
                                        // Skip inherited properties from the root object
                                        if(IsChartBaseProperty(objectToSerialize, parent, pi))
                                        {
                                                continue;
                                        }
                                        // Serialize collection
                    if (pi.CanRead && pi.PropertyType.GetInterface("ICollection", true) != null && !this.SerializeICollAsAtribute(pi, objectToSerialize))
                    {
                        bool serialize = IsSerializableContent(pi.Name, objectToSerialize);

                        // fixing Axes Array Framework 2.0 side effect
                        // fixed by:DT
                        if (serialize && objectToSerialize != null)
                        {
                            PropertyDescriptor pd = TypeDescriptor.GetProperties(objectToSerialize)[pi.Name];
                            if (pd != null)
                            {
                                SerializationVisibilityAttribute styleAttribute = (SerializationVisibilityAttribute)pd.Attributes[typeof(SerializationVisibilityAttribute)];
                                if (styleAttribute != null)
                                {
                                    if (styleAttribute.Visibility == SerializationVisibility.Hidden)
                                    {
                                        serialize = false;
                                    }
                                }
                            }
                        }

                        MethodInfo mi = objectToSerialize.GetType().GetMethod("ShouldSerialize" + pi.Name, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
                                                if( serialize && mi != null)
                                                {
                                                        object result = mi.Invoke(objectToSerialize, null);
                                                        if(result is bool && ((bool)result) == false)
                                                        {
                                                                // Do not serialize collection
                                                                serialize = false;
                                                        }
                                                }

                                                // Serialize collection
                                                if(serialize)
                                                {
                                                        propNamesList.Add(pi.Name);
                                                        SerializeCollection(pi.GetValue(objectToSerialize, null), pi.Name, writer);
                                                }
                                        }

                                        // Serialize public properties with Get and Set methods
                                        else if(pi.CanRead && pi.CanWrite)
                                        {
                                                // Skip indexes
                                                if(pi.Name == "Item")
                                                {
                                                        continue;
                                                }
                        // Check if this property is serializable content
                        if (IsSerializableContent(pi.Name, objectToSerialize))
                        {
                            // Check if an object should be serialized as a property or as a class
                            if (ShouldSerializeAsAttribute(pi, objectToSerialize))
                            {
                                // Serialize property
                                SerializeProperty(pi.GetValue(objectToSerialize, null), objectToSerialize, pi.Name, writer);
                            }
                            else
                            {
                                // Serialize inner object
                                SerializeObject(pi.GetValue(objectToSerialize, null), objectToSerialize, pi.Name, writer);
                            }
                        }
                                                propNamesList.Add(pi.Name);
                                        }
                                }
                        
                                // Check that all properties have unique IDs
                                CheckPropertiesID(propNamesList);
                        }


                        // If position of the writer did not change - nothing was written
                        if(writer.Seek(0, SeekOrigin.Current) == elementStartPosition)
                        {
                                // Remove object ID from the stream
                                writer.Seek(-2, SeekOrigin.Current);
                                writer.Write((short)0);
                                writer.Seek(-2, SeekOrigin.Current);
                        }
                        else
                        {
                                // Write the end objectTag 
                                writer.Write((short)0);
                        }

                        return;
                }


        /// <summary>
        /// Serializes the data point.
        /// </summary>
        /// <param name="objectToSerialize">The object to serialize.</param>
        /// <param name="elementName">Name of the element.</param>
        /// <param name="writer">The writer.</param>
        private void SerializeDataPoint(object objectToSerialize, string elementName, BinaryWriter writer)
        {

            // Write object ID (hash of the name) into the writer
            writer.Write(SerializerBase.GetStringHashCode(elementName));
            // Remember position where object data is started
            long elementStartPosition = writer.Seek(0, SeekOrigin.Current);    

            DataPoint dataPoint = objectToSerialize as DataPoint;
            if (dataPoint.XValue != 0d && IsSerializableContent("XValue", objectToSerialize))
            {
                SerializeProperty(dataPoint.XValue, dataPoint, "XValue", writer);
            }
            if (dataPoint.YValues.Length > 0 && IsSerializableContent("YValues", objectToSerialize))
            {
                SerializeProperty(dataPoint.YValues, dataPoint, "YValues", writer);
            }
            if (dataPoint.IsEmpty && IsSerializableContent("IsEmpty", objectToSerialize))
            {
                SerializeProperty(dataPoint.IsEmpty, dataPoint, "IsEmpty", writer);
            }
            bool hasCustomProperties = false;
            foreach (DictionaryEntry entry in dataPoint.properties)
            {
                if (entry.Key is int)
                {
                    CommonCustomProperties propertyType = (CommonCustomProperties)((int)entry.Key);
                    String properyName = propertyType.ToString();
                    if (IsSerializableContent(properyName, objectToSerialize))
                    {
                        SerializeProperty(entry.Value, dataPoint, properyName, writer);
                    }
                }
                else
                {
                    hasCustomProperties = true;
                }
            }

            if (hasCustomProperties && !String.IsNullOrEmpty(dataPoint.CustomProperties) && IsSerializableContent("CustomProperties", objectToSerialize))
            {
                SerializeProperty(dataPoint.CustomProperties, dataPoint, "CustomProperties", writer);
            }  

            // If position of the writer did not change - nothing was written
            if (writer.Seek(0, SeekOrigin.Current) == elementStartPosition)
            {
                // Remove object ID from the stream
                writer.Seek(-2, SeekOrigin.Current);
                writer.Write((short)0);
                writer.Seek(-2, SeekOrigin.Current);
            }
            else
            {
                // Write the end objectTag 
                writer.Write((short)0);
            }
        }


        /// <summary>
                /// Serialize specified object into the binary writer.
                /// Method is called recursively to serialize child objects.
                /// </summary>
                /// <param name="objectToSerialize">Object to be serialized.</param>
                /// <param name="elementName">Object element name.</param>
                /// <param name="writer">Binary writer.</param>
        virtual internal void SerializeCollection(object objectToSerialize, string elementName, BinaryWriter writer)
                {
            ICollection collection = objectToSerialize as ICollection;
                        if(collection != null)
                        {
                                // Write object ID (hash of the name) into the writer
                                writer.Write(SerializerBase.GetStringHashCode(elementName));

                                // Remember position where object data is started
                                long elementStartPosition = writer.Seek(0, SeekOrigin.Current);

                                // Enumerate through all objects in collection and serialize them
                foreach (object obj in collection)
                                {

                    if (obj is DataPoint)
                    {
                        SerializeDataPoint(obj, GetObjectName(obj), writer);
                        continue;
                    }

                    SerializeObject(obj, objectToSerialize, GetObjectName(obj), writer);
                                }

                                // If position of the writer did not change - nothing was written
                                if(writer.Seek(0, SeekOrigin.Current) == elementStartPosition)
                                {
                                        // Remove object ID from the stream
                                        writer.Seek(-2, SeekOrigin.Current);
                                        writer.Write((short)0);
                                        writer.Seek(-2, SeekOrigin.Current);
                                }
                                else
                                {
                                        // Write the end objectTag 
                                        writer.Write((short)0);
                                }

                        }
                }

                /// <summary>
                /// Serialize specified object into the binary writer.
                /// Method is called recursively to serialize child objects.
                /// </summary>
                /// <param name="objectToSerialize">Object to be serialized.</param>
                /// <param name="parent">Parent of the serialized object.</param>
                /// <param name="elementName">Object element name.</param>
                /// <param name="writer">Binary writer.</param>
        virtual internal void SerializeProperty(object objectToSerialize, object parent, string elementName, BinaryWriter writer)
                {
                        // Check input parameters
                        if(objectToSerialize == null || parent == null)
                        {
                                return;
                        }

                        // Check if property has non-default value
                        PropertyDescriptor pd = TypeDescriptor.GetProperties(parent)[elementName];
                        if(pd != null)
                        {
                                DefaultValueAttribute defValueAttribute = (DefaultValueAttribute)pd.Attributes[typeof(DefaultValueAttribute)];
                                if(defValueAttribute != null)
                                {
                                        if(objectToSerialize.Equals(defValueAttribute.Value))
                                        {
                                                // Do not serialize properties with default values
                                                return;
                                        }
                                }
                                else
                                {
                                        // Check if property has "ShouldSerialize" method
                                        MethodInfo mi = parent.GetType().GetMethod("ShouldSerialize" + elementName, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public );
                                        if(mi != null)
                                        {
                                                object result = mi.Invoke(parent, null);
                                                if(result is bool && ((bool)result) == false)
                                                {
                                                        // Do not serialize properties with default values
                                                        return;
                                                }
                                        }
                }
                        
                                // Check XmlFormatSerializerStyle attribute
                                SerializationVisibilityAttribute        styleAttribute = (SerializationVisibilityAttribute)pd.Attributes[typeof(SerializationVisibilityAttribute)];
                                if(styleAttribute != null)
                                {
                                        // Hidden property
                                        if(styleAttribute.Visibility == SerializationVisibility.Hidden)
                                        {
                                                return;
                                        }
                                }
                        }

                        // Write property 
                        WritePropertyValue(objectToSerialize, elementName, writer);
                }

                /// <summary>
                /// Converts object value into the string.
                /// </summary>
                /// <param name="obj">Object to convert.</param>
                /// <param name="elementName">Object name.</param>
                /// <param name="writer">Binary writer.</param>
                /// <returns>Object value as strig.</returns>
        [SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily",
            Justification = "Too large of a code change to justify making this change")]
        internal void WritePropertyValue(object obj, string elementName, BinaryWriter writer)
                {
                        // Write property ID (hash of the name) into the writer
                        writer.Write(SerializerBase.GetStringHashCode(elementName));
                        
                        if(obj is bool)
                        {
                                writer.Write(((bool)obj));
                        }
                        else if(obj is double)
                        {
                                writer.Write(((double)obj));
                        }
                        else if(obj is string)
                        {
                                writer.Write(((string)obj));
                        }
                        else if(obj is int)
                        {
                                writer.Write(((int)obj));
                        }
                        else if(obj is long)
                        {
                                writer.Write(((long)obj));
                        }
                        else if(obj is float)
                        {
                                writer.Write(((float)obj));
                        }
                        else if(obj.GetType().IsEnum)
                        {
                                // NOTE: Using 'ToString' method instead of the 'Enum.GetName' fixes
                                // an issue (#4314 & #4424) with flagged enumerations when there are
                                // more then 1 values set.
                                string enumValue = obj.ToString();
                                writer.Write(enumValue);
                        }

                        else if(obj is byte)
                        {
                                // Write as long
                                writer.Write((byte)obj);
                        }

#if !Microsoft_CONTROL
                        else if(obj is Unit)
                        {
                                writer.Write(((Unit)obj).Value);
                        }
#endif

                        else if(obj is Font)
                        {
                                // Write as string
                                writer.Write(SerializerBase.FontToString((Font)obj));
                        }

                        else if(obj is Color)
                        {
                                // Write as int
                                writer.Write(((Color)obj).ToArgb());
                        }

                        else if(obj is DateTime)
                        {
                                // Write as long
                                writer.Write(((DateTime)obj).Ticks);
                        }

                        else if(obj is Size)
                        {
                                // Write as two integers
                                writer.Write(((Size)obj).Width);
                                writer.Write(((Size)obj).Height);
                        }

                        else if(obj is double[])
                        {
                                double[] arr = (double[])obj;

                                // Write the size of the array (int)
                                writer.Write(arr.Length);

                                // Write each element of the array
                                foreach(double d in arr)
                                {
                                        writer.Write(d);
                                }
                        }
                        
                        else if(obj is Color[])
                        {
                                Color[] arr = (Color[])obj;

                                // Write the size of the array (int)
                                writer.Write(arr.Length);

                                // Write each element of the array
                                foreach(Color color in arr)
                                {
                                        writer.Write(color.ToArgb());
                                }
                        }

                        else if(obj is System.Drawing.Image)
                        {
                                // Save image into the memory stream
                                MemoryStream imageStream = new MemoryStream();
                                ((System.Drawing.Image)obj).Save(imageStream, ((System.Drawing.Image)obj).RawFormat);
                                
                                // Write the size of the data
                                int imageSize = (int)imageStream.Seek(0, SeekOrigin.End);
                                imageStream.Seek(0, SeekOrigin.Begin);
                                writer.Write(imageSize);

                                // Write the data
                                writer.Write(imageStream.ToArray());

                                imageStream.Close();
                        }



                        else if(obj is Margins)
                        {
                                // Write as 4 integers
                                writer.Write(((Margins)obj).Top);
                                writer.Write(((Margins)obj).Bottom);
                                writer.Write(((Margins)obj).Left);
                                writer.Write(((Margins)obj).Right);
                        }



                        else
                        {
                throw (new InvalidOperationException(SR.ExceptionChartSerializerBinaryTypeUnsupported(obj.GetType().ToString())));
                        }
                }

                /// <summary>
                /// Checks if all properties will have a unique ID.
                /// Property ID is a hash of it's name.
                /// !!!USED IN DEBUG BUILD ONLY!!!
                /// </summary>
                /// <param name="propNames">Array of properties names.</param>
        internal void CheckPropertiesID(ArrayList propNames)
                {
#if DEBUG
                        if(propNames != null)
                        {
                                // Loop through all properties and check the hash values
                                foreach(string name1 in propNames)
                                {
                                        foreach(string name2 in propNames)
                                        {
                                                if(name1 != name2)
                                                {
                                                        if( SerializerBase.GetStringHashCode(name1) == SerializerBase.GetStringHashCode(name2) )
                                                        {
                                throw (new InvalidOperationException(SR.ExceptionChartSerializerBinaryHashCodeDuplicate(name1,name2)));
                                                        }
                                                }
                                        }
                                }
                        }
#endif
                }
                #endregion

                #region Deserialization methods

                /// <summary>
                /// Deserialize specified object from the source using binary format.
                /// </summary>
                /// <param name="objectToDeserialize">Object to be deserialized.</param>
                /// <param name="source">Deserialization source.</param>
        internal override void Deserialize(object objectToDeserialize, object source)
        {
            // Check input parameters
            if (objectToDeserialize == null)
            {
                throw (new ArgumentNullException("objectToDeserialize"));
            }
            if (source == null)
            {
                throw (new ArgumentNullException("source"));
            }

            string sourceStr = source as string;
            if (sourceStr != null)
            {
                Deserialize(objectToDeserialize, sourceStr);
                return;
            }

            Stream stream = source as Stream;
            if (stream != null)
            {
                Deserialize(objectToDeserialize, stream);
                return;
            }

            BinaryWriter binaryWriter = source as BinaryWriter;
            if (binaryWriter != null)
            {
                Deserialize(objectToDeserialize, binaryWriter);
                return;
            }

            throw (new ArgumentException(SR.ExceptionChartSerializerSourceObjectInvalid, "source"));
        }

                /// <summary>
                /// Deserialize object from the file using binary format.
                /// </summary>
                /// <param name="objectToDeserialize">Object to be deserialized.</param>
                /// <param name="fileName">File name to read the data from.</param>
                public void Deserialize(object objectToDeserialize, string fileName)
                {
                        FileStream stream = new FileStream(fileName, FileMode.Open);
                        Deserialize(objectToDeserialize, new BinaryReader(stream));
                        stream.Close();
                }

                /// <summary>
                /// Deserialize object from the stream using binary format.
                /// </summary>
                /// <param name="objectToDeserialize">Object to be deserialized.</param>
                /// <param name="stream">Stream to read the data from.</param>
                public void Deserialize(object objectToDeserialize, Stream stream)
                {
                        Deserialize(objectToDeserialize, new BinaryReader(stream));
                }

                /// <summary>
                /// Deserialize object from different types of readers using binary format.
                /// </summary>
                /// <param name="objectToDeserialize">Object to be deserialized.</param>
                /// <param name="reader">Binary reader.</param>
                public void Deserialize(object objectToDeserialize, BinaryReader reader)
                {
                        // Check input parameters
                        if(objectToDeserialize == null)
                        {
                                throw(new ArgumentNullException("objectToDeserialize"));
                        }
                        if(reader == null)
                        {
                                throw(new ArgumentNullException("reader"));
                        }

                        // Binary deserializer do not support IsUnknownAttributeIgnored property
                        if(base.IsUnknownAttributeIgnored)
                        {
                throw (new InvalidOperationException(SR.ExceptionChartSerializerBinaryIgnoreUnknownAttributesUnsupported));
                        }

                        // Read 15 characters of file header
                        char[]  header = reader.ReadChars(15);
                        if(header[0] != 'D' || header[1] != 'C' || header[2] != 'B' || header[3] != 'F')
                        {
                throw (new InvalidOperationException(SR.ExceptionChartSerializerBinaryFromatInvalid));
                        }

                        // Get ID of the root object
                        this.ReadHashID(reader);
 
                        // Reset properties of the root object
                        if(IsResetWhenLoading)
                        {
                                ResetObjectProperties(objectToDeserialize);
                        }

                        // Deserialize object
                        DeserializeObject(objectToDeserialize, null, GetObjectName(objectToDeserialize), reader, false);
                }

        /// <summary>
        /// Deserialize object from the binary format.
        /// Method is called recursively to deserialize child objects.
        /// </summary>
        /// <param name="objectToDeserialize">Object to be deserialized.</param>
        /// <param name="parent">Parent of the deserialized object.</param>
        /// <param name="elementName">Object element name.</param>
        /// <param name="reader">Binary reader object.</param>
        /// <param name="skipElement">if set to <c>true</c> the element will not be set.</param>
        /// <returns>Number of properties set.</returns>
                virtual protected int DeserializeObject(object objectToDeserialize, object parent, string elementName, BinaryReader reader, bool skipElement)
                {
                        int     setPropertiesNumber = 0;

                        // Check input parameters
                        if(objectToDeserialize == null)
                        {
                                return setPropertiesNumber;
                        }

                        // Special handling for the collections
                        Type[] assemblyTypes = null;
                        int     listItemIndex = 0;

            IList list = objectToDeserialize as IList;

                        if(list != null)
                        {
                                // Loop through all list items
                                Int16 typeHash = 0;
                PropertyInfo listItemPI = objectToDeserialize.GetType().GetProperty("Item", new Type[] { typeof(int) });
                while ((typeHash = this.ReadHashID(reader)) != 0)
                                {
                                        // Get collection item type from hashed type name
                                        string  typeName = String.Empty;
                                        if(listItemPI != null)
                                        {
                        if ((SerializerBase.GetStringHashCode(listItemPI.PropertyType.Name)) == typeHash)
                        {
                            typeName = listItemPI.PropertyType.Name;
                        }
                        else
                        {
                            Assembly assembly = listItemPI.PropertyType.Assembly;
                            if (assembly != null)
                            {
                                // Find all classes derived from this type
                                if (assemblyTypes == null)
                                {
                                    assemblyTypes = assembly.GetExportedTypes();
                                }
                                foreach (Type type in assemblyTypes)
                                {
                                    if (type.IsSubclassOf(listItemPI.PropertyType))
                                    {
                                        if ((SerializerBase.GetStringHashCode(type.Name)) == typeHash)
                                        {
                                            typeName = type.Name;
                                            break;
                                        }
                                    }
                                }
                            }
                        }
                                        }
                
                                        // Create new item object
                                        string itemName = null;
                                        bool    reusedObject = false;
                                        object listItem = GetListNewItem(list, typeName, ref itemName, ref reusedObject);


                                        // Deserialize list item object
                                        int itemSetProperties = DeserializeObject(listItem, objectToDeserialize, "", reader, skipElement);

                    // Add item object into the list
                    if (!skipElement && (itemSetProperties > 0 || reusedObject))
                    {
                        list.Insert(listItemIndex++, listItem);
                    }
                    // TD: here was removed a code which doesn't work but cause heavy workload: GetListNewItem removes the reusedObject from the list.
                    // Add properties set for collection item
                                        setPropertiesNumber += itemSetProperties;
                                }

                                return setPropertiesNumber;
                        }       

                        // Get list of object's properties
                        PropertyInfo[] properties = objectToDeserialize.GetType().GetProperties();
                        if(properties == null)
                        {
                                return setPropertiesNumber;
                        }
            
                        // Get property information by reading the ID
                        PropertyInfo pi = null;
            while ( (pi = ReadPropertyInfo(objectToDeserialize, parent, properties, reader)) != null)
                        {
                                // Read simple properties
                                if(ShouldSerializeAsAttribute(pi, objectToDeserialize))
                                {
                                        if(SetPropertyValue(objectToDeserialize, pi, reader, skipElement))
                                        {
                                                ++setPropertiesNumber;
                                        }
                                }

                                else
                                {
                                        // Get property descriptor
                                        PropertyDescriptor pd = TypeDescriptor.GetProperties(objectToDeserialize)[pi.Name];
                                        if(pd != null)
                                        {
                                                object innerObject = pd.GetValue(objectToDeserialize);
                                                
                                                // Deserialize inner item object
                        setPropertiesNumber += DeserializeObject(innerObject, objectToDeserialize, pi.Name, reader, !IsSerializableContent(pi.Name, objectToDeserialize));
                                        }
                                        else if(!IsUnknownAttributeIgnored)
                                        {
                                                throw(new InvalidOperationException(SR.ExceptionChartSerializerPropertyNameUnknown( pi.Name,objectToDeserialize.GetType().ToString())));
                                        }
                                }
                        }

                        return setPropertiesNumber;
                }

        /// <summary>
        /// Reads and sets a property of an object.
        /// </summary>
        /// <param name="obj">Object to set.</param>
        /// <param name="pi">Property information.</param>
        /// <param name="reader">Binary reader.</param>
        /// <param name="skipElement">if set to <c>true</c> the property will not be set.</param>
        /// <returns>True if property was set.</returns>
                private bool SetPropertyValue(object obj, PropertyInfo pi, BinaryReader reader, bool skipElement)
                {
                        if(pi != null)
                        {
                                object objValue = null;


                                if(pi.PropertyType == typeof(bool))
                                {
                                        objValue = reader.ReadBoolean();
                                }
                                else if(pi.PropertyType == typeof(double))
                                {
                                        objValue = reader.ReadDouble();
                                }
                                else if(pi.PropertyType == typeof(string))
                                {
                                        objValue = reader.ReadString();
                                }
                                else if(pi.PropertyType == typeof(int))
                                {
                                        objValue = reader.ReadInt32();
                                }
                                else if(pi.PropertyType == typeof(long))
                                {
                                        objValue = reader.ReadInt64();
                                }
                                else if(pi.PropertyType == typeof(float))
                                {
                                        objValue = reader.ReadSingle();
                                }
                                else if(pi.PropertyType.IsEnum)
                                {
                                        // Read as string
                                        objValue = Enum.Parse(pi.PropertyType, reader.ReadString());
                                }
                                else if(pi.PropertyType == typeof(byte))
                                {
                                        objValue = reader.ReadByte();
                                }

#if !Microsoft_CONTROL
                                else if(pi.PropertyType == typeof(Unit))
                                {
                                        objValue = new Unit((double)reader.ReadDouble());
                                }
#endif

                                else if(pi.PropertyType == typeof(Font))
                                {
                                        // Read as string
                                        objValue = SerializerBase.FontFromString(reader.ReadString());
                                }

                                else if(pi.PropertyType == typeof(Color))
                                {
                                        // Read as int
                                        objValue = Color.FromArgb(reader.ReadInt32());
                                }

                                else if(pi.PropertyType == typeof(DateTime))
                                {
                                        // Read as long
                                        objValue = new DateTime(reader.ReadInt64());
                                }

                                else if(pi.PropertyType == typeof(Size))
                                {
                                        // Read as two integers
                                        objValue = new Size(reader.ReadInt32(), reader.ReadInt32());
                                }



                                else if(pi.PropertyType == typeof(Margins) )
                                {
                                        // Read as 4 integers
                                        objValue = new Margins(
                                                reader.ReadInt32(), 
                                                reader.ReadInt32(), 
                                                reader.ReadInt32(), 
                                                reader.ReadInt32());
                                }



                                else if(pi.PropertyType == typeof(double[]))
                                {
                                        // Allocate array
                                        double[] array = new double[reader.ReadInt32()];

                                        // Read each element of the array
                                        for(int arrayIndex = 0; arrayIndex < array.Length; arrayIndex++)
                                        {
                                                array[arrayIndex] = reader.ReadDouble();
                                        }

                                        objValue = array;
                                }

                                else if(pi.PropertyType == typeof(Color[]))
                                {
                                        // Allocate array
                                        Color[] array = new Color[reader.ReadInt32()];

                                        // Read each element of the array
                                        for(int arrayIndex = 0; arrayIndex < array.Length; arrayIndex++)
                                        {
                                                array[arrayIndex] = Color.FromArgb(reader.ReadInt32());
                                        }

                                        objValue = array;
                                }

                                else if(pi.PropertyType == typeof(System.Drawing.Image))
                                {       
                                        // Get image data size
                                        int imageSize = reader.ReadInt32();

                                        // Create image stream
                                        MemoryStream imageStream = new MemoryStream(imageSize + 10);

                                        // Copy image data into separate stream
                                        imageStream.Write(reader.ReadBytes(imageSize), 0, imageSize);

                                        // Create image object
                                        objValue = new Bitmap(System.Drawing.Image.FromStream(imageStream));    // !!! .Net bug when image source stream is closed - can create brush using the image

                                        // Close image stream
                                        imageStream.Close();
                                }                       

                                else
                                {
                                        throw(new InvalidOperationException(SR.ExceptionChartSerializerBinaryTypeUnsupported( obj.GetType().ToString() )));
                                }


                                // Check if this property is serializable content
                if (!skipElement && IsSerializableContent(pi.Name, obj))
                                {
                                        // Set object value
                                        pi.SetValue(obj, objValue, null);

                                        return true;
                                }
                        }
                
                        return false;
                }

                /// <summary>
                /// Reads property ID and return property information
                /// </summary>
                /// <param name="objectToDeserialize">Object to be deserialized.</param>
                /// <param name="parent">Parent of the deserialized object.</param>
                /// <param name="properties">List of properties information.</param>
                /// <param name="reader">Binary reader.</param>
                /// <returns>Property information.</returns>
                private PropertyInfo ReadPropertyInfo(object objectToDeserialize, object parent, PropertyInfo[] properties, BinaryReader reader)
                {
                        // Read property ID
                        short   propertyID = this.ReadHashID(reader);

                        // End objectTag reached
                        if(propertyID == 0)
                        {
                                return null;
                        }

                        // Loop through all properties and check properties IDs (hash code of name)
                        foreach(PropertyInfo pi in properties)
                        {
                                // Skip inherited properties from the root object
                                if(IsChartBaseProperty(objectToDeserialize, parent, pi))
                                {
                                        continue;
                                }

                                // Check collection
                if (pi.CanRead && pi.PropertyType.GetInterface("ICollection", true) != null)
                                {
                                        if((SerializerBase.GetStringHashCode(pi.Name)) == propertyID)
                                        {
                                                return pi;
                                        }
                                }

                                // Check public properties with Get and Set methods
                                else if(pi.CanRead && pi.CanWrite)
                                {
                                        // Skip indexes
                                        if(pi.Name == "Item")
                                        {
                                                continue;
                                        }

                                        if((SerializerBase.GetStringHashCode(pi.Name)) == propertyID)
                                        {
                                                return pi;
                                        }
                                }
                        }

                        // Property was not found
            throw (new InvalidOperationException(SR.ExceptionChartSerializerPropertyNotFound));
                }

                #endregion
        }
}