protected void AnalyseAction(IStateGlyph state, string actions)
{
if (IsNotEmptyString (actions))
{
string[] names = ParseNames (actions);
}
}
protected void AnalyseAction(IStateGlyph state, string actions)
{
if (IsNotEmptyString(actions))
{
string[] names = ParseNames(actions);
}
}
public bool IsProperInnerTransition()
{
bool sameState = true;
IStateGlyph lastState = null;
foreach (IGlyph contact in ContactPoints)
{
IStateGlyph state = contact.Parent as IStateGlyph;
if (lastState == null)
{
lastState = state;
}
if (lastState != state)
{
sameState = false;
break;
}
lastState = state;
}
if (sameState)
{
if (IsInnerTransition)
{
return(true);
}
}
return(false);
}
void DoNewTransitionList(IStateGlyph state, ArrayList transitionList)
{
if (NewTransitionList != null)
{
NewTransitionList(this, new TransitionListEventArgs(state, transitionList));
}
}
protected string StateNameFrom(IStateGlyph state)
{
string name = state.FullyQualifiedStateName;
name = name.Replace(".", "_");
return(name);
}
protected ArrayList GetTransitionList(IStateGlyph state)
{
ArrayList transitionList = new ArrayList();
GetTransitionList(transitionList, state);
return(transitionList);
}
public TransitionInfo(ITransitionGlyph trans, string fromStateName, string toStateName, IStateGlyph toStateGlyph)
{
Transition = trans;
FromStateName = fromStateName;
ToStateName = toStateName;
ToStateGlyph = toStateGlyph;
}
public void Visit(ITransitionGlyph transition)
{
WriteDefaults(transition);
_Writer.WriteElementString("EventSignal", transition.EventSignal);
_Writer.WriteElementString("EventSource", transition.EventSource);
_Writer.WriteElementString("GuardCondition", transition.GuardCondition);
_Writer.WriteElementString("Action", transition.Action);
_Writer.WriteElementString("EvaluationOrderPriority", transition.EvaluationOrderPriority.ToString());
_Writer.WriteElementString("EventType", transition.EventType);
_Writer.WriteElementString("IsInnerTransition", transition.IsInnerTransition.ToString().ToLower());
_Writer.WriteElementString("TimeOutExpression", transition.TimeOutExpression);
_Writer.WriteElementString("TransitionType", transition.TransitionType.ToString());
foreach (ITransitionContactPointGlyph contactPoint in transition.ContactPoints)
{
if (contactPoint.Parent != null)
{
IStateGlyph state = contactPoint.Parent as IStateGlyph;
System.Diagnostics.Debug.Assert(state != null);
_Writer.WriteStartElement("State");
try
{
_Writer.WriteElementString("Id", state.Id);
_Writer.WriteElementString("Name", state.Name);
}
finally
{
_Writer.WriteEndElement();
}
}
}
}
private string GetStateName(IStateGlyph stateGlyph)
{
string sname = "S_" + stateGlyph.FullyQualifiedStateName;
sname = sname.Replace(".", "_");
return(sname);
}
protected override bool AcceptParentInFullyQualifiedName(IGlyph glyph)
{
System.Diagnostics.Debug.Assert(glyph != null);
IStateGlyph state = glyph as IStateGlyph;
System.Diagnostics.Debug.Assert(state != null);
return(!state.IsOverriding);
}
protected string OuterMostStateName()
{
IStateGlyph state = OuterMostState();
if (state != null)
{
return(StateNameFrom(state));
}
return("NO_STATE_AT_OUTER_LEVEL_MARKED_AS_START_STATE");
}
protected void UpdateAllParentsDeepHistory()
{
IStateGlyph state = _CurrentState;
while (state != null)
{
_DeepHistory [state] = _CurrentState;
state = state.Parent as IStateGlyph;
}
}
protected bool StateHasAfterTransitions(IStateGlyph state)
{
foreach (TransitionInfo transInfo in GetTransitionList(state))
{
if (IsNotEmptyString(transInfo.Transition.TimeOutExpression))
{
return(true);
}
}
return(false);
}
protected bool StateOrParentHasDeepHistoryTransition(IStateGlyph state)
{
while (state != null)
{
if (_StatesWithHistoryTransitions.Contains(state))
{
return(true);
}
state = state.Parent as IStateGlyph;
}
return(false);
}
protected bool StateHasAsAnyParent(IStateGlyph state, IStateGlyph possibleParentState)
{
while (state != null)
{
if (state.Parent == possibleParentState)
{
return(true);
}
state = state.Parent as IStateGlyph;
}
return(false);
}
protected ArrayList GetStateAfterTransitions(IStateGlyph state)
{
ArrayList list = new ArrayList ();
foreach (TransitionInfo transInfo in GetTransitionList (state))
{
if (IsNotEmptyString (transInfo.Transition.TimeOutExpression))
{
list.Add (transInfo.Transition);
}
}
return list;
}
protected void RefreshCurrentStateView(string qhsmName, string currentTransitionName)
{
ClearCurrentStateView();
foreach (IGlyph glyph in _View.StateControl.Model.Glyphs)
{
if (currentTransitionName == null)
{
IStateGlyph stateGlyph = glyph as IStateGlyph;
if (stateGlyph != null)
{
if (qhsmName == GetStateName(stateGlyph))
{
stateGlyph.Selected = true;
}
}
}
else
{
ITransitionGlyph trans = glyph as ITransitionGlyph;
if (trans != null)
{
string sx = trans.FullyQualifiedStateName;
foreach (IGlyph owned in trans.OwnedItems)
{
IStateGlyph sg = owned.Parent as IStateGlyph;
if (sg != null)
{
if (GetStateName(sg) == qhsmName)
{
string transName = trans.CompleteEventText(true, true);
if (trans.Action != "")
{
transName = transName + "/" + trans.Action;
}
if (transName == currentTransitionName)
{
trans.Selected = true;
_View.StateControl.RefreshView();
if (_TransitionDelay > 0)
{
System.Threading.Thread.Sleep(TimeSpan.FromMilliseconds(_TransitionDelay));
}
}
}
}
break;
}
}
}
}
_View.StateControl.RefreshView();
}
protected ArrayList GetStateAfterTransitions(IStateGlyph state)
{
ArrayList list = new ArrayList();
foreach (TransitionInfo transInfo in GetTransitionList(state))
{
if (IsNotEmptyString(transInfo.Transition.TimeOutExpression))
{
list.Add(transInfo.Transition);
}
}
return(list);
}
public void Start()
{
Prepare();
IStateGlyph state = OuterMostState();
if (state == null)
{
throw new Exception("No parent start state found!");
}
CurrentState = state;
DoRefresh();
}
protected ArrayList GetStateOrParentsThatHasDeepHistoryTransition(IStateGlyph state)
{
ArrayList list = new ArrayList ();
while (state != null)
{
if (_StatesWithHistoryTransitions.Contains (state))
{
list.Add (state);
}
state = state.Parent as IStateGlyph;
}
return list;
}
public int Compare(object x, object y)
{
/// State ahead of Transition
///
/// State sorted in Parent Depth order
/// Same Depth - sort by name
///
/// Transition sorted by event
if (x == y)
{
return(0);
}
if (x is IStateGlyph && y is IStateGlyph)
{
IStateGlyph X = x as IStateGlyph;
IStateGlyph Y = y as IStateGlyph;
int overrideComp = X.IsOverriding.CompareTo(Y.IsOverriding);
if (overrideComp == 0)
{
string xname = X.FullyQualifiedStateName;
string yname = Y.FullyQualifiedStateName;
return(xname.CompareTo(yname));
}
else
{
return(overrideComp);
}
}
else if (x is ITransitionGlyph && y is ITransitionGlyph)
{
ITransitionGlyph X = x as ITransitionGlyph;
ITransitionGlyph Y = y as ITransitionGlyph;
string xevent = X.Event != null ? X.Event : "";
string yevent = Y.Event != null ? Y.Event : "";
return(xevent.CompareTo(yevent));
}
else
{
if (x is IStateGlyph) // states to front of list
{
return(-1);
}
else
{
return(1);
}
}
}
protected ArrayList GetStateOrParentsThatHasDeepHistoryTransition(IStateGlyph state)
{
ArrayList list = new ArrayList();
while (state != null)
{
if (_StatesWithHistoryTransitions.Contains(state))
{
list.Add(state);
}
state = state.Parent as IStateGlyph;
}
return(list);
}
protected virtual void PrepareGlyphs()
{
_Glyphs = (ArrayList)_SourceGlyphs.Clone();
_Glyphs.Sort(new ConvertToCodeGlyphSorter());
_States = new ArrayList();
_Transitions = new ArrayList();
_Ports = new ArrayList();
foreach (IGlyph glyph in _Glyphs)
{
IStateGlyph state = glyph as IStateGlyph;
if (state != null)
{
_States.Add(state);
}
ITransitionGlyph trans = glyph as ITransitionGlyph;
if (trans != null)
{
_Transitions.Add(trans);
}
IStateTransitionPortGlyph port = glyph as IStateTransitionPortGlyph;
if (port != null)
{
_Ports.Add(port);
}
}
_StatesWithHistoryTransitions = new Hashtable();
foreach (IStateGlyph state in _States)
{
foreach (TransitionInfo info in GetTransitionList(state))
{
if (info.Transition.TransitionType == TransitionType.History)
{
throw new NotImplementedException("History not yet implemented");
}
if (info.Transition.TransitionType == TransitionType.DeepHistory)
{
IStateGlyph historyKeeper = info.ToStateGlyph;
if (!_StatesWithHistoryTransitions.Contains(historyKeeper))
{
_StatesWithHistoryTransitions.Add(historyKeeper, info);
}
}
}
}
}
void LoadStateGlyph(TextReader sr)
{
string id;
int X, Y, width, height;
LoadBounds(sr, out id, out X, out Y, out width, out height);
string parentId = NextLine(sr);
if (parentId != "NOPARENT")
{
_ParentChildRel [id] = parentId;
}
IStateGlyph glyph = _Factory.CreateState(id, new Rectangle(X, Y, width, height));
LoadGlyphCommon(sr, glyph);
IStateGlyph state = glyph;
state.Name = LoadText(sr, "NAME");
string isStart = LoadText(sr, "ISSTARTSTATE");
state.IsStartState = bool.Parse(isStart);
string isFinal = LoadText(sr, "ISFINALSTATE", false.ToString());
state.IsFinalState = bool.Parse(isFinal);
state.EntryAction = LoadText(sr, "ENTRY");
state.ExitAction = LoadText(sr, "EXIT");
state.DoAction = LoadText(sr, "DO");
string isOverriding = LoadText(sr, "ISOVERRIDING");
state.IsOverriding = bool.Parse(isOverriding);
string cmds = LoadText(sr, "STATECOMMANDS", "");
state.StateCommands.Clear();
cmds = cmds.Trim();
if (cmds != null && cmds.Trim() != "")
{
string[] commandsArray = cmds.Split(';');
state.StateCommands.AddRange(commandsArray);
}
// kludge - when stringcollection displayed in propertygrid - cannot create new string instances - so adding 10 by default (beyond what is already there).
state.StateCommands.AddRange(new string[] { "", "", "", "", "", "", "", "", "", "" });
BlankLine(sr); // blank line
_GlyphLookup.Add(id, glyph);
_Glyphs.Add(glyph);
}
protected void CreateNewTransitionList(IStateGlyph state)
{
ArrayList list = new ArrayList();
while (state != null)
{
GetTransitionList(list, state);
IGlyph parent = state.Parent;
state = parent as IStateGlyph;
if (parent != null)
{
System.Diagnostics.Debug.Assert(state != null);
}
}
_TransitionList = list;
DoNewTransitionList(_CurrentState, list);
}
protected void AnalyseTransition(IStateGlyph state, ArrayList groupedTransitionList)
{
foreach (TransitionInfo transInfo in groupedTransitionList)
{
ITransitionGlyph trans = transInfo.Transition;
if (HasGuardCondition (trans))
{
AnalyseGuardAction (state, trans, trans.GuardCondition);
}
if (IsNotEmptyString (trans.Action))
{
AnalyseAction (state, trans, trans.Action);
}
}
}
protected void AnalyseTransition(IStateGlyph state, ArrayList groupedTransitionList)
{
foreach (TransitionInfo transInfo in groupedTransitionList)
{
ITransitionGlyph trans = transInfo.Transition;
if (HasGuardCondition(trans))
{
AnalyseGuardAction(state, trans, trans.GuardCondition);
}
if (IsNotEmptyString(trans.Action))
{
AnalyseAction(state, trans, trans.Action);
}
}
}
protected void GetTransitionList(ArrayList transitionList, IStateGlyph state)
{
// now find transitions
foreach (IGlyph child in state.Children)
{
ITransitionContactPointGlyph transContactPoint = child as ITransitionContactPointGlyph;
if (transContactPoint != null)
{
ITransitionGlyph trans = transContactPoint.Owner as ITransitionGlyph;
if (transContactPoint.WhichEnd == TransitionContactEnd.From)
{
// this is a from transition
ITransitionContactPointGlyph transTo = null;
foreach (ITransitionContactPointGlyph contactPoint in trans.ContactPoints)
{
if (contactPoint.WhichEnd == TransitionContactEnd.To)
{
transTo = contactPoint;
break;
}
}
System.Diagnostics.Debug.Assert(transTo != null, "Transition To Contact Point not found");
IStateGlyph toStateGlyph = transTo.Parent as IStateGlyph;
string toStateName = "TRANSITION_TOSTATE_NOT_SET";
if (toStateGlyph != null)
{
if (IsNotEmptyString(toStateGlyph.Name))
{
toStateName = StateNameFrom(toStateGlyph);
}
else
{
toStateName = "TRANSITION_TOSTATE_SET_BUT_STATE_NOT_NAMED";
}
}
TransitionInfo info = new TransitionInfo(trans, StateNameFrom(state), toStateName, toStateGlyph);
transitionList.Add(info);
}
}
}
}
protected bool StepNextEvent()
{
if (_EventQueue.Count == 0)
{
DoNoEvents();
return(false);
}
string eventName = _EventQueue.Dequeue() as string;
foreach (TransitionInfo info in _TransitionList)
{
if (info.Transition.Event == eventName)
{
DoTransitionEvent(eventName);
switch (info.Transition.TransitionType)
{
case TransitionType.History:
{
throw new NotSupportedException("History not supported");
} break;
case TransitionType.DeepHistory:
{
IStateGlyph toState = _DeepHistory [info.ToStateGlyph] as IStateGlyph;
if (toState == null)
{
toState = info.ToStateGlyph;
}
CurrentState = toState;
} break;
default:
{
CurrentState = info.ToStateGlyph;
} break;
}
return(true);
}
}
DoDropEvent(eventName);
return(false);
}
bool FindInnerStartState()
{
if (CurrentState == null)
{
return(false);
}
foreach (IGlyph glyph in CurrentState.Children)
{
IStateGlyph state = glyph as IStateGlyph;
if (state != null && state.IsStartState)
{
CurrentState = state;
return(true);
}
}
return(false);
}
protected void DrawContactPoints(IGraphicsContext GC, bool isOk, bool usePrimary, Color primary, out Color fromColor, out Color toColor)
{
fromColor = primary;
toColor = primary;
foreach (ITransitionContactPointGlyph contact in ContactPoints)
{
switch (contact.WhichEnd)
{
case TransitionContactEnd.From: GC.Thickness = 3; break;
case TransitionContactEnd.To: GC.Thickness = 5; break;
default: throw new NotSupportedException("Unknown TransitionContactEnd: " + contact.WhichEnd.ToString());
}
IStateGlyph state = contact.Parent as IStateGlyph;
if (usePrimary == false && state != null)
{
if (isOk)
{
switch (contact.WhichEnd)
{
case TransitionContactEnd.From: fromColor = state.StateColor; break;
case TransitionContactEnd.To: toColor = state.StateColor; break;
default: throw new NotSupportedException("Unknown TransitionContactEnd: " + contact.WhichEnd.ToString());
}
}
GC.Color = state.StateColor;
}
else
{
GC.Color = primary;
}
if (usePrimary)
{
fromColor = primary;
toColor = primary;
}
contact.Draw(GC);
}
}
public void Visit(IStateGlyph state)
{
WriteDefaults(state);
_Writer.WriteElementString("IsStartState", state.IsStartState.ToString().ToLower());
_Writer.WriteElementString("EntryAction", state.EntryAction);
_Writer.WriteElementString("ExitAction", state.ExitAction);
_Writer.WriteStartElement("StateCommands");
try
{
foreach (string cmd in state.StateCommands)
{
if (cmd != null && cmd.Trim().Length > 0)
{
_Writer.WriteElementString("Command", cmd);
}
}
}
finally
{
_Writer.WriteEndElement();
}
}
void SaveStateGlyph(TextWriter sw, IStateGlyph glyph)
{
SaveBounds(sw, "STATE:", glyph);
if (glyph.Parent != null)
{
sw.WriteLine(glyph.Parent.Id);
}
else
{
sw.WriteLine("NOPARENT");
}
SaveGlyphCommon(sw, glyph);
IStateGlyph state = glyph;
SaveText(sw, "NAME", state.Name);
SaveText(sw, "ISSTARTSTATE", state.IsStartState.ToString());
SaveText(sw, "ISFINALSTATE", state.IsFinalState.ToString());
SaveText(sw, "ENTRY", state.EntryAction);
SaveText(sw, "EXIT", state.ExitAction);
SaveText(sw, "DO", state.DoAction);
SaveText(sw, "ISOVERRIDING", state.IsOverriding.ToString());
ArrayList commandList = new ArrayList();
foreach (string commandName in state.StateCommands)
{
if (commandName != null && commandName.Trim() != "")
{
commandList.Add(commandName);
}
}
string[] commandsArray = (string[])commandList.ToArray(typeof(string));
string cmds = string.Join(";", commandsArray);
SaveTextIfNotDefault(sw, "STATECOMMANDS", cmds, "");
}
public void Visit(IStateGlyph state)
{
WriteDefaults (state);
_Writer.WriteElementString ("IsStartState", state.IsStartState.ToString ());
_Writer.WriteElementString ("EntryAction", state.EntryAction);
_Writer.WriteElementString ("ExitAction", state.ExitAction);
_Writer.WriteStartElement ("StateCommands");
try
{
foreach (string cmd in state.StateCommands)
{
if (cmd != null && cmd.Trim ().Length > 0)
{
_Writer.WriteElementString ("Command", cmd);
}
}
}
finally
{
_Writer.WriteEndElement ();
}
}
public override void KeyUp(object sender, KeyEventArgs e)
{
if (_LastSelectedGlyph == null)
{
return;
}
if (_Model.IsStateGlyph(_LastSelectedGlyph))
{
if (IsControlKey(e, Keys.T)) // Toggle Start State
{
IStateGlyph stateGlyph = _LastSelectedGlyph as IStateGlyph;
stateGlyph.IsStartState = !stateGlyph.IsStartState;
}
if (IsControlKey(e, Keys.N)) // name
{
_LastSelectedGlyph.Name = InputDialog.Execute(_Context.ParentStateDiagramView, "State Property Input", "State Name", _LastSelectedGlyph.Name);
}
else if (IsControlKey(e, Keys.E)) // entry action
{
IStateGlyph stateGlyph = _LastSelectedGlyph as IStateGlyph;
stateGlyph.EntryAction = InputDialog.Execute(_Context.ParentStateDiagramView, "State Property Input", "State Entry Action", stateGlyph.EntryAction);
}
else if (IsControlKey(e, Keys.X)) // exit action
{
IStateGlyph stateGlyph = _LastSelectedGlyph as IStateGlyph;
stateGlyph.ExitAction = InputDialog.Execute(_Context.ParentStateDiagramView, "State Property Input", "State Exit Action", stateGlyph.ExitAction);
}
else if (IsControlKey(e, Keys.F))
{
IStateGlyph stateGlyph = _LastSelectedGlyph as IStateGlyph;
stateGlyph.IsFinalState = !stateGlyph.IsFinalState;
}
}
else if (_Model.IsTransitionGlyph(_LastSelectedGlyph))
{
if (IsControlKey(e, Keys.N))
{
_LastSelectedGlyph.Name = InputDialog.Execute(_Context.ParentStateDiagramView, "Transition Property Input", "Transition Name", _LastSelectedGlyph.Name);
}
else if (IsControlKey(e, Keys.V))
{
ITransitionGlyph transitionGlyph = _LastSelectedGlyph as ITransitionGlyph;
transitionGlyph.EventSignal = InputDialog.Execute(_Context.ParentStateDiagramView, "Transition Property Input", "Transition Event Signal", transitionGlyph.EventSignal);
}
else if (IsControlKey(e, Keys.K))
{
ITransitionGlyph transitionGlyph = _LastSelectedGlyph as ITransitionGlyph;
transitionGlyph.EventSource = InputDialog.Execute(_Context.ParentStateDiagramView, "Transition Property Input", "Transition Event Source", transitionGlyph.EventSource);
}
else if (IsControlKey(e, Keys.G))
{
ITransitionGlyph transitionGlyph = _LastSelectedGlyph as ITransitionGlyph;
transitionGlyph.GuardCondition = InputDialog.Execute(_Context.ParentStateDiagramView, "Transition Property Input", "Transition Event Guard Condition", transitionGlyph.GuardCondition);
}
else if (IsControlKey(e, Keys.A))
{
ITransitionGlyph transitionGlyph = _LastSelectedGlyph as ITransitionGlyph;
transitionGlyph.Action = InputDialog.Execute(_Context.ParentStateDiagramView, "Transition Property Input", "Transition Event Action", transitionGlyph.Action);
}
else if (IsControlKey(e, Keys.I))
{
ITransitionGlyph transitionGlyph = _LastSelectedGlyph as ITransitionGlyph;
transitionGlyph.IsInnerTransition = !transitionGlyph.IsInnerTransition;
}
}
else if (_Model.IsStateTransitionPortGlyph(_LastSelectedGlyph))
{
if (IsControlKey(e, Keys.N))
{
_LastSelectedGlyph.Name = InputDialog.Execute(_Context.ParentStateDiagramView, "State Transition Port Property Input", "Port Name", _LastSelectedGlyph.Name);
}
}
else if (_Model.IsComponentGlyph(_LastSelectedGlyph))
{
if (IsControlKey(e, Keys.N))
{
_LastSelectedGlyph.Name = InputDialog.Execute(_Context.ParentStateDiagramView, "Component Property Input", "Component Name", _LastSelectedGlyph.Name);
}
}
else
{
if (IsControlKey(e, Keys.N))
{
_LastSelectedGlyph.Name = InputDialog.Execute(_Context.ParentStateDiagramView, "Property Input", "Name", _LastSelectedGlyph.Name);
}
}
_Context.RefreshView();
}
public void Start()
{
Prepare ();
IStateGlyph state = OuterMostState ();
if (state == null)
{
throw new Exception ("No parent start state found!");
}
CurrentState = state;
DoRefresh ();
}
protected void GetTransitionList(ArrayList transitionList, IStateGlyph state)
{
// now find transitions
foreach (IGlyph child in state.Children)
{
ITransitionContactPointGlyph transContactPoint = child as ITransitionContactPointGlyph;
if (transContactPoint != null)
{
ITransitionGlyph trans = transContactPoint.Owner as ITransitionGlyph;
if (transContactPoint.WhichEnd == TransitionContactEnd.From)
{
// this is a from transition
ITransitionContactPointGlyph transTo = null;
foreach (ITransitionContactPointGlyph contactPoint in trans.ContactPoints)
{
if (contactPoint.WhichEnd == TransitionContactEnd.To)
{
transTo = contactPoint;
break;
}
}
System.Diagnostics.Debug.Assert (transTo != null, "Transition To Contact Point not found");
IStateGlyph toStateGlyph = transTo.Parent as IStateGlyph;
string toStateName = "TRANSITION_TOSTATE_NOT_SET";
if (toStateGlyph != null)
{
if (IsNotEmptyString (toStateGlyph.Name))
{
toStateName = StateNameFrom (toStateGlyph);
}
else
{
toStateName = "TRANSITION_TOSTATE_SET_BUT_STATE_NOT_NAMED";
}
}
TransitionInfo info = new TransitionInfo (trans, StateNameFrom (state), toStateName, toStateGlyph);
transitionList.Add (info);
}
}
}
}
protected string StateNameFrom(IStateGlyph state)
{
string name = state.FullyQualifiedStateName;
name = name.Replace (".", "_");
return name;
}
public TransitionInfo(ITransitionGlyph trans, string fromStateName, string toStateName, IStateGlyph toStateGlyph)
{
Transition = trans;
FromStateName = fromStateName;
ToStateName = toStateName;
ToStateGlyph = toStateGlyph;
}
protected void WriteStaticTransitionChains(IStateGlyph state, ArrayList transitionList)
{
Hashtable writtenTrans = new Hashtable ();
transitionList.Sort (new TransitionVarComparer ());
foreach (TransitionInfo transInfo in transitionList)
{
ITransitionGlyph trans = transInfo.Transition;
if (!trans.IsProperInnerTransition ())
{
string sv = transInfo.TransitionVarName;
if (!writtenTrans.Contains (sv))
{
WriteLine ("protected static int {0} = s_TransitionChainStore.GetOpenSlot ();", sv);
writtenTrans.Add (sv, sv);
}
}
}
}
protected bool StateHasAfterTransitions(IStateGlyph state)
{
foreach (TransitionInfo transInfo in GetTransitionList (state))
{
if (IsNotEmptyString (transInfo.Transition.TimeOutExpression))
{
return true;
}
}
return false;
}
protected bool CanInstrument(IStateGlyph state)
{
return _Instrument && state.DoNotInstrument == false;
}
protected void WriteTransition(IStateGlyph state, ArrayList groupedTransitionList)
{
ITransitionGlyph trans = (groupedTransitionList [0] as TransitionInfo).Transition;
WriteLine ("case {0}{1}.{2}: {{", _SignalTypeCast, _QualifiedSignalClassName, trans.Event);
Inc ();
int round = 0;
string breakString = "break;"; // if no non-empty guard condition so execution could fall through all tests - so break at end of case block.
CheckTransitions (state, groupedTransitionList);
foreach (TransitionInfo transInfo in groupedTransitionList)
{
trans = transInfo.Transition;
bool transitionHasAction = IsNotEmptyString (trans.Action);
bool transitionHasGuard = HasGuardCondition (trans);
if (transitionHasGuard == false)
{
breakString = ""; // empty guard condition and empty source - so conditionless handler - no need for break as no fall-through.
}
if (transitionHasGuard)
{
string elseOp = round > 0 ? "else" : "";
string condition = trans.GuardCondition;
WriteLine ("{1} if ({0}) {{", condition, elseOp);
Inc ();
}
else if (round > 0)
{
WriteLine ("else {");
Inc ();
}
switch (trans.TransitionType)
{
case TransitionType.History:
{
throw new NotSupportedException ("History transitions are not yet supported");
}
case TransitionType.DeepHistory:
{
WriteLine ("QState toState_{0} = _{0}_DeepHistory == null ? s_{0} : _{0}_DeepHistory;", transInfo.ToStateName);
} break;
}
/*
if (trans.IsProperInnerTransition ())
{
WriteLog (StateLogType.EventBeforeInternalTransition, state, transInfo);
}
else
{
switch (trans.TransitionType)
{
case TransitionType.History:
{
throw new NotSupportedException ("History transitions are not yet supported");
}
case TransitionType.DeepHistory:
{
WriteLog (StateLogType.EventBeforeTransition, state, transInfo, "toState");
} break;
default:
{
WriteLog (StateLogType.EventBeforeTransition, state, transInfo);
} break;
}
}
*/
string codeBlockName = _SignalClassName + "." + trans.QualifiedEvent;
if (transitionHasGuard)
{
if (IsNotEmptyString (trans.Name) == false)
{
string msg = string.Format ("State {0} - transition with guard condition must have a name: {1}", StateNameFrom (state), trans.DisplayText ());
throw new ArgumentException (msg);
}
codeBlockName += ":" + trans.Name;
}
WriteStateCodeBlock (state, codeBlockName);
if (transitionHasAction)
{
string action = ParseAction (trans.Action);
WriteLine ("{0};", action);
}
if (!trans.IsProperInnerTransition ())
{
switch (trans.TransitionType)
{
case TransitionType.History:
{
throw new NotSupportedException ("History transitions are not yet supported");
}
case TransitionType.DeepHistory:
{
WriteLog (StateLogType.EventTransition, state, transInfo, "toState");
WriteLine ("TransitionTo (toState_{0});", transInfo.ToStateName);
} break;
default:
{
WriteLog (StateLogType.EventTransition, state, transInfo);
WriteLine ("TransitionTo (s_{0}, {1});", transInfo.ToStateName, transInfo.TransitionVarName);
} break;
}
}
if (trans.IsProperInnerTransition ())
{
WriteLog (StateLogType.EventInternalTransition, state, transInfo);
}
WriteLine ("return null;");
if (transitionHasGuard || round > 0)
{
Dec ();
WriteLine ("}");
}
round++;
}
Dec ();
WriteLine ("}} {0} // {1}", breakString, trans.QualifiedEvent);
}
protected void WriteLog(StateLogType logType, IStateGlyph state, IStateGlyph initState)
{
if (CanInstrument (state))
{
WriteLine ("LogStateEvent (StateLogType.{0}, s_{1}, s_{2});", logType, StateNameFrom (state), StateNameFrom (initState));
}
}
protected void WriteLog(StateLogType logType, IStateGlyph state)
{
if (CanInstrument (state))
{
string action = null;
switch (logType)
{
case StateLogType.Entry:
{
action = NormalisedActionDisplayText (state.EntryAction);
} break;
case StateLogType.Exit:
{
action = NormalisedActionDisplayText (state.ExitAction);
} break;
}
if (action == null)
{
WriteLine ("LogStateEvent (StateLogType.{0}, s_{1});", logType, StateNameFrom (state));
}
else
{
WriteLine ("LogStateEvent (StateLogType.{0}, s_{1}, \"{2}\");", logType, StateNameFrom (state), action);
}
}
}
private string GetStateName(IStateGlyph stateGlyph)
{
string sname = "S_" + stateGlyph.FullyQualifiedStateName;
sname = sname.Replace (".", "_");
return sname;
}
protected void WriteLog(StateLogType logType, IStateGlyph state, TransitionInfo transitionInfo, string transitionFieldNamePrefix)
{
if (CanInstrument (state))
{
string text = NormalisedTransitionDisplayText (transitionInfo);
WriteLine ("LogStateEvent (StateLogType.{0}, s_{1}, {5}_{2}, \"{3}\", \"{4}\");", logType, StateNameFrom (state), transitionInfo.ToStateName, transitionInfo.Transition.QualifiedEvent, text, transitionFieldNamePrefix);
}
}
protected void CheckTransitions_DuplicateTransitionsNoGuard(IStateGlyph state, ArrayList groupedTransitionList)
{
// not really necessary - but supplies extra info.
bool guardLessTransFound = false;
foreach (TransitionInfo transInfo in groupedTransitionList)
{
ITransitionGlyph trans = transInfo.Transition;
if (IsNotEmptyString (trans.GuardCondition) == false)
{
if (guardLessTransFound)
{
string msg = string.Format ("Two transitions from the same State: {0} have the same event {1} without guard conditions", StateNameFrom (state), trans.QualifiedEvent);
throw new ArgumentException (msg);
}
guardLessTransFound = true;
}
}
}
protected void WriteLog(StateLogType logType, IStateGlyph state, TransitionInfo transitionInfo)
{
WriteLog(logType, state, transitionInfo, "s");
}
protected void WriteStateDefaults(IStateGlyph state)
{
IStateGlyph initState = null;
foreach (IGlyph child in state.Children)
{
IStateGlyph childState = child as IStateGlyph;
if (childState != null && childState.IsStartState)
{
System.Diagnostics.Debug.Assert (initState == null, "More than one child marked as StartState: " + state.Name);
initState = childState;
}
}
if (initState != null)
{
WriteLine ("case {0}QSignals.Init: {{", _SignalTypeCast);
Inc ();
WriteLog (StateLogType.Init, state, initState);
WriteStateCodeBlock (state, "Init");
WriteLine ("InitializeState (s_{0});", StateNameFrom (initState));
Dec ();
WriteLine ("} return null;");
}
if (IsNotEmptyString (state.DoAction))
{
throw new NotSupportedException ("DoAction not supported. Found in state: " + StateNameFrom (state));
}
bool isFinalState = state.IsFinalState;
bool hasEntryAction = IsNotEmptyString (state.EntryAction);
bool stateMustKeepHistory = StateOrParentHasDeepHistoryTransition (state);
bool hasAfterTransitions = StateHasAfterTransitions (state);
if (hasEntryAction || isFinalState || stateMustKeepHistory || hasAfterTransitions)
{
WriteLine ("case {0}QSignals.Entry: {{", _SignalTypeCast);
Inc ();
WriteLog (StateLogType.Entry, state);
WriteStateCodeBlock (state, "Entry");
if (stateMustKeepHistory)
{
ArrayList historyKeepers = GetStateOrParentsThatHasDeepHistoryTransition (state);
foreach (IStateGlyph historyKeeper in historyKeepers)
{
WriteLine ("_{0}_DeepHistory = s_{1};", StateNameFrom (historyKeeper), StateNameFrom (state));
}
}
if (hasEntryAction)
{
WriteLine ("{0};", ParseAction (state.EntryAction));
}
if (hasAfterTransitions)
{
ArrayList afterTransitions = GetStateAfterTransitions (state);
foreach (ITransitionGlyph trans in afterTransitions)
{
if (trans.IsInnerTransition)
{
throw new NotSupportedException ("After Timeout transitions are not supported for InnerTransitions");
}
string timeOutExpression = trans.TimeOutExpression.Trim ();
if (timeOutExpression.IndexOf (" ") == -1)
{
// this is the original timeout request
WriteLine ("SetTimeOut (\"{0}_{1}_{2}\", TimeSpan.FromSeconds ({3}), new QEvent (\"{4}\"));", StateNameFrom (state), trans.Name, trans.Event, trans.TimeOutExpression, trans.QualifiedEvent);
}
else
{
string[] strList = timeOutExpression.Split (' ');
string timeOut = strList [strList.Length - 1].Trim ();
string flag = "Single";
if (timeOutExpression.StartsWith ("every"))
{
flag = "Repeat";
}
if (timeOutExpression.StartsWith ("at"))
{
flag = "Single";
WriteLine ("SetTimeOut (\"{0}_{1}_{2}\", {3}, new QEvent (\"{4}\"), TimeOutType.{5});", StateNameFrom (state), trans.Name, trans.Event, timeOut, trans.QualifiedEvent, flag);
}
else
{
WriteLine ("SetTimeOut (\"{0}_{1}_{2}\", TimeSpan.FromSeconds ({3}), new QEvent (\"{4}\"), TimeOutType.{5});", StateNameFrom (state), trans.Name, trans.Event, timeOut, trans.QualifiedEvent, flag);
}
}
}
}
if (isFinalState)
{
WriteLine ("DoFinalStateReached (this, s_{0});", StateNameFrom (state));
}
Dec ();
WriteLine ("} return null;");
}
else if (!state.IsOverriding)
{
WriteLine ("case {0}QSignals.Entry: {{", _SignalTypeCast);
Inc ();
WriteLog (StateLogType.Entry, state);
WriteStateCodeBlock (state, "Entry");
Dec ();
WriteLine ("} return null;");
}
if (hasAfterTransitions || IsNotEmptyString (state.ExitAction))
{
WriteLine ("case {0}QSignals.Exit: {{", _SignalTypeCast);
Inc ();
if (hasAfterTransitions)
{
ArrayList afterTransitions = GetStateAfterTransitions (state);
foreach (ITransitionGlyph trans in afterTransitions)
{
WriteLine ("ClearTimeOut (\"{0}_{1}_{2}\");", StateNameFrom (state), trans.Name, trans.Event);
}
}
WriteStateCodeBlock (state, "Exit");
if (IsNotEmptyString (state.ExitAction))
{
WriteLine ("{0};", ParseAction (state.ExitAction));
}
WriteLog (StateLogType.Exit, state);
Dec ();
WriteLine ("} return null;");
}
else if (!state.IsOverriding)
{
WriteLine ("case {0}QSignals.Exit: {{", _SignalTypeCast);
Inc ();
WriteStateCodeBlock (state, "Exit");
WriteLog (StateLogType.Exit, state);
Dec ();
WriteLine ("} return null;");
}
}
protected bool StateHasAsAnyParent(IStateGlyph state, IStateGlyph possibleParentState)
{
while (state != null)
{
if (state.Parent == possibleParentState)
{
return true;
}
state = state.Parent as IStateGlyph;
}
return false;
}
protected void WriteStateCodeBlock(IStateGlyph state, string eventName)
{
string stateName = StateNameFrom (state);
string codeBlockName = string.Format ("{0}:{1}", stateName, eventName);
if (_WriteStateCodeBlocks)
{
WriteCodeBlock (codeBlockName);
}
else
{
string block = GetCodeBlock (codeBlockName);
if (IsNotEmptyString (block))
{
throw new Exception ("Don't want to use these code blocks for now... - can put them back in later!\n\nCodeBlock: " + block);
}
}
}
protected bool StateOrParentHasDeepHistoryTransition(IStateGlyph state)
{
while (state != null)
{
if (_StatesWithHistoryTransitions.Contains (state))
{
return true;
}
state = state.Parent as IStateGlyph;
}
return false;
}
protected void WriteState(IStateGlyph state)
{
ArrayList transitionList = GetTransitionList (state);
Inc ();
WriteLine ("");
WriteLine ("#region State {0}", StateNameFrom (state));
WriteStaticTransitionChains (state, transitionList);
WriteLine ("[StateMethod (\"{0}\")]", StateNameFrom (state));
foreach (string stateCommandName in state.StateCommands)
{
if (IsNotEmptyString (stateCommandName))
{
WriteLine ("[StateCommand (\"{0}\")]", stateCommandName);
}
}
string overrideOrVirtual = state.IsOverriding ? "override" : "virtual";
WriteLine ("protected {0} QState S_{1} (IQEvent ev){{", overrideOrVirtual, StateNameFrom (state));
Inc ();
WriteLine ("switch (ev.QSignal){");
WriteStateDefaults (state);
// now find transitions
ArrayList groupedTransitions = GroupTransitionsByEvent (transitionList);
foreach (ArrayList groupedTransitionList in groupedTransitions)
{
WriteTransition (state, groupedTransitionList);
}
WriteLine ("} // switch");
// get return parent state
string parentName = "TopState";
IGlyph parentGlyph = state.Parent;
if (parentGlyph != null)
{
IStateGlyph parentState = parentGlyph as IStateGlyph;
parentName = "s_" + StateNameFrom (parentState);
}
WriteLine ("");
if (state.IsOverriding)
{
WriteLine ("return base.S_{0} (ev);", StateNameFrom (state));
}
else
{
WriteLine ("return {0};", parentName);
}
Dec ();
WriteLine ("}} // S_{0}", StateNameFrom (state));
WriteLine ("#endregion");
Dec ();
}
protected void AnalyseGuardAction(IStateGlyph state, ITransitionGlyph trans, string actions)
{
string[] names = ParseNames (actions);
}
protected void CheckTransitions_CheckUniqueNames(IStateGlyph state, ArrayList groupedTransitionList)
{
Hashtable catcher = new Hashtable ();
foreach (TransitionInfo transInfo in groupedTransitionList)
{
ITransitionGlyph trans = transInfo.Transition;
string text = trans.Name;
if (IsNotEmptyString (text))
{
if (catcher.Contains (text))
{
string msg = string.Format ("More than one transition has same name {0}. Last one found in state {1} event {2}", text, StateNameFrom (state), trans.DisplayText ());
throw new ArgumentException (msg);
}
catcher.Add (text, text);
}
}
}
protected ArrayList GetTransitionList(IStateGlyph state)
{
ArrayList transitionList = new ArrayList ();
GetTransitionList (transitionList, state);
return transitionList;
}
protected void CheckTransitions_CatchDuplicateEvents(IStateGlyph state, ArrayList groupedTransitionList)
{
Hashtable catcher = new Hashtable ();
foreach (TransitionInfo transInfo in groupedTransitionList)
{
ITransitionGlyph trans = transInfo.Transition;
string eventText = trans.CompleteEventText (false, false);
if (catcher.Contains (eventText))
{
string msg = string.Format ("More than one transition from the same State: {0} have the same event {1}", StateNameFrom (state), eventText);
throw new ArgumentException (msg);
}
catcher.Add (eventText, eventText);
}
}
protected void CheckTransitions(IStateGlyph state, ArrayList groupedTransitionList)
{
CheckTransitions_DuplicateTransitionsNoGuard (state, groupedTransitionList);
CheckTransitions_CatchDuplicateEvents (state, groupedTransitionList);
CheckTransitions_CheckUniqueNames (state, groupedTransitionList);
}
void SaveStateGlyph(TextWriter sw, IStateGlyph glyph)
{
SaveBounds (sw, "STATE:", glyph);
if (glyph.Parent != null)
{
sw.WriteLine (glyph.Parent.Id);
}
else
{
sw.WriteLine ("NOPARENT");
}
SaveGlyphCommon (sw, glyph);
IStateGlyph state = glyph;
SaveText (sw, "NAME", state.Name);
SaveText (sw, "ISSTARTSTATE", state.IsStartState.ToString ());
SaveText (sw, "ISFINALSTATE", state.IsFinalState.ToString ());
SaveText (sw, "ENTRY", state.EntryAction);
SaveText (sw, "EXIT", state.ExitAction);
SaveText (sw, "DO", state.DoAction);
SaveText (sw, "ISOVERRIDING", state.IsOverriding.ToString ());
ArrayList commandList = new ArrayList ();
foreach (string commandName in state.StateCommands)
{
if (commandName != null && commandName.Trim () != "")
{
commandList.Add (commandName);
}
}
string[] commandsArray = (string[]) commandList.ToArray (typeof (string));
string cmds = string.Join (";", commandsArray);
SaveTextIfNotDefault (sw, "STATECOMMANDS", cmds, "");
}
