ReceiveActivityDesigner.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 / NetFx35 / System.WorkflowServices / System / Workflow / Activities / ReceiveActivityDesigner.cs / 1305376 / ReceiveActivityDesigner.cs

                            //------------------------------------------------------------ 
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------

namespace System.Workflow.Activities 
{
    using System.Collections; 
    using System.ComponentModel; 
    using System.Workflow.ComponentModel.Design;
    using System.Drawing; 
    using System.Reflection;
    using System.Workflow.ComponentModel;
    using System.ComponentModel.Design;
    using System.Workflow.Activities.Design; 
    using System.ServiceModel;
    using System.Workflow.ComponentModel.Compiler; 
    using System.Windows.Forms; 

 
    [ActivityDesignerTheme(typeof(ReceiveActivityDesignerTheme))]
    class ReceiveActivityDesigner : SequenceDesigner
    {
        static ActivityComparer matchByContractCallback; 
        static ActivityComparer matchByOperationCallback;
 
        public override Size MinimumSize 
        {
            get 
            {
                return new Size(170, 80);
            }
        } 

        public override string Text 
        { 
            get
            { 
                if (this.ReceiveActivity.ServiceOperationInfo != null)
                {
                    string operationName = this.ReceiveActivity.ServiceOperationInfo.Name;
                    if (!String.IsNullOrEmpty(operationName)) 
                    {
                        return operationName; 
                    } 
                }
                return base.Text; 

            }
        }
 
        protected override ActivityDesignerVerbCollection Verbs
        { 
            get 
            {
                ActivityDesignerVerbCollection verbs = new ActivityDesignerVerbCollection(); 
                foreach (ActivityDesignerVerb verb in base.Verbs)
                {
                    verbs.Add(verb);
                } 

                ActivityDesignerVerb findSimilarOperationsVerb = new FindSimilarActivitiesVerb( 
                    this, MatchByOperationCallback, SR2.GetString(SR2.ShowActivitiesWithSameOperation)); 
                verbs.Add(findSimilarOperationsVerb);
 
                ActivityDesignerVerb findSimilarContractVerb = new FindSimilarActivitiesVerb(
                    this, MatchByContractCallback, SR2.GetString(SR2.ShowActivitiesWithSameContract));
                verbs.Add(findSimilarContractVerb);
 
                return verbs;
            } 
        } 

        static ActivityComparer MatchByContractCallback 
        {
            get
            {
                if (matchByContractCallback == null) 
                {
                    matchByContractCallback = new ActivityComparer(MatchByContract); 
                } 
                return matchByContractCallback;
            } 
        }

        static ActivityComparer MatchByOperationCallback
        { 
            get
            { 
                if (matchByOperationCallback == null) 
                {
                    matchByOperationCallback = new ActivityComparer(MatchByOperation); 
                }
                return matchByOperationCallback;
            }
        } 

        ReceiveActivity ReceiveActivity 
        { 
            get { return this.Activity as ReceiveActivity; }
 
        }

        internal static bool MatchByContract(OperationInfoBase source, OperationInfoBase target)
        { 
            if ((source == null) || (target == null))
            { 
                return false; 
            }
            string sourceContract = source.GetContractFullName(null); 
            string targetContract = target.GetContractFullName(null);
            return MatchNames(sourceContract, targetContract);
        }
 
        internal static bool MatchByOperation(OperationInfoBase source, OperationInfoBase target)
        { 
            if (!MatchByContract(source, target)) 
            {
                return false; 
            }
            return MatchNames(source.Name, target.Name);
        }
 
        protected override void Initialize(Activity activity)
        { 
            base.Initialize(activity); 

            IExtenderListService extenderListService = (IExtenderListService) GetService(typeof(IExtenderListService)); 
            if (extenderListService != null)
            {
                bool foundExtender = false;
                foreach (IExtenderProvider extenderProvider in extenderListService.GetExtenderProviders()) 
                {
                    if (extenderProvider.GetType() == typeof(WorkflowServiceAttributesPropertyProviderExtender)) 
                    { 
                        foundExtender = true;
                    } 
                }

                if (!foundExtender)
                { 
                    IExtenderProviderService extenderProviderService = (IExtenderProviderService) GetService(typeof(IExtenderProviderService));
                    if (extenderProviderService != null) 
                    { 
                        extenderProviderService.AddExtenderProvider(new WorkflowServiceAttributesPropertyProviderExtender());
                    } 
                }
            }
        }
 
        protected override void OnActivityChanged(ActivityChangedEventArgs e)
        { 
            base.OnActivityChanged(e); 
            if (e.Member != null && e.Member.Name == ReceiveActivity.ServiceOperationInfoProperty.Name)
            { 
                ReceiveActivity receiveActivity = e.Activity as ReceiveActivity;
                if (receiveActivity != null)
                {
                    receiveActivity.ParameterBindings.Clear(); 
                }
 
                TypeDescriptor.Refresh(e.Activity); 
                PerformLayout();
            } 
        }

        protected override void OnMouseDoubleClick(System.Windows.Forms.MouseEventArgs e)
        { 
            // Do not allow editing if activity is locked
            if (this.IsLocked) 
            { 
                return;
            } 

            OperationInfoBase pickedServiceOperation = null;
            if (ServiceOperationUIEditor.TryPickOperation(this.Activity.Site, this.Activity, this.ReceiveActivity.ServiceOperationInfo, out  pickedServiceOperation))
            { 
                PropertyDescriptorUtils.SetPropertyValue(this.Activity.Site, ServiceOperationHelpers.GetServiceOperationInfoPropertyDescriptor(this.Activity), this.Activity, pickedServiceOperation);
            } 
        } 

        protected override void OnPaint(ActivityDesignerPaintEventArgs e) 
        {
            base.OnPaint(e);
            Rectangle incomingArrowRect = new Rectangle(this.Location.X - 2, this.Location.Y + 20, 24, 24);
            Rectangle outgoingArrowRect = new Rectangle(this.Location.X + 22, this.Location.Y + this.Size.Height - 45, -24, 24); 
            e.Graphics.DrawImage(ImageResources.Arrow, incomingArrowRect);
            bool isOneWay = false; 
 

            if (ReceiveActivity.ServiceOperationInfo != null) 
            {
                // Refresh the referenced design time types in the serviceoperationInfo object properties;
                //ServiceOperationHelpers.RefreshReferencedDesignTimeTypes(this.Activity.Site as IServiceProvider, operation);
                isOneWay = this.ReceiveActivity.ServiceOperationInfo.GetIsOneWay(this.Activity.Site as IServiceProvider); 
            }
            if (!isOneWay) 
            { 
                e.Graphics.DrawImage(ImageResources.Arrow, outgoingArrowRect);
            } 
        }

        protected override void PreFilterProperties(IDictionary properties)
        { 
            base.PreFilterProperties(properties);
            ReceiveActivity receiveActivity = this.Activity as ReceiveActivity; 
            if (receiveActivity != null) 
            {
                receiveActivity.GetParameterPropertyDescriptors(properties); 
            }
        }

        static bool MatchByContract(ReceiveActivity source, ReceiveActivity target) 
        {
            return MatchByContract(source.ServiceOperationInfo, target.ServiceOperationInfo); 
        } 

        static bool MatchByOperation(ReceiveActivity source, ReceiveActivity target) 
        {
            return MatchByOperation(source.ServiceOperationInfo, target.ServiceOperationInfo);
        }
 
        static bool MatchNames(string sourceName, string targetName)
        { 
            if (string.IsNullOrEmpty(sourceName) || string.IsNullOrEmpty(targetName)) 
            {
                return false; 
            }
            return (sourceName == targetName);
        }
 
    }
 
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

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