loader.cs

workflow foundaction 工作流设计器

            string rulesFile = Path.Combine(Path.GetDirectoryName(this.xoml), Path.GetFileNameWithoutExtension(this.xoml) + ".rules");
            if (File.Exists(rulesFile))
            {
                StreamReader rulesReader = new StreamReader(rulesFile);
                this.tempRulesStream = new StringBuilder(rulesReader.ReadToEnd());
                rulesReader.Close();
            }

        }

        public override void Flush()
        {
            PerformFlush(null);
        }

        /// <summary>
        /// Save the Xaml file and flush the code compile unit into a .CS file
        /// </summary>
        /// <param name="manager"></param>
        protected override void PerformFlush(IDesignerSerializationManager manager)
        {
            IDesignerHost host = (IDesignerHost)GetService(typeof(IDesignerHost));
            Activity rootActivity = host.RootComponent as Activity;
            if (host != null && host.RootComponent != null)
            {

                if (rootActivity != null)
                {
                    XmlTextWriter xmlWriter = new XmlTextWriter(this.xoml, Encoding.Default);
                    try
                    {
                        WorkflowMarkupSerializer xomlSerializer = new WorkflowMarkupSerializer();
                        xomlSerializer.Serialize(xmlWriter, rootActivity);
                    }
                    finally
                    {
                        xmlWriter.Close();
                    }
                }
            }

            string codeBesideFile = Path.Combine(Path.GetDirectoryName(this.xoml), Path.GetFileNameWithoutExtension(this.xoml) + ".cs");
            
            // Flush CS code
            CSharpCodeProvider provider = new CSharpCodeProvider();
            ICodeGenerator generator = provider.CreateGenerator();

            // Just chooses some formatting options, like four space indenting
            CodeGeneratorOptions options = new CodeGeneratorOptions();
            options.BlankLinesBetweenMembers = true;
            options.BracingStyle = "C";
            options.ElseOnClosing = false;
            options.IndentString = "    ";

            StreamWriter writer = new StreamWriter(codeBesideFile);
            generator.GenerateCodeFromCompileUnit(this.CodeBesideCCU, writer, options);
            writer.Close();

            // Flush the rules file
            if (this.tempRulesStream != null)
            {
                string rulesFile = Path.Combine(Path.GetDirectoryName(this.xoml), Path.GetFileNameWithoutExtension(this.xoml) + ".rules");
                using (StreamWriter rulesWriter = new StreamWriter(rulesFile))
                {
                    rulesWriter.Write(this.tempRulesStream.ToString());
                }
            }

            #region State Machine Workflow specific code
            // Need to save the layout in case of State Machine Workflow

            //string layoutFile = Path.Combine(Path.GetDirectoryName(this.xoml), Path.GetFileNameWithoutExtension(this.xoml) + ".layout");
            //ActivityDesigner rootdesigner = host.GetDesigner(rootActivity) as ActivityDesigner;
            //XmlWriter layoutwriter = XmlWriter.Create(layoutFile);
            //IList errors = null;
            //SaveDesignerLayout(layoutwriter, rootdesigner, out errors);
            //layoutwriter.Close();

            #endregion
        }

        #endregion

        #region Public properties
        public string DefaultNamespace
        {
            get
            {
                return "foo";
            }
        }

        public CodeCompileUnit CodeBesideCCU
        {
            get { return codeBesideccu; }
            set { codeBesideccu = value; }
        }

        public CodeCompileUnit XamlCodeCompileUnit
        {
            get { return xamlccu; }
            set { xamlccu = value; }
        }

        public string Xoml
        {
            get
            {
                return this.xoml;
            }

            set
            {
                this.xoml = value;
            }
        }

        #endregion

        #region Private helpers
        private static void AddObjectGraphToDesignerHost(IDesignerHost designerHost, Activity activity)
        {
            Guid Definitions_Class = new Guid("3FA84B23-B15B-4161-8EB8-37A54EFEEFC7");

            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<Activity> 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);
            }
        }

        #endregion

    }
    #endregion
}