ActivityDesignerLayoutSerializers.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / cdf / src / WF / Common / AuthoringOM / Design / ActivityDesignerLayoutSerializers.cs / 1305376 / ActivityDesignerLayoutSerializers.cs
                        

                        
                            using System; 
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.ComponentModel; 
using System.ComponentModel.Design;
using System.ComponentModel.Design.Serialization; 
using System.Reflection; 
using System.Xml;
using System.Workflow.ComponentModel.Serialization; 
using System.Drawing;

namespace System.Workflow.ComponentModel.Design
{ 
    #region Class ActivityDesignerLayoutSerializer
    public class ActivityDesignerLayoutSerializer : WorkflowMarkupSerializer 
    { 
        protected override void OnBeforeSerialize(WorkflowMarkupSerializationManager serializationManager, object obj)
        { 
            base.OnBeforeSerialize(serializationManager, obj);

            //For root activity we will go through all the nested activities and put the namespaces at the top level
            ActivityDesigner activityDesigner = obj as ActivityDesigner; 
            XmlWriter writer = serializationManager.WorkflowMarkupStack[typeof(XmlWriter)] as XmlWriter;
            if (activityDesigner.Activity != null && activityDesigner.Activity.Parent == null && writer != null) 
            { 
                string prefix = String.Empty;
                XmlQualifiedName xmlQualifiedName = serializationManager.GetXmlQualifiedName(typeof(Point), out prefix); 
                writer.WriteAttributeString("xmlns", prefix, null, xmlQualifiedName.Namespace);
            }
        }
 
        protected override object CreateInstance(WorkflowMarkupSerializationManager serializationManager, Type type)
        { 
            if (serializationManager == null) 
                throw new ArgumentNullException("serializationManager");
            if (type == null) 
                throw new ArgumentNullException("type");

            object designer = null;
 
            IDesignerHost host = serializationManager.GetService(typeof(IDesignerHost)) as IDesignerHost;
            XmlReader reader = serializationManager.WorkflowMarkupStack[typeof(XmlReader)] as XmlReader; 
            if (host != null && reader != null) 
            {
                //Find the associated activity 
                string associatedActivityName = String.Empty;
                while (reader.MoveToNextAttribute() && !reader.LocalName.Equals("Name", StringComparison.Ordinal)) ;
                if (reader.LocalName.Equals("Name", StringComparison.Ordinal) && reader.ReadAttributeValue())
                    associatedActivityName = reader.Value; 
                reader.MoveToElement();
 
                if (!String.IsNullOrEmpty(associatedActivityName)) 
                {
                    CompositeActivityDesigner parentDesigner = serializationManager.Context[typeof(CompositeActivityDesigner)] as CompositeActivityDesigner; 
                    if (parentDesigner == null)
                    {
                        Activity activity = host.RootComponent as Activity;
                        if (activity != null && !associatedActivityName.Equals(activity.Name, StringComparison.Ordinal)) 
                        {
                            foreach (IComponent component in host.Container.Components) 
                            { 
                                activity = component as Activity;
                                if (activity != null && associatedActivityName.Equals(activity.Name, StringComparison.Ordinal)) 
                                    break;
                            }
                        }
 
                        if (activity != null)
                            designer = host.GetDesigner(activity); 
                    } 
                    else
                    { 
                        CompositeActivity compositeActivity = parentDesigner.Activity as CompositeActivity;
                        if (compositeActivity != null)
                        {
                            Activity matchingActivity = null; 
                            foreach (Activity activity in compositeActivity.Activities)
                            { 
                                if (associatedActivityName.Equals(activity.Name, StringComparison.Ordinal)) 
                                {
                                    matchingActivity = activity; 
                                    break;
                                }
                            }
 
                            if (matchingActivity != null)
                                designer = host.GetDesigner(matchingActivity); 
                        } 
                    }
 
                    if (designer == null)
                        serializationManager.ReportError(SR.GetString(SR.Error_LayoutSerializationActivityNotFound, reader.LocalName, associatedActivityName, "Name"));
                }
                else 
                {
                    serializationManager.ReportError(SR.GetString(SR.Error_LayoutSerializationAssociatedActivityNotFound, reader.LocalName, "Name")); 
                } 
            }
 
            return designer;
        }

        protected internal override PropertyInfo[] GetProperties(WorkflowMarkupSerializationManager serializationManager, object obj) 
        {
            if (serializationManager == null) 
                throw new ArgumentNullException("serializationManager"); 
            if (obj == null)
                throw new ArgumentNullException("obj"); 

            List properties = new List(base.GetProperties(serializationManager, obj));

            ActivityDesigner activityDesigner = obj as ActivityDesigner; 
            if (activityDesigner != null)
            { 
                PropertyInfo nameProperty = activityDesigner.GetType().GetProperty("Name", BindingFlags.Instance | BindingFlags.NonPublic); 
                if (nameProperty != null)
                    properties.Insert(0, nameProperty); 
            }

            return properties.ToArray();
        } 
    }
    #endregion 
 
    #region Class CompositeActivityDesignerLayoutSerializer
    public class CompositeActivityDesignerLayoutSerializer : ActivityDesignerLayoutSerializer 
    {
        protected internal override PropertyInfo[] GetProperties(WorkflowMarkupSerializationManager serializationManager, object obj)
        {
            List properties = new List(base.GetProperties(serializationManager, obj)); 
            properties.Add(typeof(CompositeActivityDesigner).GetProperty("Designers", BindingFlags.Instance | BindingFlags.NonPublic));
            return properties.ToArray(); 
        } 
    }
    #endregion 

    #region Class FreeformActivityDesignerLayoutSerializer
    public class FreeformActivityDesignerLayoutSerializer : CompositeActivityDesignerLayoutSerializer
    { 
        protected internal override PropertyInfo[] GetProperties(WorkflowMarkupSerializationManager serializationManager, object obj)
        { 
            if (serializationManager == null) 
                throw new ArgumentNullException("serializationManager");
            if (obj == null) 
                throw new ArgumentNullException("obj");

            XmlWriter writer = serializationManager.WorkflowMarkupStack[typeof(XmlWriter)] as XmlWriter;
            PropertyInfo[] properties = base.GetProperties(serializationManager, obj); 
            FreeformActivityDesigner freeformDesigner = obj as FreeformActivityDesigner;
            if (freeformDesigner != null) 
            { 
                List serializableProperties = new List();
                foreach (PropertyInfo property in properties) 
                {
                    //Only filter this property out when we are writting
                    if (writer != null &&
                        property.Name.Equals("AutoSizeMargin", StringComparison.Ordinal) && 
                        freeformDesigner.AutoSizeMargin == FreeformActivityDesigner.DefaultAutoSizeMargin)
                    { 
                        continue; 
                    }
 
                    serializableProperties.Add(property);
                }

                serializableProperties.Add(typeof(FreeformActivityDesigner).GetProperty("DesignerConnectors", BindingFlags.Instance | BindingFlags.NonPublic)); 
                properties = serializableProperties.ToArray();
            } 
 
            return properties;
        } 
    }
    #endregion

    #region ConnectorLayoutSerializer 
    public class ConnectorLayoutSerializer : WorkflowMarkupSerializer
    { 
        protected internal override PropertyInfo[] GetProperties(WorkflowMarkupSerializationManager serializationManager, object obj) 
        {
            if (serializationManager == null) 
                throw new ArgumentNullException("serializationManager");
            if (obj == null)
                throw new ArgumentNullException("obj");
 
            List properties = new List(base.GetProperties(serializationManager, obj));
            properties.Add(typeof(Connector).GetProperty("SourceActivity", BindingFlags.Instance | BindingFlags.NonPublic)); 
            properties.Add(typeof(Connector).GetProperty("SourceConnectionIndex", BindingFlags.Instance | BindingFlags.NonPublic)); 
            properties.Add(typeof(Connector).GetProperty("SourceConnectionEdge", BindingFlags.Instance | BindingFlags.NonPublic));
            properties.Add(typeof(Connector).GetProperty("TargetActivity", BindingFlags.Instance | BindingFlags.NonPublic)); 
            properties.Add(typeof(Connector).GetProperty("TargetConnectionIndex", BindingFlags.Instance | BindingFlags.NonPublic));
            properties.Add(typeof(Connector).GetProperty("TargetConnectionEdge", BindingFlags.Instance | BindingFlags.NonPublic));
            properties.Add(typeof(Connector).GetProperty("Segments", BindingFlags.Instance | BindingFlags.NonPublic));
            return properties.ToArray(); 
        }
 
        protected override object CreateInstance(WorkflowMarkupSerializationManager serializationManager, Type type) 
        {
            if (serializationManager == null) 
                throw new ArgumentNullException("serializationManager");
            if (type == null)
                throw new ArgumentNullException("type");
 
            Connector connector = null;
 
            IReferenceService referenceService = serializationManager.GetService(typeof(IReferenceService)) as IReferenceService; 
            FreeformActivityDesigner freeformDesigner = serializationManager.Context[typeof(FreeformActivityDesigner)] as FreeformActivityDesigner;
            if (freeformDesigner != null && referenceService != null) 
            {
                ConnectionPoint sourceConnection = null;
                ConnectionPoint targetConnection = null;
 
                try
                { 
                    Dictionary constructionArguments = GetConnectorConstructionArguments(serializationManager, type); 

                    if (constructionArguments.ContainsKey("SourceActivity") && 
                        constructionArguments.ContainsKey("SourceConnectionIndex") &&
                        constructionArguments.ContainsKey("SourceConnectionEdge"))
                    {
                        ActivityDesigner sourceDesigner = ActivityDesigner.GetDesigner(referenceService.GetReference(constructionArguments["SourceActivity"] as string) as Activity); 
                        DesignerEdges sourceEdge = (DesignerEdges)Enum.Parse(typeof(DesignerEdges), constructionArguments["SourceConnectionEdge"] as string);
                        int sourceIndex = Convert.ToInt32(constructionArguments["SourceConnectionIndex"] as string, System.Globalization.CultureInfo.InvariantCulture); 
                        if (sourceDesigner != null && sourceEdge != DesignerEdges.None && sourceIndex >= 0) 
                            sourceConnection = new ConnectionPoint(sourceDesigner, sourceEdge, sourceIndex);
                    } 

                    if (constructionArguments.ContainsKey("TargetActivity") &&
                        constructionArguments.ContainsKey("TargetConnectionIndex") &&
                        constructionArguments.ContainsKey("TargetConnectionEdge")) 
                    {
                        ActivityDesigner targetDesigner = ActivityDesigner.GetDesigner(referenceService.GetReference(constructionArguments["TargetActivity"] as string) as Activity); 
                        DesignerEdges targetEdge = (DesignerEdges)Enum.Parse(typeof(DesignerEdges), constructionArguments["TargetConnectionEdge"] as string); 
                        int targetIndex = Convert.ToInt32(constructionArguments["TargetConnectionIndex"] as string, System.Globalization.CultureInfo.InvariantCulture);
                        if (targetDesigner != null && targetEdge != DesignerEdges.None && targetIndex >= 0) 
                            targetConnection = new ConnectionPoint(targetDesigner, targetEdge, targetIndex);
                    }
                }
                catch 
                {
                } 
 
                if (sourceConnection != null && targetConnection != null)
                    connector = freeformDesigner.AddConnector(sourceConnection, targetConnection); 
            }

            return connector;
        } 

        protected override void OnAfterDeserialize(WorkflowMarkupSerializationManager serializationManager, object obj) 
        { 
            base.OnAfterDeserialize(serializationManager, obj);
 
            //The following code is needed in order to making sure that we set the modification flag correctly after deserialization
            Connector connector = obj as Connector;
            if (connector != null)
                connector.SetConnectorModified(true); 
        }
 
        protected Dictionary GetConnectorConstructionArguments(WorkflowMarkupSerializationManager serializationManager, Type type) 
        {
            Dictionary argumentDictionary = new Dictionary(); 

            XmlReader reader = serializationManager.WorkflowMarkupStack[typeof(XmlReader)] as XmlReader;
            if (reader != null && reader.NodeType == XmlNodeType.Element)
            { 
                while (reader.MoveToNextAttribute())
                { 
                    string attributeName = reader.LocalName; 
                    if (!argumentDictionary.ContainsKey(attributeName))
                    { 
                        reader.ReadAttributeValue();
                        argumentDictionary.Add(attributeName, reader.Value);
                    }
                } 
                reader.MoveToElement();
            } 
 
            return argumentDictionary;
        } 
    }
    #endregion

    #region Class ActivityDesignerLayoutSerializerProvider 
    internal sealed class ActivityDesignerLayoutSerializerProvider : IDesignerSerializationProvider
    { 
        #region IDesignerSerializationProvider Members 
        object IDesignerSerializationProvider.GetSerializer(IDesignerSerializationManager manager, object currentSerializer, Type objectType, Type serializerType)
        { 
            if (typeof(System.Drawing.Color) == objectType)
                currentSerializer = new ColorMarkupSerializer();
            else if (typeof(System.Drawing.Size) == objectType)
                currentSerializer = new SizeMarkupSerializer(); 
            else if (typeof(System.Drawing.Point) == objectType)
                currentSerializer = new PointMarkupSerializer(); 
            return currentSerializer; 
        }
        #endregion 
    }
    #endregion

    #region Class ColorMarkupSerializer 
    internal sealed class ColorMarkupSerializer : WorkflowMarkupSerializer
    { 
        protected internal override bool CanSerializeToString(WorkflowMarkupSerializationManager serializationManager, object value) 
        {
            return (value is System.Drawing.Color); 
        }

        protected internal override string SerializeToString(WorkflowMarkupSerializationManager serializationManager, object value)
        { 
            if (serializationManager == null)
                throw new ArgumentNullException("serializationManager"); 
            if (value == null) 
                throw new ArgumentNullException("value");
 
            string stringValue = String.Empty;
            if (value is System.Drawing.Color)
            {
                System.Drawing.Color color = (System.Drawing.Color)value; 
                long colorValue = (long)((uint)(color.A << 24 | color.R << 16 | color.G << 8 | color.B)) & 0xFFFFFFFF;
                stringValue = "0X" + colorValue.ToString("X08", System.Globalization.CultureInfo.InvariantCulture); 
            } 
            return stringValue;
        } 

        protected internal override object DeserializeFromString(WorkflowMarkupSerializationManager serializationManager, Type propertyType, string value)
        {
            if (propertyType.IsAssignableFrom(typeof(System.Drawing.Color))) 
            {
                string colorValue = value as string; 
                if (!String.IsNullOrEmpty(colorValue)) 
                {
                    if (colorValue.StartsWith("0X", StringComparison.OrdinalIgnoreCase)) 
                    {
                        long propertyValue = Convert.ToInt64((string)value, 16) & 0xFFFFFFFF;
                        return System.Drawing.Color.FromArgb((Byte)(propertyValue >> 24), (Byte)(propertyValue >> 16), (Byte)(propertyValue >> 8), (Byte)(propertyValue));
                    } 
                    else
                    { 
                        return base.DeserializeFromString(serializationManager, propertyType, value); 
                    }
                } 
            }

            return null;
        } 
    }
    #endregion 
 
    #region Class SizeMarkupSerializer
    internal sealed class SizeMarkupSerializer : WorkflowMarkupSerializer 
    {
        protected internal override bool CanSerializeToString(WorkflowMarkupSerializationManager serializationManager, object value)
        {
            return (value is System.Drawing.Size); 
        }
 
        protected internal override PropertyInfo[] GetProperties(WorkflowMarkupSerializationManager serializationManager, object obj) 
        {
            List properties = new List(); 
            if (obj is Size)
            {
                properties.Add(typeof(Size).GetProperty("Width"));
                properties.Add(typeof(Size).GetProperty("Height")); 
            }
            return properties.ToArray(); 
        } 

        protected internal override string SerializeToString(WorkflowMarkupSerializationManager serializationManager, object value) 
        {
            string convertedValue = String.Empty;

            TypeConverter converter = TypeDescriptor.GetConverter(value); 
            if (converter != null && converter.CanConvertTo(typeof(string)))
                convertedValue = converter.ConvertTo(value, typeof(string)) as string; 
            else 
                convertedValue = base.SerializeToString(serializationManager, value);
            return convertedValue; 
        }

        protected internal override object DeserializeFromString(WorkflowMarkupSerializationManager serializationManager, Type propertyType, string value)
        { 
            object size = Size.Empty;
 
            string sizeValue = value as string; 
            if (!String.IsNullOrEmpty(sizeValue))
            { 
                TypeConverter converter = TypeDescriptor.GetConverter(typeof(Size));
                if (converter != null && converter.CanConvertFrom(typeof(string)) && !IsValidCompactAttributeFormat(sizeValue))
                    size = converter.ConvertFrom(value);
                else 
                    size = base.SerializeToString(serializationManager, value);
            } 
 
            return size;
        } 
    }
    #endregion

    #region Class PointMarkupSerializer 
    internal sealed class PointMarkupSerializer : WorkflowMarkupSerializer
    { 
        protected internal override bool CanSerializeToString(WorkflowMarkupSerializationManager serializationManager, object value) 
        {
            return (value is Point); 
        }

        protected internal override PropertyInfo[] GetProperties(WorkflowMarkupSerializationManager serializationManager, object obj)
        { 
            List properties = new List();
            if (obj is Point) 
            { 
                properties.Add(typeof(Point).GetProperty("X"));
                properties.Add(typeof(Point).GetProperty("Y")); 
            }
            return properties.ToArray();
        }
 
        protected internal override string SerializeToString(WorkflowMarkupSerializationManager serializationManager, object value)
        { 
            string convertedValue = String.Empty; 

            TypeConverter converter = TypeDescriptor.GetConverter(value); 
            if (converter != null && converter.CanConvertTo(typeof(string)))
                convertedValue = converter.ConvertTo(value, typeof(string)) as string;
            else
                convertedValue = base.SerializeToString(serializationManager, value); 
            return convertedValue;
        } 
 
        protected internal override object DeserializeFromString(WorkflowMarkupSerializationManager serializationManager, Type propertyType, string value)
        { 
            object point = Point.Empty;

            string pointValue = value as string;
            if (!String.IsNullOrEmpty(pointValue)) 
            {
                TypeConverter converter = TypeDescriptor.GetConverter(typeof(Point)); 
                if (converter != null && converter.CanConvertFrom(typeof(string)) && !IsValidCompactAttributeFormat(pointValue)) 
                    point = converter.ConvertFrom(value);
                else 
                    point = base.SerializeToString(serializationManager, value);
            }

            return point; 
        }
    } 
    #endregion 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK