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