Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Workflow.Activities/Designers/StateDesigner.TransitionInfo.cs

@@ -0,0 +1,194 @@
+namespace System.Workflow.Activities
+{
+    using System;
+    using System.Text;
+    using System.Reflection;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Collections.ObjectModel;
+    using System.CodeDom;
+    using System.ComponentModel;
+    using System.ComponentModel.Design;
+    using System.Drawing.Design;
+    using System.Drawing;
+    using System.Drawing.Drawing2D;
+    using System.Diagnostics;
+    using System.IO;
+    using System.Windows.Forms;
+    using System.Workflow.ComponentModel;
+    using System.Workflow.ComponentModel.Design;
+    using System.Runtime.Serialization;
+
+    internal partial class StateDesigner : FreeformActivityDesigner
+    {
+        internal class TransitionInfo
+        {
+            private SetStateActivity _setState;
+            private CompositeActivity _eventHandler;
+            private StateActivity _targetState;
+            private StateDesignerConnector _connector;
+
+            internal TransitionInfo(SetStateActivity setState, CompositeActivity eventHandler)
+            {
+                if (setState == null)
+                    throw new ArgumentNullException("setState");
+                if (eventHandler == null)
+                    throw new ArgumentNullException("eventHandler");
+                _setState = setState;
+                _eventHandler = eventHandler;
+            }
+
+            internal SetStateActivity SetState
+            {
+                get
+                {
+                    return _setState;
+                }
+            }
+
+            internal CompositeActivity EventHandler
+            {
+                get
+                {
+                    return _eventHandler;
+                }
+            }
+
+            internal StateActivity SourceState
+            {
+                get
+                {
+                    if (_eventHandler == null)
+                        return null;
+
+                    StateActivity sourceState = _eventHandler.Parent as StateActivity;
+                    return sourceState;
+                }
+            }
+
+            internal StateActivity TargetState
+            {
+                get
+                {
+                    return _targetState;
+                }
+                set
+                {
+                    _targetState = value;
+                }
+            }
+
+            internal StateDesignerConnector Connector
+            {
+                get
+                {
+                    return _connector;
+                }
+                set
+                {
+                    _connector = value;
+                }
+            }
+
+            internal bool Matches(StateDesignerConnector stateDesignerConnector)
+            {
+                if (stateDesignerConnector == null)
+                    throw new ArgumentNullException("stateDesignerConnector");
+
+                if (this.Connector != null &&
+                    this.Connector == stateDesignerConnector)
+                    return true;
+
+                // this transitioninfo is incomplete,
+                // therefore, it cannot match an existing connector
+                if (this.SetState == null ||
+                    this.SourceState == null ||
+                    this.TargetState == null ||
+                    this.EventHandler == null)
+                    return false;
+
+                if (this.SetState.QualifiedName != stateDesignerConnector.SetStateName)
+                    return false;
+
+                if (this.SourceState.QualifiedName != stateDesignerConnector.SourceStateName)
+                    return false;
+
+                if (this.TargetState.QualifiedName != stateDesignerConnector.TargetStateName ||
+                    stateDesignerConnector.Target.AssociatedDesigner.Activity.QualifiedName != stateDesignerConnector.TargetStateName)
+                    return false;
+
+                if (this.EventHandler.QualifiedName != stateDesignerConnector.EventHandlerName)
+                    return false;
+
+                return true;
+            }
+
+            internal static ReadOnlyCollection<TransitionInfo> ParseStateMachine(StateActivity rootState)
+            {
+                List<TransitionInfo> transitions = new List<TransitionInfo>();
+                Dictionary<string, StateActivity> states = new Dictionary<string, StateActivity>();
+                Queue<StateActivity> processingQueue = new Queue<StateActivity>();
+                processingQueue.Enqueue(rootState);
+                while (processingQueue.Count > 0)
+                {
+                    StateActivity state = processingQueue.Dequeue();
+                    states[state.QualifiedName] = state;
+                    foreach (Activity childActivity in state.Activities)
+                    {
+                        StateActivity childState = childActivity as StateActivity;
+                        if (childState == null)
+                        {
+                            CompositeActivity compositeChild = childActivity as CompositeActivity;
+                            if (compositeChild != null)
+                                ParseEventHandler(compositeChild, transitions);
+                        }
+                        else
+                        {
+                            processingQueue.Enqueue(childState);
+                        }
+                    }
+                }
+
+                foreach (TransitionInfo transitionInfo in transitions)
+                {
+                    StateActivity targetState;
+                    string targetStateName = transitionInfo.SetState.TargetStateName;
+                    if (!String.IsNullOrEmpty(targetStateName))
+                    {
+                        states.TryGetValue(transitionInfo.SetState.TargetStateName, out targetState);
+                        transitionInfo.TargetState = targetState;
+                    }
+                }
+
+                return transitions.AsReadOnly();
+            }
+
+            private static void ParseEventHandler(CompositeActivity eventHandler, List<TransitionInfo> transitions)
+            {
+                Queue<Activity> processingQueue = new Queue<Activity>();
+                processingQueue.Enqueue(eventHandler);
+                while (processingQueue.Count > 0)
+                {
+                    Activity activity = processingQueue.Dequeue();
+                    SetStateActivity setState = activity as SetStateActivity;
+                    if (setState != null)
+                    {
+                        TransitionInfo transitionInfo = new TransitionInfo(setState, eventHandler);
+                        transitions.Add(transitionInfo);
+                    }
+                    else
+                    {
+                        CompositeActivity compositeActivity = activity as CompositeActivity;
+                        if (compositeActivity != null)
+                        {
+                            foreach (Activity childActivity in compositeActivity.Activities)
+                            {
+                                processingQueue.Enqueue(childActivity);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}