www.pudn.com > wxwinter2.rar > wxdWFLoader.cs

using System; 
using System.IO; 
using System.ComponentModel; 
using System.ComponentModel.Design; 
using System.ComponentModel.Design.Serialization; 
using System.Workflow.ComponentModel; 
using System.Workflow.ComponentModel.Compiler; 
using System.Workflow.ComponentModel.Design; 
using System.Workflow.ComponentModel.Serialization; 
using System.Collections; 
using System.Collections.Generic; 
using System.Drawing.Design; 
using System.Xml; 
 
 
namespace wxwinter.wf.Design 
{ 
    //工作流加载器 
    public sealed class wxdWFLoader : WorkflowDesignerLoader 
    { 
        private string xoml = string.Empty; 
 
        string activityToolItemFile; 
        internal wxdWFLoader(string activityToolItemFile) 
        { 
            this.activityToolItemFile = activityToolItemFile; 
 
        } 
 
        protected override void Initialize() 
        { 
            base.Initialize(); 
            //提供一个接口，该接口可扩展设计器宿主以支持从序列化状态加载 
            IDesignerLoaderHost host; 
 
            //获取加载程序宿主 
            host = this.LoaderHost; 
 
            if (host != null) 
            { 
                //加载菜单服务 
                host.AddService(typeof(IMenuCommandService), new wxdWFMenu(host)); 
 
                //加载工具栏服务 
                host.AddService(typeof(IToolboxService), new wxdActivityTool(host, activityToolItemFile)); 
 
                TypeProvider typeProvider = new TypeProvider(host); 
                typeProvider.AddAssemblyReference(typeof(string).Assembly.Location); 
                host.AddService(typeof(ITypeProvider), typeProvider, true); 
            } 
        } 
 
        public override void Dispose() 
        { 
            IDesignerLoaderHost host = LoaderHost; 
            if (host != null) 
            { 
                host.RemoveService(typeof(IMenuCommandService)); 
                host.RemoveService(typeof(IToolboxService)); 
                host.RemoveService(typeof(ITypeProvider), true); 
            } 
 
            base.Dispose(); 
        } 
 
        public override void ForceReload() 
        { 
        } 
 
        public string DefaultNamespace 
        { 
            get 
            { 
                return "SampleNamespace"; 
            } 
        } 
 
        public string Xoml 
        { 
            get 
            { 
                return this.xoml; 
            } 
 
            set 
            { 
                this.xoml = value; 
            } 
        } 
 
        private Type workflowType = null; 
 
        public Type WorkflowType 
        { 
            get { return workflowType; } 
            set { workflowType = value; } 
        } 
 
        private string xomlFile = string.Empty; 
 
        public string XomlFile 
        { 
            get 
            { 
                return this.xomlFile; 
            } 
            set 
            { 
                this.xomlFile = value; 
            } 
        } 
 
        public override string FileName 
        { 
            get { return string.Empty; } 
        } 
 
        public override TextReader GetFileReader(string filePath) 
        { 
            return new StreamReader(new FileStream(filePath, FileMode.OpenOrCreate)); 
        } 
 
        public override TextWriter GetFileWriter(string filePath) 
        { 
            // clsoe the handle 
            return new StreamWriter(new FileStream(filePath, FileMode.OpenOrCreate)); 
        } 
 
        protected override void PerformLoad(IDesignerSerializationManager serializationManager) 
        { 
            IDesignerHost designerHost = (IDesignerHost)GetService(typeof(IDesignerHost)); 
            Activity rootActivity = null; 
            //First see if we have a workflow type 
            if (WorkflowType != null) 
            { 
                rootActivity = (Activity)Activator.CreateInstance(WorkflowType); 
            } 
            else 
            { 
                // Create a text reader out of the doc data, and ask 
                TextReader reader = new StringReader(this.xoml); 
                try 
                { 
                    using (XmlReader xmlReader = XmlReader.Create(reader)) 
                    { 
                        WorkflowMarkupSerializer xomlSerializer = new WorkflowMarkupSerializer(); 
                        rootActivity = xomlSerializer.Deserialize(xmlReader) as Activity; 
                    } 
                } 
                finally 
                { 
                    reader.Close(); 
                } 
            } 
 
            if (rootActivity != null && designerHost != null) 
            { 
                AddObjectGraphToDesignerHost(designerHost, rootActivity); 
            } 
        } 
 
        protected override void PerformFlush(IDesignerSerializationManager manager) 
        { 
        } 
 
        public void PerformFlush() 
        { 
            IDesignerHost host = (IDesignerHost)GetService(typeof(IDesignerHost)); 
 
            if (host != null && host.RootComponent != null) 
            { 
                Activity service = host.RootComponent as Activity; 
 
                if (service != null) 
                { 
                    using (XmlWriter writer = XmlWriter.Create(this.xomlFile)) 
                    { 
                        WorkflowMarkupSerializer xomlSerializer = new WorkflowMarkupSerializer(); 
                        xomlSerializer.Serialize(writer, service); 
                    } 
                } 
            } 
        } 
 
        private static void AddObjectGraphToDesignerHost(IDesignerHost designerHost, Activity activity) 
        { 
 
            Guid Definitions_Class = new Guid("11111111-2222-3333-4444-555555555555"); 
 
            if (designerHost == null) 
                throw new ArgumentNullException("designerHost"); 
            if (activity == null) 
                throw new ArgumentNullException("activity"); 
 
            string rootSiteName = activity.QualifiedName; 
            if (activity.Parent == null) 
            { 
                string fullClassName = activity.UserData[Definitions_Class] as string; 
                if (fullClassName == null) 
                    fullClassName = activity.GetType().FullName; 
                rootSiteName = (fullClassName.LastIndexOf('.') != -1) ? fullClassName.Substring(fullClassName.LastIndexOf('.') + 1) : fullClassName; 
                designerHost.Container.Add(activity, rootSiteName); 
            } 
            else 
            { 
                designerHost.Container.Add(activity, activity.QualifiedName); 
            } 
 
            if (activity is CompositeActivity) 
            { 
                foreach (Activity activity2 in GetNestedActivities(activity as CompositeActivity)) 
                    designerHost.Container.Add(activity2, activity2.QualifiedName); 
            } 
        } 
 
        private static Activity[] GetNestedActivities(CompositeActivity compositeActivity) 
        { 
            if (compositeActivity == null) 
                throw new ArgumentNullException("compositeActivity"); 
 
            IList childActivities = null; 
            ArrayList nestedActivities = new ArrayList(); 
            Queue compositeActivities = new Queue(); 
            compositeActivities.Enqueue(compositeActivity); 
            while (compositeActivities.Count > 0) 
            { 
                CompositeActivity compositeActivity2 = (CompositeActivity)compositeActivities.Dequeue(); 
                childActivities = compositeActivity2.Activities; 
 
                foreach (Activity activity in childActivities) 
                { 
                    nestedActivities.Add(activity); 
                    if (activity is CompositeActivity) 
                        compositeActivities.Enqueue(activity); 
                } 
            } 
            return (Activity[])nestedActivities.ToArray(typeof(Activity)); 
        } 
 
        internal static void DestroyObjectGraphFromDesignerHost(IDesignerHost designerHost, Activity activity) 
        { 
            if (designerHost == null) 
                throw new ArgumentNullException("designerHost"); 
            if (activity == null) 
                throw new ArgumentNullException("activity"); 
 
            designerHost.DestroyComponent(activity); 
 
            if (activity is CompositeActivity) 
            { 
                foreach (Activity activity2 in GetNestedActivities(activity as CompositeActivity)) 
                    designerHost.DestroyComponent(activity2); 
            } 
        } 
    } 
}