XomlDesignerLoader.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 / XomlDesignerLoader.cs / 1551714 / XomlDesignerLoader.cs

                            namespace System.Workflow.ComponentModel.Design 
{
    using System;
    using System.Collections;
    using System.Collections.Generic; 
    using System.ComponentModel;
    using System.ComponentModel.Design; 
 	using System.Workflow.ComponentModel.Serialization; 
	using System.ComponentModel.Design.Serialization;
	using System.IO; 
    using System.Windows.Forms;
    using System.Drawing.Design;
    using System.Security.Permissions;
    using System.Xml; 
    using System.Workflow.ComponentModel.Compiler;
    using System.Collections.ObjectModel; 
 
    #region Class WorkflowDesignerLoader
    [PermissionSet(SecurityAction.InheritanceDemand, Name = "FullTrust")] 
    [PermissionSet(SecurityAction.LinkDemand, Name = "FullTrust")]
    public abstract class WorkflowDesignerLoader : BasicDesignerLoader
    {
        #region Members, Construction and Dispose 
        internal const string DesignerLayoutFileExtension = ".layout";
 
        private CustomActivityDesignerAdapter customActivityDesignerAdapter; 
        private WorkflowDesignerEventsCoordinator eventsCoordinator;
        private Hashtable createdServices = null; 
        private bool loadingDesignerLayout = false;

        static WorkflowDesignerLoader()
        { 
            ComponentDispenser.RegisterComponentExtenders(typeof(CustomActivityDesignerAdapter), new IExtenderProvider[] { new CustomActivityPropertyExtender() });
        } 
 
        protected override void Initialize()
        { 
            base.Initialize();

            //PLEASE NOTE THE FOLLOWING CODE IS ADDED TO MAKE THE SPECIFIC DESIGNER TYPE INTERNAL
            //This is a work around for invoke workflow so that the ActivityHostDesignerType does not become public 
            //Please refer to file WorkflowInlining.cs
            Type invokeWorkflowType = Type.GetType(InvokeWorkflowDesigner.InvokeWorkflowRef); 
            if (invokeWorkflowType != null) 
                TypeDescriptor.AddAttributes(invokeWorkflowType, new DesignerAttribute(typeof(InvokeWorkflowDesigner), typeof(IDesigner)));
 
            //Add all the services, it is important to make sure that if user pushes the services then we honor
            //those services
            LoaderHost.AddService(typeof(WorkflowDesignerLoader), this);
 
            ServiceCreatorCallback callback = new ServiceCreatorCallback(OnCreateService);
            if (LoaderHost.GetService(typeof(IWorkflowCompilerOptionsService)) == null) 
                LoaderHost.AddService(typeof(IWorkflowCompilerOptionsService), callback); 

            if (LoaderHost.GetService(typeof(IIdentifierCreationService)) == null) 
                LoaderHost.AddService(typeof(IIdentifierCreationService), callback);

            if (LoaderHost.GetService(typeof(ComponentSerializationService)) == null)
                LoaderHost.AddService(typeof(ComponentSerializationService), callback); 

            LoaderHost.RemoveService(typeof(IReferenceService)); 
            if (LoaderHost.GetService(typeof(IReferenceService)) == null) 
                LoaderHost.AddService(typeof(IReferenceService), callback);
 
            if (LoaderHost.GetService(typeof(IDesignerVerbProviderService)) == null)
                LoaderHost.AddService(typeof(IDesignerVerbProviderService), callback);

            //Add all the extenders, the extenders are responsible to add the extended properties which are not 
            //actual properties on activity
            IExtenderProviderService extenderProviderService = GetService(typeof(IExtenderProviderService)) as IExtenderProviderService; 
            if (extenderProviderService != null) 
            {
                foreach (IExtenderProvider extender in ComponentDispenser.Extenders) 
                    extenderProviderService.AddExtenderProvider(extender);
            }

            this.customActivityDesignerAdapter = new CustomActivityDesignerAdapter(LoaderHost); 
        }
 
        public override void Dispose() 
        {
            if (this.eventsCoordinator != null) 
            {
                ((IDisposable)this.eventsCoordinator).Dispose();
                this.eventsCoordinator = null;
            } 

            if (this.customActivityDesignerAdapter != null) 
            { 
                ((IDisposable)this.customActivityDesignerAdapter).Dispose();
                this.customActivityDesignerAdapter = null; 
            }

            IExtenderProviderService extenderProviderService = GetService(typeof(IExtenderProviderService)) as IExtenderProviderService;
            if (extenderProviderService != null) 
            {
                foreach (IExtenderProvider extender in ComponentDispenser.Extenders) 
                    extenderProviderService.RemoveExtenderProvider(extender); 
            }
 
            if (LoaderHost != null)
            {
                if (this.createdServices != null)
                { 
                    foreach (Type serviceType in this.createdServices.Keys)
                    { 
                        LoaderHost.RemoveService(serviceType); 
                        OnDisposeService(serviceType, this.createdServices[serviceType]);
                    } 
                    this.createdServices.Clear();
                    this.createdServices = null;
                }
                LoaderHost.RemoveService(typeof(WorkflowDesignerLoader)); 
            }
 
            base.Dispose(); 
        }
        #endregion 

        #region Public Methods and Properties
        public abstract TextReader GetFileReader(string filePath);
 
        public abstract TextWriter GetFileWriter(string filePath);
 
        public abstract string FileName { get;} 

        public virtual void ForceReload() 
        {
            Reload(ReloadOptions.Force);
        }
 
        public override void Flush()
        { 
            base.Flush(); 
        }
 
        public virtual bool InDebugMode
        {
            get
            { 
                return false;
            } 
        } 

        protected virtual TypeDescriptionProvider TargetFrameworkTypeDescriptionProvider 
        {
            get
            {
                return null; 
            }
        } 
 
        void AddTargetFrameworkProvider(IComponent component)
        { 
            TypeDescriptionProviderService typeDescriptionProviderService = GetService(typeof(TypeDescriptionProviderService)) as TypeDescriptionProviderService;
            if (typeDescriptionProviderService != null && component != null)
            {
                TypeDescriptor.AddProvider(typeDescriptionProviderService.GetProvider(component), component); 
            }
        } 
 
        public void AddActivityToDesigner(Activity activity)
        { 
            if (activity == null)
                throw new ArgumentNullException("activity");

            IDesignerHost designerHost = GetService(typeof(IDesignerHost)) as IDesignerHost; 
            if (designerHost == null)
                throw new InvalidOperationException(SR.GetString(SR.General_MissingService, typeof(IDesignerHost).FullName)); 
 
            if (activity.Parent == null && designerHost.RootComponent == null)
            { 
		        string fullClassName = activity.GetValue(WorkflowMarkupSerializer.XClassProperty) as String;
                string rootSiteName = (!string.IsNullOrEmpty(fullClassName)) ? Helpers.GetClassName(fullClassName) : Helpers.GetClassName(activity.GetType().FullName);
                designerHost.Container.Add(activity, rootSiteName);
                AddTargetFrameworkProvider(activity); 
            }
            else 
            { 
                designerHost.Container.Add(activity, activity.QualifiedName);
                AddTargetFrameworkProvider(activity); 
            }

            if (activity is CompositeActivity)
            { 
                foreach (Activity activity2 in Helpers.GetNestedActivities(activity as CompositeActivity))
                { 
                    designerHost.Container.Add(activity2, activity2.QualifiedName); 
                    AddTargetFrameworkProvider(activity2);
                } 
            }
        }

        public void RemoveActivityFromDesigner(Activity activity) 
        {
            if (activity == null) 
                throw new ArgumentNullException("activity"); 

            IDesignerHost designerHost = GetService(typeof(IDesignerHost)) as IDesignerHost; 
            if (designerHost == null)
                throw new InvalidOperationException(SR.GetString(SR.General_MissingService, typeof(IDesignerHost).FullName));

            designerHost.DestroyComponent(activity); 
            if (activity is CompositeActivity)
            { 
                foreach (Activity activity2 in Helpers.GetNestedActivities(activity as CompositeActivity)) 
                    designerHost.DestroyComponent(activity2);
            } 
        }
        #endregion

        #region Protected Methods and Properties 
        protected override void PerformLoad(IDesignerSerializationManager serializationManager)
        { 
        } 

        protected override void PerformFlush(IDesignerSerializationManager serializationManager) 
        {
            SaveDesignerLayout();
        }
 
        protected override void OnEndLoad(bool successful, ICollection errors)
        { 
            base.OnEndLoad(successful, errors); 

            if (successful) 
            {
                //We initialize the events coordinator only once when loading of the designer is complete
                ActivityDesigner rootDesigner = ActivityDesigner.GetRootDesigner(LoaderHost);
                if (this.eventsCoordinator == null && (rootDesigner == null || rootDesigner.ParentDesigner == null)) 
                    this.eventsCoordinator = new WorkflowDesignerEventsCoordinator(LoaderHost);
 
                try 
                {
                    this.loadingDesignerLayout = true; 

                    string layoutFileName = DesignerLayoutFileName;
                    IList layoutErrors = null;
                    if (File.Exists(layoutFileName)) 
                        LoadDesignerLayout(out layoutErrors);
                    else if (InDebugMode || (ActivityDesigner.GetRootDesigner(LoaderHost) != null && ActivityDesigner.GetRootDesigner(LoaderHost).ParentDesigner != null)) 
                        LoadDesignerLayoutFromResource(out layoutErrors); 

                    if (layoutErrors != null) 
                    {
                        if (errors == null)
                            errors = new ArrayList();
                        IList designerErrors = errors as IList; 
                        if (designerErrors != null)
                        { 
                            foreach (object layoutError in layoutErrors) 
                                designerErrors.Add(layoutError);
                        } 
                    }
                }
                finally
                { 
                    this.loadingDesignerLayout = false;
                } 
            } 
        }
 
        protected void LoadDesignerLayoutFromResource(Type type, string manifestResourceName, out IList errors)
        {
            if (type == null)
                throw new ArgumentNullException("type"); 

            if (manifestResourceName == null) 
                throw new ArgumentNullException("manifestResourceName"); 

            if (manifestResourceName.Length == 0) 
                throw new ArgumentException(SR.GetString(SR.Error_ParameterCannotBeEmpty), "manifestResourceName");

            errors = new ArrayList();
 
            Stream stream = type.Module.Assembly.GetManifestResourceStream(type, manifestResourceName);
            if (stream == null) 
                stream = type.Module.Assembly.GetManifestResourceStream(manifestResourceName); 

            if (stream != null) 
            {
                using (XmlReader layoutReader = XmlReader.Create(stream))
                {
                    if (layoutReader != null) 
                        LoadDesignerLayout(layoutReader, out errors);
                } 
            } 
        }
 
        protected void LoadDesignerLayout(XmlReader layoutReader, out IList layoutLoadErrors)
        {
            if (layoutReader == null)
                throw new ArgumentNullException("layoutReader"); 

            ArrayList errors = new ArrayList(); 
            layoutLoadErrors = errors; 

            ActivityDesigner rootDesigner = null; 
            IDesignerHost designerHost = GetService(typeof(IDesignerHost)) as IDesignerHost;
            if (designerHost != null && designerHost.RootComponent != null)
                rootDesigner = designerHost.GetDesigner(designerHost.RootComponent) as ActivityDesigner;
 
            if (rootDesigner != null)
            { 
                if (rootDesigner.SupportsLayoutPersistence) 
                {
                    DesignerSerializationManager serializationManager = new DesignerSerializationManager(LoaderHost); 
                    using (serializationManager.CreateSession())
                    {
                        WorkflowMarkupSerializationManager layoutSerializationManager = new WorkflowMarkupSerializationManager(serializationManager);
                        layoutSerializationManager.AddSerializationProvider(new ActivityDesignerLayoutSerializerProvider()); 

                        try 
                        { 
                            new WorkflowMarkupSerializer().Deserialize(layoutSerializationManager, layoutReader);
                        } 
                        catch (Exception e)
                        {
                            errors.Add(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_LayoutDeserialization), e));
                        } 
                        finally
                        { 
                            if (serializationManager.Errors != null) 
                                errors.AddRange(serializationManager.Errors);
                        } 
                    }
                }
                else
                { 
                    errors.Add(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_LayoutSerializationPersistenceSupport)));
                } 
            } 
            else
            { 
                errors.Add(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_LayoutSerializationRootDesignerNotFound)));
            }
        }
 
        protected void SaveDesignerLayout(XmlWriter layoutWriter, ActivityDesigner rootDesigner, out IList layoutSaveErrors)
        { 
            if (layoutWriter == null) 
                throw new ArgumentNullException("layoutWriter");
 
            if (rootDesigner == null)
                throw new ArgumentNullException("rootDesigner");

            ArrayList errors = new ArrayList(); 
            layoutSaveErrors = errors;
 
            if (rootDesigner.SupportsLayoutPersistence) 
            {
                DesignerSerializationManager serializationManager = new DesignerSerializationManager(LoaderHost); 
                using (serializationManager.CreateSession())
                {
                    WorkflowMarkupSerializationManager layoutSerializationManager = new WorkflowMarkupSerializationManager(serializationManager);
                    layoutSerializationManager.AddSerializationProvider(new ActivityDesignerLayoutSerializerProvider()); 

                    try 
                    { 
                        new WorkflowMarkupSerializer().Serialize(layoutSerializationManager, layoutWriter, rootDesigner);
                    } 
                    catch (Exception e)
                    {
                        errors.Add(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_LayoutSerialization), e));
                    } 
                    finally
                    { 
                        if (serializationManager.Errors != null) 
                            errors.AddRange(serializationManager.Errors);
                    } 
                }
            }
            else
            { 
                errors.Add(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_LayoutSerializationPersistenceSupport)));
            } 
        } 
        #endregion
 
        #region Private Methods and Properties
        internal void SetModified(bool modified)
        {
            if (LoaderHost != null && !LoaderHost.Loading && !this.loadingDesignerLayout) 
            {
                OnModifying(); 
                base.Modified = modified; 
            }
        } 

        internal static void AddActivityToDesigner(IServiceProvider serviceProvider, Activity activity)
        {
            WorkflowDesignerLoader workflowLoader = serviceProvider.GetService(typeof(WorkflowDesignerLoader)) as WorkflowDesignerLoader; 
            if (workflowLoader == null)
                throw new InvalidOperationException(SR.GetString(SR.General_MissingService, typeof(WorkflowDesignerLoader).FullName)); 
 
            workflowLoader.AddActivityToDesigner(activity);
        } 

        internal static void RemoveActivityFromDesigner(IServiceProvider serviceProvider, Activity activity)
        {
            WorkflowDesignerLoader workflowLoader = serviceProvider.GetService(typeof(WorkflowDesignerLoader)) as WorkflowDesignerLoader; 
            if (workflowLoader == null)
                throw new InvalidOperationException(SR.GetString(SR.General_MissingService, typeof(WorkflowDesignerLoader).FullName)); 
 
            workflowLoader.RemoveActivityFromDesigner(activity);
        } 

        private object OnCreateService(IServiceContainer container, Type serviceType)
        {
            object createdService = null; 

            if (serviceType == typeof(ComponentSerializationService)) 
                createdService = new XomlComponentSerializationService(LoaderHost); 
            else if (serviceType == typeof(IReferenceService))
                createdService = new ReferenceService(LoaderHost); 
            else if (serviceType == typeof(IIdentifierCreationService))
                createdService = new IdentifierCreationService(container, this);
            else if (serviceType == typeof(IWorkflowCompilerOptionsService))
                createdService = new WorkflowCompilerOptionsService(); 
            else if (serviceType == typeof(IDesignerVerbProviderService))
                createdService = new DesignerVerbProviderService(); 
 
            if (createdService != null)
            { 
                if (this.createdServices == null)
                    this.createdServices = new Hashtable();
                object existingService = this.createdServices[serviceType];
                this.createdServices[serviceType] = createdService; 
                if (existingService != null)
                { 
                    OnDisposeService(serviceType, existingService); 
                }
            } 

            return createdService;
        }
        private void OnDisposeService(Type serviceType, object service) 
        {
            if (serviceType == typeof(IReferenceService)) 
            { 
                ReferenceService refService = service as ReferenceService;
                if (refService != null) 
                {
                    refService.Dispose();
                }
            } 
        }
 
        private void LoadDesignerLayoutFromResource(out IList layoutErrors) 
        {
            layoutErrors = null; 

            IWorkflowRootDesigner rootDesigner = ActivityDesigner.GetSafeRootDesigner(LoaderHost);
            if (rootDesigner == null || !rootDesigner.SupportsLayoutPersistence)
                return; 

            Type rootActivityType = rootDesigner.Component.GetType(); 
            string resourceName = rootActivityType.Name + WorkflowDesignerLoader.DesignerLayoutFileExtension; 

            LoadDesignerLayoutFromResource(rootActivityType, resourceName, out layoutErrors); 
        }

        private void LoadDesignerLayout(out IList layoutErrors)
        { 
            layoutErrors = null;
 
            string layoutFileName = DesignerLayoutFileName; 
            IWorkflowRootDesigner rootDesigner = ActivityDesigner.GetSafeRootDesigner(LoaderHost);
            if (rootDesigner == null || !rootDesigner.SupportsLayoutPersistence || !File.Exists(layoutFileName)) 
                return;

            using (TextReader layoutReader = GetFileReader(layoutFileName))
            { 
                if (layoutReader != null)
                { 
                    using (XmlReader xmlReader = XmlReader.Create(layoutReader)) 
                        LoadDesignerLayout(xmlReader, out layoutErrors);
                } 
            }
        }

        private void SaveDesignerLayout() 
        {
            string layoutFileName = DesignerLayoutFileName; 
            ActivityDesigner rootDesigner = ActivityDesigner.GetSafeRootDesigner(LoaderHost); 
            if (String.IsNullOrEmpty(layoutFileName) || rootDesigner == null || !rootDesigner.SupportsLayoutPersistence)
                return; 

            using (TextWriter layoutWriter = GetFileWriter(layoutFileName))
            {
                if (layoutWriter != null) 
                {
                    IList layoutErrors = null; 
                    using (XmlWriter xmlWriter = Helpers.CreateXmlWriter(layoutWriter)) 
                        SaveDesignerLayout(xmlWriter, rootDesigner, out layoutErrors);
                } 
            }
        }

        private string DesignerLayoutFileName 
        {
            get 
            { 
                string layoutFileName = FileName;
                if (!String.IsNullOrEmpty(layoutFileName)) 
                {
                    layoutFileName = Path.Combine(Path.GetDirectoryName(layoutFileName), Path.GetFileNameWithoutExtension(layoutFileName));
                    layoutFileName += WorkflowDesignerLoader.DesignerLayoutFileExtension;
                } 
                return layoutFileName;
            } 
        } 
        #endregion
    } 
    #endregion

    #region Class DesignerVerbProviderService
    internal sealed class DesignerVerbProviderService : IDesignerVerbProviderService 
    {
        private List designerVerbProviders = new List(); 
 
        public DesignerVerbProviderService()
        { 
            ((IDesignerVerbProviderService)this).AddVerbProvider(new FreeFormDesignerVerbProvider());
        }

        #region IDesignerVerbProviderService Implementation 
        void IDesignerVerbProviderService.AddVerbProvider(IDesignerVerbProvider verbProvider)
        { 
            if (!this.designerVerbProviders.Contains(verbProvider)) 
                this.designerVerbProviders.Add(verbProvider);
        } 

        void IDesignerVerbProviderService.RemoveVerbProvider(IDesignerVerbProvider verbProvider)
        {
            this.designerVerbProviders.Remove(verbProvider); 
        }
 
        ReadOnlyCollection IDesignerVerbProviderService.VerbProviders 
        {
            get 
            {
                return this.designerVerbProviders.AsReadOnly();
            }
        } 
        #endregion
    } 
    #endregion 

    #region Class WorkflowDesignerEventsCoordinator 
    //THIS CLASS IS CREATED WITH SOLE PURPOSE OF LISTENING TO COMMON EVENTS AT ONE LOCATION, AND AVOID
    //LISTENING TO EVENTS SUCH AS TYPESCHANGED, ACTIVEDESIGNERCHANGED, SELECTIONCHANGED AND COMPONENTCHANGED
    //REPEATEDLY
    internal sealed class WorkflowDesignerEventsCoordinator : IDisposable 
    {
        private IDesignerLoaderHost serviceProvider; 
 
        private bool typeSystemTypesChanged = false;
 
        private EventHandler refreshTypesHandler;
        private EventHandler refreshDesignerActionsHandler;
        private EventHandler refreshTasksHandler;
 
        public WorkflowDesignerEventsCoordinator(IDesignerLoaderHost serviceProvider)
        { 
            this.serviceProvider = serviceProvider; 

            this.serviceProvider.LoadComplete += new EventHandler(OnDesignerReloaded); 

            //Listen to the events so that we are sure that we appropriately refresh the designer actions and tasks when the types
            //change
            IDesignerEventService designerEventService = this.serviceProvider.GetService(typeof(IDesignerEventService)) as IDesignerEventService; 
            if (designerEventService != null)
                designerEventService.ActiveDesignerChanged += new ActiveDesignerEventHandler(OnActiveDesignerChanged); 
 
            ITypeProvider typeProvider = this.serviceProvider.GetService(typeof(ITypeProvider)) as ITypeProvider;
            if (typeProvider != null) 
                typeProvider.TypesChanged += new EventHandler(OnTypeSystemTypesChanged);

            ISelectionService selectionService = this.serviceProvider.GetService(typeof(ISelectionService)) as ISelectionService;
            if (selectionService != null) 
                selectionService.SelectionChanged += new EventHandler(OnSelectionChanged);
 
            IComponentChangeService componentChangedService = this.serviceProvider.GetService(typeof(IComponentChangeService)) as IComponentChangeService; 
            if (componentChangedService != null)
                componentChangedService.ComponentChanged += new ComponentChangedEventHandler(OnComponentChanged); 

            IPropertyValueUIService propertyValueService = this.serviceProvider.GetService(typeof(IPropertyValueUIService)) as IPropertyValueUIService;
            if (propertyValueService != null)
                propertyValueService.AddPropertyValueUIHandler(new PropertyValueUIHandler(OnPropertyGridAdornments)); 
        }
 
        void IDisposable.Dispose() 
        {
            WorkflowView workflowView = this.serviceProvider.GetService(typeof(WorkflowView)) as WorkflowView; 
            if (workflowView != null)
            {
                if (this.refreshTypesHandler != null)
                    workflowView.Idle -= this.refreshTypesHandler; 

                if (this.refreshDesignerActionsHandler != null) 
                    workflowView.Idle -= this.refreshDesignerActionsHandler; 

                if (this.refreshTasksHandler != null) 
                    workflowView.Idle -= this.refreshTasksHandler;
            }

            this.refreshTypesHandler = null; 
            this.refreshDesignerActionsHandler = null;
            this.refreshTasksHandler = null; 
 
            IExtendedUIService extUIService = this.serviceProvider.GetService(typeof(IExtendedUIService)) as IExtendedUIService;
            if (extUIService != null) 
                extUIService.RemoveDesignerActions();

            IPropertyValueUIService propertyValueService = this.serviceProvider.GetService(typeof(IPropertyValueUIService)) as IPropertyValueUIService;
            if (propertyValueService != null) 
                propertyValueService.RemovePropertyValueUIHandler(new PropertyValueUIHandler(OnPropertyGridAdornments));
 
            IComponentChangeService componentChangedService = this.serviceProvider.GetService(typeof(IComponentChangeService)) as IComponentChangeService; 
            if (componentChangedService != null)
                componentChangedService.ComponentChanged -= new ComponentChangedEventHandler(OnComponentChanged); 

            ISelectionService selectionService = this.serviceProvider.GetService(typeof(ISelectionService)) as ISelectionService;
            if (selectionService != null)
                selectionService.SelectionChanged -= new EventHandler(OnSelectionChanged); 

            ITypeProvider typeProvider = this.serviceProvider.GetService(typeof(ITypeProvider)) as ITypeProvider; 
            if (typeProvider != null) 
                typeProvider.TypesChanged -= new EventHandler(OnTypeSystemTypesChanged);
 
            IDesignerEventService designerEventService = this.serviceProvider.GetService(typeof(IDesignerEventService)) as IDesignerEventService;
            if (designerEventService != null)
                designerEventService.ActiveDesignerChanged -= new ActiveDesignerEventHandler(OnActiveDesignerChanged);
 
            this.serviceProvider.LoadComplete -= new EventHandler(OnDesignerReloaded);
        } 
 
        private void OnDesignerReloaded(object sender, EventArgs e)
        { 
            bool refreshTypes = (this.refreshTypesHandler != null);
            bool refreshDesignerActions = (this.refreshDesignerActionsHandler != null);
            bool refreshTasks = (this.refreshTasksHandler != null);
 
            this.refreshTypesHandler = null;
            this.refreshDesignerActionsHandler = null; 
            this.refreshTasksHandler = null; 

            if (refreshTypes || refreshTasks || refreshDesignerActions) 
            {
                RefreshTypes();
                RefreshDesignerActions();
            } 
        }
 
        private void OnTypeSystemTypesChanged(object sender, EventArgs e) 
        {
            this.typeSystemTypesChanged = true; 

            //If the current designer is not active designer then we need to wait for it to be active before we update the types
            IDesignerEventService designerEventService = this.serviceProvider.GetService(typeof(IDesignerEventService)) as IDesignerEventService;
            if (designerEventService != null && designerEventService.ActiveDesigner == this.serviceProvider.GetService(typeof(IDesignerHost))) 
                RefreshTypes();
        } 
 
        private void OnActiveDesignerChanged(object sender, ActiveDesignerEventArgs e)
        { 
            if (e.NewDesigner == this.serviceProvider.GetService(typeof(IDesignerHost)) && this.typeSystemTypesChanged)
                RefreshTypes();
            else
                RefreshTasks(); 
        }
 
        private void OnComponentChanged(object sender, ComponentChangedEventArgs eventArgs) 
        {
            RefreshDesignerActions(); 
        }

        private void RefreshTypes()
        { 
            if (this.refreshTypesHandler == null && this.typeSystemTypesChanged)
            { 
                WorkflowView workflowView = this.serviceProvider.GetService(typeof(WorkflowView)) as WorkflowView; 
                if (workflowView != null)
                { 
                    this.refreshTypesHandler = new EventHandler(OnRefreshTypes);
                    workflowView.Idle += this.refreshTypesHandler;
                }
            } 

            this.typeSystemTypesChanged = false; 
        } 

        private void OnRefreshTypes(object sender, EventArgs e) 
        {
            if (this.refreshTypesHandler != null)
            {
                WorkflowView workflowView = this.serviceProvider.GetService(typeof(WorkflowView)) as WorkflowView; 
                if (workflowView != null)
                    workflowView.Idle -= this.refreshTypesHandler; 
                this.refreshTypesHandler = null; 
            }
 
            IDesignerHost designerHost = this.serviceProvider.GetService(typeof(IDesignerHost)) as IDesignerHost;
            Activity rootActivity = (designerHost != null) ? designerHost.RootComponent as Activity : null;
            if (rootActivity == null)
                return; 

            //Now Refresh the types as well as the designer actions 
            ITypeProvider typeProvider = this.serviceProvider.GetService(typeof(ITypeProvider)) as ITypeProvider; 
            if (typeProvider != null)
            { 
                Walker walker = new Walker();
                walker.FoundProperty += delegate(Walker w, WalkerEventArgs args)
                {
                    if (args.CurrentValue != null && 
                        args.CurrentProperty != null &&
                        args.CurrentProperty.PropertyType == typeof(System.Type) && 
                        args.CurrentValue is System.Type) 
                    {
                        Type updatedType = typeProvider.GetType(((Type)args.CurrentValue).FullName); 
                        if (updatedType != null)
                        {
                            args.CurrentProperty.SetValue(args.CurrentPropertyOwner, updatedType, null);
 
                            if (args.CurrentActivity != null)
                                TypeDescriptor.Refresh(args.CurrentActivity); 
                        } 
                    }
                    else if (args.CurrentProperty == null && args.CurrentValue is DependencyObject && !(args.CurrentValue is Activity)) 
                    {
                        walker.WalkProperties(args.CurrentActivity, args.CurrentValue);
                    }
                }; 
                walker.FoundActivity += delegate(Walker w, WalkerEventArgs args)
                { 
                    if (args.CurrentActivity != null) 
                    {
                        TypeDescriptor.Refresh(args.CurrentActivity); 

                        ActivityDesigner activityDesigner = ActivityDesigner.GetDesigner(args.CurrentActivity);
                        if (activityDesigner != null)
                            activityDesigner.RefreshDesignerActions(); 

                        InvokeWorkflowDesigner invokeWorkflowDesigner = activityDesigner as InvokeWorkflowDesigner; 
                        if (invokeWorkflowDesigner != null) 
                            invokeWorkflowDesigner.RefreshTargetWorkflowType();
                    } 
                };

                walker.Walk(rootActivity);
            } 

            IPropertyValueUIService propertyValueService = this.serviceProvider.GetService(typeof(IPropertyValueUIService)) as IPropertyValueUIService; 
            if (propertyValueService != null) 
                propertyValueService.NotifyPropertyValueUIItemsChanged();
 
            RefreshTasks();
            RefreshDesignerActions();
        }
 
        private void RefreshDesignerActions()
        { 
            if (this.refreshDesignerActionsHandler == null) 
            {
                WorkflowView workflowView = this.serviceProvider.GetService(typeof(WorkflowView)) as WorkflowView; 
                if (workflowView != null)
                {
                    this.refreshDesignerActionsHandler = new EventHandler(OnRefreshDesignerActions);
                    workflowView.Idle += this.refreshDesignerActionsHandler; 
                }
            } 
        } 

        private void OnRefreshDesignerActions(object sender, EventArgs e) 
        {
            //NOTE: Make sure that we dont invalidate the workflow here. Workflow will be invalidated when'
            //the designer actions are refreshed on idle thread. Putting invalidation logic here causes the validation
            //to go haywire as before the idle message comes in we start getting to DesignerActions thru the paiting 
            //logic to show smart tags. This causes problems and ConfigErrors appear everywhere on designer intermittently
 
            //PROBLEM: ConfigErrors appearing on the entire design surface 
            //This is due to a race condition between the validation triggered during painting
            //logic and validation triggered when we try to access the DesignerActions from RefreshTask handler 
            //In the validation logic we try to get to the types while doing so we Refresh the code compile unit
            //in typesystem which in turn triggers CodeDomLoader.Refresh. In this we remove types, call refresh handler
            //and add new types. While doing this after the remove types but before addtypes, call is made to the drawing
            //logic in which we try to grab the designer actions which triggers another set of validations hence now we 
            //always call UpdateWindow after invalidatewindow so that the validation will always get triggered on painting thread.
            //NOTE: PLEASE DO NOT CHANGE SEQUENCE IN WHICH THE FOLLOWING HANDLERS ARE ADDED 
            //THE PROBLEM CAN BE ALSO FIXED BY TRIGGERING VALIDATION IN RefreshDesignerActions ITSELF 
            //FOR NOW THE REFRESH FIX WILL CAUSE MINIMAL IMPACT IN THE LIGHT OF M3
 
            WorkflowView workflowView = this.serviceProvider.GetService(typeof(WorkflowView)) as WorkflowView;
            if (this.refreshDesignerActionsHandler != null)
            {
                if (workflowView != null) 
                    workflowView.Idle -= this.refreshDesignerActionsHandler;
                this.refreshDesignerActionsHandler = null; 
            } 

            DesignerHelpers.RefreshDesignerActions(this.serviceProvider); 

            IPropertyValueUIService propertyValueService = this.serviceProvider.GetService(typeof(IPropertyValueUIService)) as IPropertyValueUIService;
            if (propertyValueService != null)
                propertyValueService.NotifyPropertyValueUIItemsChanged(); 

            RefreshTasks(); 
        } 

        private void OnSelectionChanged(object sender, EventArgs e) 
        {
            WorkflowView workflowView = this.serviceProvider.GetService(typeof(WorkflowView)) as WorkflowView;
            if (workflowView != null)
                workflowView.Invalidate(); 

            RefreshTasks(); 
        } 

        private void RefreshTasks() 
        {
            if (this.refreshTasksHandler == null)
            {
                //Listen to the next idle event to populate the tasks; this should happen on selection changed as well as active designer changed if the current designer is active 
                WorkflowView workflowView = this.serviceProvider.GetService(typeof(WorkflowView)) as WorkflowView;
                if (workflowView != null) 
                { 
                    this.refreshTasksHandler = new EventHandler(OnRefreshTasks);
                    workflowView.Idle += this.refreshTasksHandler; 
                }
            }
        }
 
        private void OnRefreshTasks(object sender, EventArgs e)
        { 
            WorkflowView workflowView = this.serviceProvider.GetService(typeof(WorkflowView)) as WorkflowView; 
            if (this.refreshTasksHandler != null)
            { 
                if (workflowView != null)
                    workflowView.Idle -= this.refreshTasksHandler;
                this.refreshTasksHandler = null;
            } 

            ISelectionService selectionService = this.serviceProvider.GetService(typeof(ISelectionService)) as ISelectionService; 
            IExtendedUIService extendedUIService = this.serviceProvider.GetService(typeof(IExtendedUIService)) as IExtendedUIService; 
            if (selectionService != null && extendedUIService != null)
            { 
                extendedUIService.RemoveDesignerActions();

                //Only if the current designer is active designer we add the designer actions to the task list
                IDesignerEventService designerEventService = (IDesignerEventService)this.serviceProvider.GetService(typeof(IDesignerEventService)); 
                if (designerEventService != null && designerEventService.ActiveDesigner == this.serviceProvider.GetService(typeof(IDesignerHost)))
                { 
                    foreach (object obj in selectionService.GetSelectedComponents()) 
                    {
                        ActivityDesigner activityDesigner = null; 
                        if (obj is HitTestInfo)
                            activityDesigner = ((HitTestInfo)obj).AssociatedDesigner;
                        else if (obj is Activity)
                            activityDesigner = ActivityDesigner.GetDesigner(obj as Activity); 

                        if (activityDesigner != null) 
                            extendedUIService.AddDesignerActions(new List(activityDesigner.DesignerActions).ToArray()); 
                    }
                } 
            }

            if (workflowView != null)
                workflowView.Invalidate(); 
        }
 
        private void OnPropertyGridAdornments(ITypeDescriptorContext context, PropertyDescriptor propDesc, ArrayList valueUIItemList) 
        {
            IComponent component = null; 
            IReferenceService referenceService = this.serviceProvider.GetService(typeof(IReferenceService)) as IReferenceService;
            if (referenceService != null)
                component = referenceService.GetComponent(context.Instance);
 
            string fullAliasName = string.Empty;
            //this attribue is set to overcome issue with the TypedVariableDeclarationTypeConverter 
            //not returning Name property at all. we alias that property to the VariableDeclaration itself 
            DefaultPropertyAttribute aliasPropertyNameAttribute = propDesc.Attributes[typeof(DefaultPropertyAttribute)] as DefaultPropertyAttribute;
            if (aliasPropertyNameAttribute != null && aliasPropertyNameAttribute.Name != null && aliasPropertyNameAttribute.Name.Length > 0) 
                fullAliasName = propDesc.Name + "." + aliasPropertyNameAttribute.Name;

            if (component != null)
            { 
                ActivityDesigner activityDesigner = ActivityDesigner.GetDesigner(component as Activity);
                if (activityDesigner != null) 
                { 
                    if (!activityDesigner.IsLocked && ActivityBindPropertyDescriptor.IsBindableProperty(propDesc) && !propDesc.IsReadOnly)
                        valueUIItemList.Add(new PropertyValueUIItem(DR.GetImage(DR.Bind), OnBindProperty, DR.GetString(DR.BindProperty))); 

                    string fullComponentName = referenceService.GetName(component);//schedule1.send1
                    string fullPropertyName = referenceService.GetName(context.Instance);//schedule1.send1.message
                    fullPropertyName = (fullPropertyName.Length > fullComponentName.Length) ? fullPropertyName.Substring(fullComponentName.Length + 1, fullPropertyName.Length - fullComponentName.Length - 1) + "." + propDesc.Name : string.Empty; 

                    foreach (DesignerAction action in activityDesigner.DesignerActions) 
                    { 
                        string actionPropertyName = action.PropertyName as string;
                        if (actionPropertyName == null || actionPropertyName.Length == 0) 
                            continue;

                        if (actionPropertyName == propDesc.Name || (actionPropertyName == fullPropertyName) || (actionPropertyName == fullAliasName))
                        { 
                            PropertyValueUIItemHandler propValueUIItemhandler = new PropertyValueUIItemHandler(action);
                            valueUIItemList.Add(new PropertyValueUIItem(action.Image, propValueUIItemhandler.OnFixPropertyError, action.Text)); 
                            break; 
                        }
                    } 
                }
            }
        }
 
        private void OnBindProperty(ITypeDescriptorContext context, PropertyDescriptor descriptor, PropertyValueUIItem invokedItem)
        { 
            BindUITypeEditor.EditValue(context); 
        }
 
        #region Class PropertyValueUIItemHandler
        private class PropertyValueUIItemHandler
        {
            DesignerAction action = null; 
            internal PropertyValueUIItemHandler(DesignerAction action)
            { 
                this.action = action; 
            }
            internal void OnFixPropertyError(ITypeDescriptorContext context, PropertyDescriptor descriptor, PropertyValueUIItem invokedItem) 
            {
                action.Invoke();
            }
        } 
        #endregion
    } 
    #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