public ExceptionsTests() { Definition = new StateMachineDefinition(); Definition.GetOrCreateState("s1") .Setup(_ => _.StartPoint = true); Definition.GetOrCreateState("s2") .Setup(_ => _.EndPoint = true); var tran1 = new Transition() { id = "t1", SourceStateId = "s1", TargetStateId = "s2" }; Definition.Transitions.Add(tran1); tran1 .Trigger("TestTrigger") .SetParameter <string>("TargetState", "s2"); var tran2 = new Transition() { id = "t2", SourceStateId = "s1", TargetStateId = "s2" }; Definition.Transitions.Add(tran2); tran2 .Trigger("TestTrigger") .SetParameter <string>("TargetState", "s2"); }
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label) { if (property.propertyType != SerializedPropertyType.String) { EditorGUI.PropertyField(position, property, label); } else { StateMachineDefinition sm = property.serializedObject.targetObject as StateMachineDefinition; GUIContent[] options = sm.states?.Select(s => new GUIContent(s.name)).Prepend(new GUIContent("(none)")).ToArray(); if (options != null) { int index = Array.FindIndex(options, c => c.text == property.stringValue); index = EditorGUI.Popup(position, label, index, options); if (index > 0) { property.stringValue = options[index].text; } else { property.stringValue = ""; } } else { property.stringValue = ""; } } }
public static string GetStateInitializers(StateMachineDefinition def) { string str = " allStates = new State[" + def.states.Count + "];\n\n"; for (int i = 0; i < def.states.Count; i++) { str += GetStateInitializer(def, i); } if (def.defaultState != null && def.defaultState.Length > 0 && def.GetState(def.defaultState) != null) { str += " rootMachine.defaultState = state" + def.defaultState + ";\n"; } else { str += " rootMachine.defaultState = allStates[0];\n"; } for (int i = 0; i < def.states.Count; i++) { str += GetStateParentChildInitializer(def, i); } return(str); }
public StateMachineDefinition GetStateMachineDefinition(string WFName) { TrackingWorkFlowInteraction II = new TrackingWorkFlowInteraction(); StateMachineDefinition statemachineDefinition = II.getStateMachineDefinition(WFName); return(statemachineDefinition); }
public static string GetTransitionInitializers(StateMachineDefinition def) { string str = ""; foreach (var state in def.states) { if (state.transitions != null) { for (int i = 0; i < state.transitions.Count; i++) { var t = state.transitions[i]; var to = def.GetState(t.to); if (to == null) { Debug.LogWarning("Ignoring transition from " + state.name + " to non-existant state " + t.to + "."); } else if (def.IsAncestor(state, to) || def.IsAncestor(to, state)) { Debug.LogWarning("Ignoring transition from " + state.name + " to " + t.to + " because one state is a direct ancestor."); } else { str += GetTransitionInitializer(state, t, i); } } } } return(str); }
public void CanStepOnceWithAlwaysCondition() { var sm = new StateMachineDefinition <TIn, TOut>() .AddState(RandomState()) .AddTransition(RandomState(), new AlwaysCondition <TIn, TOut>()) .Definition.CreateStateMachine(); var root = sm.CurrentState.Value.GUID; sm.Step(default);
internal ITransition DefaultTransition() { var genericType = StateMachineDefinition.GetType().GetInterface(typeof(IStateMachineDefinition <,>).Name); if (genericType == null) { Debug.LogError($"State machine type {StateMachineDefinition.GetType()} did not contain an IStateMachine"); } return(Activator.CreateInstance(typeof(Transition <,>).MakeGenericType(genericType)) as ITransition); }
public MoveStateOperation(StateMachineDefinition def, StateMachineEditorWindow window, StateMachineDefinition.State state) : base(def, window, state) { showBaseGUI = true; start = state.position; move = Vector2.zero; children = new List <StateMachineDefinition.State>(); AddChildren(state); CalcParentRect(); }
public static void GenerateImplClass(StateMachineDefinition def, string path) { string className = Path.GetFileNameWithoutExtension(path); string generated = string.Format(implClassTemplate, className, def.name, GetFunctionDeclarations(def, true)); StreamWriter outStream = new StreamWriter(path); outStream.Write(generated); outStream.Close(); AssetDatabase.Refresh(); }
public static string GetStateParentChildInitializer(StateMachineDefinition def, int index) { string str = ""; var state = def.states[index]; string p = state.parent; if (p != null && p.Length > 0) { var parent = def.GetState(p); if (parent != null && parent.hasChildren) { str += " state" + state.name + ".parent = state" + p + ";\n"; str += " state" + state.name + ".parentMachine = state" + p + ".subMachine;\n"; } else { Debug.LogWarning("State " + state.name + " has non-existant parent " + p + "."); str += " state" + state.name + ".parentMachine = rootMachine;\n"; } } else { str += " state" + state.name + ".parentMachine = rootMachine;\n"; } if (state.hasChildren) { var children = def.GetChildren(state.name); if (children.Count > 0) { StateMachineDefinition.State defState = null; foreach (var child in children) { if (child.name == state.localDefault) { defState = child; break; } } if (defState == null) { defState = children[0]; } str += " state" + state.name + ".subMachine.defaultState = state" + defState.name + ";\n"; } } return(str); }
public override void OnInspectorGUI() { StateMachineDefinition myTarget = (StateMachineDefinition)target; if (GUILayout.Button("Open State Machine Editor")) { StateMachineEditorWindow.def = myTarget; StateMachineEditorWindow.ShowWindow(); } serializedObject.Update(); DrawPropertiesExcluding(serializedObject, "m_Script"); serializedObject.ApplyModifiedProperties(); }
public static string GetFunctionDeclarations(StateMachineDefinition def, bool impl = false) { string vo = impl ? "override" : "abstract"; string end = impl ? "() { }" + nl : "();" + nl; string end2 = impl ? "() { return false; }" + nl : "();" + nl; string str = ""; foreach (var state in def.states) { if (state.hasEnter) { str += " protected " + vo + " void StateEnter_" + state.name + end; } if (state.hasDuring) { str += " protected " + vo + " void State_" + state.name + end; } if (state.hasExit) { str += " protected " + vo + " void StateExit_" + state.name + end; } } str += "" + nl; foreach (var state in def.states) { if (state.transitions != null) { foreach (var trans in state.transitions) { if (trans.mode == StateMachineDefinition.TransitionMode.Condition) { str += " protected " + vo + " bool TransitionCond_" + state.name + "_" + trans.to + end2; } if (trans.hasNotify) { str += " protected " + vo + " void TransitionNotify_" + state.name + "_" + trans.to + end; } } } } return(str); }
public static string GetTransitionInitializers(StateMachineDefinition def) { string str = ""; foreach (var state in def.states) { if (state.transitions != null) { for (int i = 0; i < state.transitions.Count; i++) { str += GetTransitionInitializer(state, state.transitions[i], i); } } } return(str); }
private static string GetStateEnums(StateMachineDefinition def) { string str = ""; for (int i = 0; i < def.states.Count; i++) { str += def.states[i].name; if (i < def.states.Count - 1) { str += ", "; } } return(str); }
public static void GenerateAbstractClass(StateMachineDefinition def) { string generated = string.Format(abstractClassTemplate, def.name, GetStateEnums(def), GetStateInitializers(def), GetTransitionInitializers(def), GetFunctionDeclarations(def), def.baseClass); string defPath = AssetDatabase.GetAssetPath(def); if (defPath.Length > 0) { string newPath = defPath.Substring(0, defPath.LastIndexOf(".")) + ".cs"; StreamWriter outStream = new StreamWriter(newPath); outStream.Write(generated); outStream.Close(); AssetDatabase.Refresh(); } }
public static string GetFunctionDeclarations(StateMachineDefinition def, bool over = false) { string vo = over ? "override" : "virtual"; string str = ""; foreach (var state in def.states) { if (state.hasEnter) { str += " protected " + vo + " void StateEnter_" + state.name + "() { }\n"; } if (state.hasDuring) { str += " protected " + vo + " void State_" + state.name + "() { }\n"; } if (state.hasExit) { str += " protected " + vo + " void StateExit_" + state.name + "() { }\n"; } } str += "\n"; foreach (var state in def.states) { if (state.transitions != null) { foreach (var trans in state.transitions) { str += " protected " + vo + " bool TransitionCond_" + state.name + "_" + trans.to + "() { return false; }\n"; if (trans.hasNotify) { str += " protected " + vo + " void TransitionNotify_" + state.name + "_" + trans.to + "() { }\n"; } } } } return(str); }
public static string GetTriggerDeclarations(StateMachineDefinition def) { string str = ""; HashSet <string> created = new HashSet <string>(); foreach (var state in def.states) { foreach (var tr in state.transitions) { if (tr.mode == StateMachineDefinition.TransitionMode.Message && created.Add(tr.message)) { str += " protected readonly Trigger trigger_" + tr.message + " = new Trigger();" + nl; str += " public void " + tr.message + "() => trigger_" + tr.message + ".Set();" + nl; } } } return(str); }
public async Task AsyncWork() { var def = new StateMachineDefinition <int, int>(); var root = new State <int, int>(); var workState = new AsyncIntMultiplierState(); def.AddState(root); def.AddState(workState); root.AddTransition(workState, new AlwaysCondition <int, int>()); var sm = def.CreateStateMachine(); // Entry for first time should divide input by 2 Assert.AreEqual(2, await sm.StepAsync(4)); // Reentry should times by 2 Assert.AreEqual(8, await sm.StepAsync(4)); }
public void CanSerializeDefinition() { var rootState = RandomState(); var def = new StateMachineDefinition <TIn, TOut>(rootState); var secondState = def.AddState(RandomState()); rootState.AddTransition(secondState, new AlwaysCondition <TIn, TOut>()); secondState.AddTransition(rootState, new AlwaysCondition <TIn, TOut>()); var jsonSettings = new JsonSerializerSettings() { TypeNameHandling = TypeNameHandling.Auto, Formatting = Formatting.Indented }; var json = JsonConvert.SerializeObject(def, jsonSettings); var des = JsonConvert.DeserializeObject <StateMachineDefinition <TIn, TOut> >(json, jsonSettings); Assert.AreEqual(json, JsonConvert.SerializeObject(des, jsonSettings)); }
public void LessThanOrEqual() { var rootState = RandomState(); var def = new StateMachineDefinition <T, T>(rootState); var secondState = def.AddState(RandomState()); rootState.AddTransition(secondState, new CompareCondition <T, T>(EComparisonType.LessThanOrEqual, C(5))); var sm = def.CreateStateMachine(); sm.Step(C(10)); Assert.AreEqual(rootState.GUID, sm.CurrentState.GUID); sm.Reset(); sm.Step(C(5)); Assert.AreEqual(secondState.GUID, sm.CurrentState.GUID); sm.Reset(); sm.Step(C(1)); Assert.AreEqual(secondState.GUID, sm.CurrentState.GUID); }
public static void GenerateImplClass(StateMachineDefinition def, string path) { string newClassName = Path.GetFileNameWithoutExtension(path); string abstractClassName = def.name; Type baseType = GetType(def.baseClass); if (baseType.ContainsGenericParameters) { abstractClassName += "`1"; } string generated = string.Format(implClassTemplate, GetClassDeclaration(abstractClassName, newClassName), GetFunctionDeclarations(def, true)); StreamWriter outStream = new StreamWriter(path); outStream.Write(generated); outStream.Close(); AssetDatabase.Refresh(); }
public WorkFlowInstance startWorkFlow(CommandInfo CommandInfo) { WorkFlowInstance wfi = new WorkFlowInstance(); try { string WFName = CommandInfo.WFName.Trim(); TrackingWorkFlowInteraction twfi = new TrackingWorkFlowInteraction(); string id = twfi.startProcess(WFName); CommandInteraction cmdInteraction = new CommandInteraction(); Dictionary <string, string> paras = new Dictionary <string, string>(); paras.Add("InstanceId", id); paras.Add("WFName", CommandInfo.WFName); if (CommandInfo.ParameterList != null) { foreach (Parameter p in CommandInfo.ParameterList) { paras.Add(p.Name, p.Value); } } TrackingWorkFlowInteraction II = new TrackingWorkFlowInteraction(); StateMachineDefinition statemachineDefinition = II.getStateMachineDefinition(CommandInfo.WFName); paras.Add("QFEStatus", statemachineDefinition.InitialState); cmdInteraction.executeCommand(CommandInfo.CommandName, paras); wfi.Id = id; List <string> candCmds = twfi.getCandidateCommands(WFName, id); CandidateCommandList ccl = new CandidateCommandList(); ccl.AddRange(candCmds); wfi.CandidateCommandList = ccl; } catch (Exception e) { throw new WebFaultException <string>(e.ToString(), HttpStatusCode.InternalServerError); // TrackingLog.Log(e.Message + "!!" + e.ToString()); } return(wfi); }
public BaseSMTestClass() { Definition = new StateMachineDefinition(); Definition.GetOrCreateState("state1") .Setup(_ => _.StartPoint = true) .Action("TestInitAction"); Definition.GetOrCreateState("state2") .Action("TestActionSetPropTo2"); Definition.GetOrCreateState("state2_1"); Definition.GetOrCreateState("state3") .Setup(_ => _.EndPoint = true) .Action("TestAction") .Setup(_ => _.Order = 0) .SetParameter <string>("int", "10"); Definition.GetOrCreateTran("tran1", "state1", "state2") .Trigger("TestTrigger") .SetParameter <string>("TargetState", "state2"); Definition.GetOrCreateTran("tran2", "state2", "state3") .Trigger("TestTrigger") .SetParameter <string>("TargetState", "state3"); Definition.GetOrCreateTran("tran2_1", "state2", "state2_1") .Trigger("TestTrigger") .SetParameter <string>("TargetState", "state2_1"); Definition.GetOrCreateTran("tran2_11", "state2_1", "state3") .Trigger("TestTrigger") .SetParameter <string>("TargetState", "state3"); Definition.GetOrCreateTran("tran3", "state3", "state1") .Trigger("TestTrigger") .SetParameter <string>("TargetState", "state1"); }
public static string GetStateInitializer(StateMachineDefinition def, int index) { var state = def.states[index]; string variable = "state" + state.name; string str = " State " + variable + " = new State() {\n"; str += " id = StateID." + state.name + ",\n"; if (state.hasEnter) { str += " enter = StateEnter_" + state.name + ",\n"; } if (state.hasDuring) { str += " during = State_" + state.name + ",\n"; } if (state.hasExit) { str += " exit = StateExit_" + state.name + ",\n"; } if (state.hasChildren && def.GetChildren(state.name).Count > 0) { str += " subMachine = new SubStateMachine(),\n"; } str += " transitions = new List<Transition>(" + (state.transitions == null ? 0 : state.transitions.Count) + ")\n"; str += " };\n"; str += " allStates[" + index + "] = " + variable + ";\n"; str += "\n"; return(str); }
void OnGUI() { foreach (var obj in Selection.objects) { if (obj is StateMachineDefinition) { def = (StateMachineDefinition)obj; break; } } if (!Application.isPlaying) { ShowSidebar(); } Rect viewportRect = new Rect(0, 0, position.width - sideWidth, position.height); EditorGUI.DrawRect(viewportRect, bgColor); GUI.EndGroup(); Rect clippedArea = new Rect(0, 0, position.width - sideWidth, position.height); clippedArea.size /= zoom; clippedArea.y += editorWindowTabHeight / zoom; GUI.BeginGroup(clippedArea); bool repaint = false; if (def != null) { Event cur = Event.current; Matrix4x4 gm = GUI.matrix; GUI.matrix = Matrix4x4.Scale(new Vector3(zoom, zoom, 1)); UpdateView(ref repaint); if (!Application.isPlaying) { if (op != null) { if (def != op.definition) { op.Cancel(); op = null; } else { op.Update(); if (op.done) { op = null; repaint = true; EditorUtility.SetDirty(def); dirty = true; } } } else { var selected = def.SelectState(ToWorld(cur.mousePosition)); var selectedTr = def.SelectTransition(ToWorld(cur.mousePosition)); if (selectedTr.t1 == null) { if (selected != lastSelectedState) { repaint = true; lastSelectedState = selected; } if (lastSelectedTr != null) { lastSelectedTr = null; repaint = true; } } else { if (selectedTr.t2 != lastSelectedTr) { repaint = true; lastSelectedTr = selectedTr.t2; } if (lastSelectedState != null) { lastSelectedState = null; repaint = true; } } if (cur.type == EventType.MouseDown) { if (cur.button == 0) { if (selectedTr.t1 != null) { editingTransition = selectedTr; editingState = null; repaint = true; } else if (selected != null) { editingState = selected; editingTransition.t1 = null; editingTransition.t2 = null; repaint = true; if (cur.clickCount == 1) { op = new MoveStateOperation(def, this, selected); } else if (cur.clickCount == 2) { op = new RenameStateOperation(def, this, selected); } } else { editingState = null; editingTransition.t1 = null; editingTransition.t2 = null; repaint = true; } } else if (cur.button == 1) { if (selected == null && lastSelectedTr == null) { GenericMenu menu = new GenericMenu(); menu.AddItem(new GUIContent("Create State"), false, () => { var s = def.AddState(); s.position = ToWorld((cur.mousePosition - Vector2.up * editorWindowTabHeight) / zoom); MoveStateOperation.Snap(ref s.position); op = new RenameStateOperation(def, this, s); EditorUtility.SetDirty(def); dirty = true; }); GUI.EndGroup(); menu.ShowAsContext(); GUI.BeginGroup(clippedArea); } else if (selectedTr.t1 != null) { GenericMenu menu = new GenericMenu(); menu.AddItem(new GUIContent("Remove Transition"), false, () => { selectedTr.t1.RemoveTransition(selectedTr.t2); EditorUtility.SetDirty(def); dirty = true; repaint = true; }); GUI.EndGroup(); menu.ShowAsContext(); GUI.BeginGroup(clippedArea); } else if (selected != null) { GenericMenu menu = new GenericMenu(); menu.AddItem(new GUIContent("Delete State"), false, () => { def.RemoveState(selected); EditorUtility.SetDirty(def); dirty = true; repaint = true; }); menu.AddItem(new GUIContent("Rename State"), false, () => { op = new RenameStateOperation(def, this, selected); }); menu.AddItem(new GUIContent("Add Transition"), false, () => { op = new MakeTransitionOperation(def, this, selected); }); StateMachineDefinition.State parent = def.GetState(selected.parent); if (parent == null) { if (selected.name != def.defaultState) { menu.AddItem(new GUIContent("Make Default State"), false, () => { def.defaultState = selected.name; dirty = true; repaint = true; }); } } else { if (selected.name != parent.localDefault) { menu.AddItem(new GUIContent("Make Local Default"), false, () => { parent.localDefault = selected.name; dirty = true; repaint = true; }); } } if (selected.hasChildren) { menu.AddItem(new GUIContent("Remove Sub-Machine"), false, () => { def.RemoveSub(selected, MoveStateOperation.snap * 2); }); menu.AddItem(new GUIContent("Create Child State"), false, () => { var s = def.AddState(); s.position = ToWorld((cur.mousePosition - Vector2.up * editorWindowTabHeight) / zoom); def.SetStateParent(s, selected, MoveStateOperation.snap); MoveStateOperation.Snap(ref s.position); op = new RenameStateOperation(def, this, s); EditorUtility.SetDirty(def); dirty = true; }); } else { menu.AddItem(new GUIContent("Make Sub-Machine"), false, () => { def.CreateSub(selected, MoveStateOperation.snap * 2); }); } GUI.EndGroup(); menu.ShowAsContext(); GUI.BeginGroup(clippedArea); } } } } } if (Event.current.type != EventType.Repaint && (repaint || (op != null && op.repaint))) { Repaint(); } Handles.BeginGUI(); Handles.color = lineColor; Vector2 sz = scroll / zoom; for (float x = -sz.x % MoveStateOperation.snap; x < clippedArea.width; x += MoveStateOperation.snap) { Handles.DrawLine(new Vector3(x, 0), new Vector3(x, clippedArea.height)); } for (float y = -sz.y % MoveStateOperation.snap; y < clippedArea.height; y += MoveStateOperation.snap) { Handles.DrawLine(new Vector3(0, y), new Vector3(clippedArea.width, y)); } if (Application.isPlaying) { if (observing == null || observing.gameObject != Selection.activeGameObject) { if (Selection.activeGameObject) { observing = Selection.activeGameObject.GetComponent <StateMachine>(); } if (observing == null) { observing = (StateMachine)FindObjectOfType(typeof(StateMachine).Assembly.GetType(def.name)); } } } else if (!Application.isPlaying) { observing = null; } Color oldColor = GUI.color; if (def.states != null) { foreach (var state in def.states) { if (op == null || op.state != state || op.showBaseGUI) { string s = state.name; var parent = def.GetState(state.parent); if (parent == null && def.defaultState == s) { s += "\n<default state>"; } else if (parent != null && parent.localDefault == s) { s += "\n<local default>"; } Rect rect = state.rect; rect.position = ToScreen(rect.position); GUI.SetNextControlName("StateButton"); if (observing && cur.type == EventType.Repaint) { if (observing.IsStateActive(state.name)) { GUI.color = new Color(0.5f, 0.7f, 1.0f); } else if (observing.IsStateRemembered(state.name)) { GUI.color = new Color(0.9f, 0.8f, 1.0f); } else { GUI.color = oldColor; } } if (!state.hasChildren) { if (state != editingState) { GUI.Button(rect, s); } else { GUI.Button(rect, ""); var style = new GUIStyle(GUI.skin.label); style.alignment = TextAnchor.MiddleCenter; style.normal.textColor = Color.blue; style.fontStyle = FontStyle.Bold; GUI.Label(rect, s, style); } } else { GUI.Button(rect, ""); var style = new GUIStyle(GUI.skin.label); style.alignment = TextAnchor.UpperCenter; if (state == editingState) { style.normal.textColor = Color.blue; style.fontStyle = FontStyle.Bold; } GUI.Label(rect, s, style); Rect innerRect = rect; innerRect.xMin += 4; innerRect.xMax -= 4; innerRect.yMin += 32; innerRect.yMax -= 4; GUI.color = oldColor; EditorGUI.DrawRect(innerRect, bgColor); Handles.color = lineColor; for (float x = rect.xMin + MoveStateOperation.snap; x < rect.xMax; x += MoveStateOperation.snap) { Handles.DrawLine(new Vector3(x, innerRect.yMin), new Vector3(x, innerRect.yMax)); } for (float y = rect.yMin + MoveStateOperation.snap * 2; y < rect.yMax; y += MoveStateOperation.snap) { Handles.DrawLine(new Vector3(innerRect.xMin, y), new Vector3(innerRect.xMax, y)); } } } if (op != null && op.state == state) { op.OnGUI(); } } foreach (var from in def.states) { if (from.transitions != null) { foreach (var tr in from.transitions) { if (Application.isPlaying) { Handles.color = Color.black; if (observing) { float t = Time.unscaledTime - observing.TransitionLastTime(from.name, tr.to); if (t < 0.5f) { Handles.color = Color.Lerp(Color.black, Color.green, 1.0f - t * 2); } } } else { if (tr != lastSelectedTr && tr != editingTransition.t2) { Handles.color = Color.black; } else { Handles.color = Color.blue; } } if (def.GetState(tr.to) != null) { var line = def.GetTransitionPoints(from, tr); Vector2 src = ToScreen(line.t1); Vector2 dest = ToScreen(line.t2); Vector2 v = (dest - src).normalized; Vector2 ortho = new Vector2(v.y, -v.x); Vector2 arrow = ortho - v; Vector2 mid = (src + dest) / 2; Handles.DrawAAPolyLine(3, src, dest); Handles.DrawAAPolyLine(3, mid + v * 5, mid + arrow * 6); } } } } } Handles.EndGUI(); GUI.matrix = gm; } else if (op != null) { op.Cancel(); op = null; } }
public MakeTransitionOperation(StateMachineDefinition def, StateMachineEditorWindow window, StateMachineDefinition.State state) : base(def, window, state) { showBaseGUI = true; }
public Operation(StateMachineDefinition definition, StateMachineEditorWindow window, StateMachineDefinition.State state) { this.definition = definition; this.state = state; this.window = window; }
public StateMachineDefinition getStateMachineDefinition(string WFName) { StateMachineDefinition definition = new StateMachineDefinition(); Assembly trackingWorkFlowAssembly = Assembly.Load("TrackingWorkFlow"); Type[] types = trackingWorkFlowAssembly.GetTypes(); Type target = trackingWorkFlowAssembly.GetType("TrackingWorkFlow.TrackingWorkFlow"); foreach (Type type in types) { if (type.IsSubclassOf(target) && type.Name.Equals(WFName, StringComparison.InvariantCultureIgnoreCase)) { Type tt = typeof(Boolean); ConstructorInfo ci = type.GetConstructor(new Type[] { tt }); using (TrackingWorkFlow twf = (TrackingWorkFlow)(ci.Invoke(new object[] { false }))) { Activity workflowDefinition = twf.app.WorkflowDefinition; string stateMachineActivityName = twf.app.WorkflowDefinition.DisplayName; string[] resources = workflowDefinition.GetType().Assembly.GetManifestResourceNames(); string resourceName = null; for (int i = 0; (i < resources.Length); i = (i + 1)) { resourceName = resources[i]; if ((resourceName.Contains("." + stateMachineActivityName + ".g.xaml") || resourceName.Equals(stateMachineActivityName + ".g.xaml"))) { break; } } System.IO.Stream initializeXaml = typeof(SESampleProcess2).Assembly.GetManifestResourceStream(resourceName); XmlDocument xDoc = new XmlDocument(); xDoc.Load(initializeXaml); XmlElement root = xDoc.DocumentElement; string documentNameSpace = xDoc.NamespaceURI; string nameSpace = root.NamespaceURI; string xmlns = root.Attributes["xmlns"].Value; XmlNamespaceManager nsmgr = new XmlNamespaceManager(xDoc.NameTable); nsmgr.AddNamespace(root.Prefix, nameSpace); nsmgr.AddNamespace("default", xmlns); nsmgr.AddNamespace("x", "http://schemas.microsoft.com/winfx/2006/xaml"); nsmgr.AddNamespace("av", "http://schemas.microsoft.com/winfx/2006/xaml/presentation"); nsmgr.AddNamespace("sap", "http://schemas.microsoft.com/netfx/2009/xaml/activities/presentation"); //av xmlns:av="http://schemas.microsoft.com/winfx/2006/xaml/presentation" //xmlns:sap="http://schemas.microsoft.com/netfx/2009/xaml/activities/presentation" XmlNode stateMachineNode = root.SelectSingleNode(".//default:StateMachine", nsmgr); XmlNode initialStateNode = stateMachineNode.SelectSingleNode(".//default:StateMachine.InitialState/default:State", nsmgr); definition.InitialState = initialStateNode.Attributes["DisplayName"].Value; //definition.InitialState = initialStateNode; XmlNodeList states = root.SelectNodes(".//default:State", nsmgr); //XmlNodeList transitions = root.SelectNodes(".//default:Transition", nsmgr); if (states != null) { foreach (XmlNode node in states) { State state = new State(); string displayName = node.Attributes["DisplayName"].Value; state.Name = displayName; definition.StateList.Add(state); XmlNode point = node.SelectSingleNode("./sap:WorkflowViewStateService.ViewState/*/av:Point", nsmgr); string shapeLocation = point.InnerText; string[] location = shapeLocation.Split(','); state.x = double.Parse(location[0]); state.y = double.Parse(location[1]); /* * <sap:WorkflowViewStateService.ViewState> * <scg3:Dictionary x:TypeArguments="x:String, x:Object"> * <av:Point x:Key="ShapeLocation">33,79.5</av:Point> * <av:Size x:Key="ShapeSize">153,90</av:Size> * <x:Boolean x:Key="IsPinned">False</x:Boolean> * <x:Double x:Key="StateContainerWidth">139</x:Double> * <x:Double x:Key="StateContainerHeight"> * 54.326666666666654</x:Double> * </scg3:Dictionary> * </sap:WorkflowViewStateService.ViewState>*/ XmlNodeList transitions = node.SelectNodes("./default:State.Transitions/default:Transition", nsmgr); if (transitions != null) { foreach (XmlNode tNode in transitions) { Transition t = new Transition(); t.Name = tNode.Attributes["DisplayName"].Value; t.From = state.Name; XmlNode transitionTo = tNode.SelectSingleNode("./default:Transition.To", nsmgr); XmlNode transitionToState = transitionTo.SelectSingleNode("./default:State", nsmgr); if (transitionToState != null) { string toStateName = transitionToState.Attributes["DisplayName"].Value; t.To = toStateName; } else { XmlNode referenceNode = transitionTo.SelectSingleNode("./x:Reference", nsmgr); foreach (XmlNode stateNode in states) { string xName = stateNode.Attributes["x:Name"].Value; if (xName.Equals(referenceNode.InnerText, StringComparison.InvariantCultureIgnoreCase)) { string toStateName = stateNode.Attributes["DisplayName"].Value; t.To = toStateName; } } //transitionToState = tNode.SelectSingleNode("./default:Transition.To/default:State", nsmgr); } definition.TransitionList.Add(t); } } } } //if (transitions != null) //{ // foreach (XmlNode node in transitions) // { // definition.TransitionList.Add(new Transition()); // } //} } //WorkFlowDefinition WFD = new WorkFlowDefinition(); //WFD.WFName = t.Name; } } return(definition); }
public RenameStateOperation(StateMachineDefinition def, StateMachineEditorWindow window, StateMachineDefinition.State state) : base(def, window, state) { name = state.name; showBaseGUI = false; }
public StateMachineDefinition getStateMachineDefinition(string WFName) { StateMachineDefinition definition = new StateMachineDefinition(); Assembly trackingWorkFlowAssembly = Assembly.Load("TrackingWorkFlow"); Type[] types = trackingWorkFlowAssembly.GetTypes(); Type target = trackingWorkFlowAssembly.GetType("TrackingWorkFlow.TrackingWorkFlow"); foreach (Type type in types) { if (type.IsSubclassOf(target)&&type.Name.Equals(WFName,StringComparison.InvariantCultureIgnoreCase)) { Type tt = typeof(Boolean); ConstructorInfo ci = type.GetConstructor(new Type[] { tt }); using (TrackingWorkFlow twf = (TrackingWorkFlow)(ci.Invoke(new object[] { false }))) { Activity workflowDefinition = twf.app.WorkflowDefinition; string stateMachineActivityName=twf.app.WorkflowDefinition.DisplayName; string[] resources = workflowDefinition.GetType().Assembly.GetManifestResourceNames(); string resourceName = null; for (int i = 0; (i < resources.Length); i = (i + 1)) { resourceName = resources[i]; if ((resourceName.Contains("."+stateMachineActivityName+".g.xaml") || resourceName.Equals(stateMachineActivityName+".g.xaml"))) { break; } } System.IO.Stream initializeXaml = typeof(SESampleProcess2).Assembly.GetManifestResourceStream(resourceName); XmlDocument xDoc = new XmlDocument(); xDoc.Load(initializeXaml); XmlElement root = xDoc.DocumentElement; string documentNameSpace = xDoc.NamespaceURI; string nameSpace = root.NamespaceURI; string xmlns = root.Attributes["xmlns"].Value; XmlNamespaceManager nsmgr = new XmlNamespaceManager(xDoc.NameTable); nsmgr.AddNamespace(root.Prefix, nameSpace); nsmgr.AddNamespace("default", xmlns); nsmgr.AddNamespace("x", "http://schemas.microsoft.com/winfx/2006/xaml"); nsmgr.AddNamespace("av","http://schemas.microsoft.com/winfx/2006/xaml/presentation"); nsmgr.AddNamespace("sap", "http://schemas.microsoft.com/netfx/2009/xaml/activities/presentation"); //av xmlns:av="http://schemas.microsoft.com/winfx/2006/xaml/presentation" //xmlns:sap="http://schemas.microsoft.com/netfx/2009/xaml/activities/presentation" XmlNode stateMachineNode = root.SelectSingleNode(".//default:StateMachine", nsmgr); XmlNode initialStateNode = stateMachineNode.SelectSingleNode(".//default:StateMachine.InitialState/default:State", nsmgr); definition.InitialState=initialStateNode.Attributes["DisplayName"].Value; //definition.InitialState = initialStateNode; XmlNodeList states = root.SelectNodes(".//default:State", nsmgr); //XmlNodeList transitions = root.SelectNodes(".//default:Transition", nsmgr); if (states != null) { foreach (XmlNode node in states) { State state = new State(); string displayName=node.Attributes["DisplayName"].Value; state.Name = displayName; definition.StateList.Add(state); XmlNode point=node.SelectSingleNode("./sap:WorkflowViewStateService.ViewState/*/av:Point", nsmgr); string shapeLocation = point.InnerText; string[] location = shapeLocation.Split(','); state.x = double.Parse(location[0]); state.y = double.Parse(location[1]); /* <sap:WorkflowViewStateService.ViewState> <scg3:Dictionary x:TypeArguments="x:String, x:Object"> <av:Point x:Key="ShapeLocation">33,79.5</av:Point> <av:Size x:Key="ShapeSize">153,90</av:Size> <x:Boolean x:Key="IsPinned">False</x:Boolean> <x:Double x:Key="StateContainerWidth">139</x:Double> <x:Double x:Key="StateContainerHeight"> 54.326666666666654</x:Double> </scg3:Dictionary> </sap:WorkflowViewStateService.ViewState>*/ XmlNodeList transitions = node.SelectNodes("./default:State.Transitions/default:Transition", nsmgr); if (transitions != null) { foreach (XmlNode tNode in transitions) { Transition t = new Transition(); t.Name=tNode.Attributes["DisplayName"].Value; t.From = state.Name; XmlNode transitionTo=tNode.SelectSingleNode("./default:Transition.To",nsmgr); XmlNode transitionToState = transitionTo.SelectSingleNode("./default:State", nsmgr); if (transitionToState != null) { string toStateName = transitionToState.Attributes["DisplayName"].Value; t.To = toStateName; } else { XmlNode referenceNode = transitionTo.SelectSingleNode("./x:Reference", nsmgr); foreach (XmlNode stateNode in states) { string xName = stateNode.Attributes["x:Name"].Value; if (xName.Equals(referenceNode.InnerText, StringComparison.InvariantCultureIgnoreCase)) { string toStateName = stateNode.Attributes["DisplayName"].Value; t.To = toStateName; } } //transitionToState = tNode.SelectSingleNode("./default:Transition.To/default:State", nsmgr); } definition.TransitionList.Add(t); } } } } //if (transitions != null) //{ // foreach (XmlNode node in transitions) // { // definition.TransitionList.Add(new Transition()); // } //} } //WorkFlowDefinition WFD = new WorkFlowDefinition(); //WFD.WFName = t.Name; } } return definition; }
public StateMachine(StateMachineDefinition definition, object callbackObject) { this.definition = definition; this.callbackObject = callbackObject; foreach (var keyVal in this.definition.states) { var stateObj = new State(keyVal.Value) { Name = keyVal.Key }; if (keyVal.Value.isDefault) { this.MoveState(stateObj); } this.states.Add(keyVal.Key, stateObj); } var methodDict = new Dictionary <string, MethodInfo>(); var methods = callbackObject.GetType().GetMethods(); foreach (var meth in methods) { if (meth.DeclaringType != typeof(Object)) { methodDict.Add(meth.Name, meth); } } foreach (var trans in this.definition.transitions) { var toState = this.states[trans.to]; var fromState = this.states[trans.from]; var transObj = new Transition() { eventName = trans.eventName, toState = toState, fromState = fromState, Parent = this }; foreach (var methName in trans.actions) { var info = methodDict[methName]; transObj.actions.Add(delegate { info.Invoke(callbackObject, new object[0]); }); } fromState.Transitions.Add(transObj); List <Transition> transList; if (this.eventMap.TryGetValue(trans.eventName, out transList)) { transList.Add(transObj); } else { List <Transition> list = new List <Transition>(); list.Add(transObj); this.eventMap.Add(trans.eventName, list); } } this._thread = new Thread(this._think); this._thread.Start(); }