public virtual IStateTransition AddNewTransition(IStateMachineEvent trigger, IStateMachineState destination)
{
var transition = new StateTransition(this, trigger, destination);
TransitionList.Add(transition);
return(transition);
}
public virtual IStateTransition AddNewTransition(IStateMachineEvent trigger, IStateMachineState destination, List <string> rolesRequired)
{
var transition = new StateTransition(this, trigger, destination, rolesRequired);
TransitionList.Add(transition);
return(transition);
}
void SetupAnimationForCustomTransitions(TransitionList transitionsToAnimate, View view)
{
if (transitionsToAnimate?.Count > 0)
{
foreach (LayoutTransition transition in transitionsToAnimate)
{
if (transition.AnimatableProperty != AnimatableProperties.Position &&
transition.AnimatableProperty != AnimatableProperties.Size)
{
_coreAnimation.AnimateTo(view,
transition.AnimatableProperty.ToString(),
transition.TargetValue,
transition.Animator.Delay,
transition.Animator.Duration,
transition.Animator.AlphaFunction);
Debug.WriteLineIf(LayoutDebugController,
"LayoutController SetupAnimationForCustomTransitions View:" + view.Name +
" Property:" + transition.AnimatableProperty.ToString() +
" delay:" + transition.Animator.Delay +
" duration:" + transition.Animator.Duration);
}
}
}
}
/// <summary>
/// Copy the transitions in the source list to the target list
/// </summary>
/// <param name="sourceTransitionList">The source transition list.</param>
/// <param name="targetTransitionList">The target transition list to copy to.</param>
static public void CopyTransitions(TransitionList sourceTransitionList, TransitionList targetTransitionList)
{
targetTransitionList.Clear();
foreach (LayoutTransition transitionToApply in sourceTransitionList)
{
// Overwrite existing transitions
targetTransitionList.Add(transitionToApply);
}
}
public static TransitionList WithSimpleRouteOf(this TransitionList transitions, HttpState source, string defaultRoute, HttpState destination)
{
var transitionRoute = new TransitionRoute(defaultRoute, destination);
var routes = new[] { transitionRoute };
transitions.Register(source, routes);
return(transitions);
}
private TransitionList CreateLookbackTransitions(LRItemSet sourceItems)
{
var newTransitions = new TransitionList();
//Build set of initial cores - this is optimization for performance
//We need to find all initial items in all states that shift into one of sourceItems
// Each such initial item would have the core from the "initial" cores set that we build from source items.
var iniCores = new LR0ItemSet();
foreach (var sourceItem in sourceItems)
{
iniCores.Add(sourceItem.Core.Production.LR0Items[0]);
}
//find
foreach (var state in _data.States)
{
foreach (var iniItem in state.BuilderData.InitialItems)
{
if (!iniCores.Contains(iniItem.Core))
{
continue;
}
var iniItemNt = iniItem.Core.Production.LValue; // iniItem's non-terminal (left side of production)
Transition lookback = null; // local var for lookback - transition over iniItemNt
var currItem = iniItem; // iniItem is initial item for all currItem's in the shift chain.
while (currItem != null)
{
if (sourceItems.Contains(currItem))
{
// We create transitions lazily, only when we actually need them. Check if we have iniItem's transition
// in local variable; if not, get it from state's transitions table; if not found, create it.
if (lookback == null && !state.BuilderData.Transitions.TryGetValue(iniItemNt, out lookback))
{
lookback = new Transition(state, iniItemNt);
newTransitions.Add(lookback);
}
//Now for currItem, either add trans to Lookbacks, or "include" it into currItem.Transition
// We need lookbacks ONLY for final items; for non-Final items we need proper Include lists on transitions
if (currItem.Core.IsFinal)
{
currItem.Lookbacks.Add(lookback);
}
else // if (currItem.Transition != null)
// Note: looks like checking for currItem.Transition is redundant - currItem is either:
// - Final - always the case for the first run of this method;
// - it has a transition after the first run, due to the way we select sourceItems list
// in SelectNewItemsThatNeedLookback (by transitions)
{
currItem.Transition.Include(lookback);
}
}//if
//move to next item
currItem = currItem.ShiftedItem;
} //while
} //foreach iniItem
} //foreach state
return(newTransitions);
}
public void LayoutTransitionsHelperAddTransitionForCondition()
{
tlog.Debug(tag, $"LayoutTransitionsHelperAddTransitionForCondition START");
Dictionary <TransitionCondition, TransitionList> targetTransitionList = new Dictionary <TransitionCondition, TransitionList>();
TransitionList transitionList = new TransitionList();
var addTransition = new LayoutTransition(TransitionCondition.Add,
AnimatableProperties.Position,
0.3f,
new TransitionComponents()
);
transitionList.Add(addTransition);
var layoutChangedTransition = new LayoutTransition(TransitionCondition.LayoutChanged,
AnimatableProperties.Opacity,
0.2f,
new TransitionComponents()
);
transitionList.Add(layoutChangedTransition);
targetTransitionList.Add(TransitionCondition.Add, transitionList);
targetTransitionList.Add(TransitionCondition.LayoutChanged, transitionList);
/**
* conditionNotInDictionary = false
*/
LayoutTransitionsHelper.AddTransitionForCondition(targetTransitionList,
TransitionCondition.LayoutChanged,
addTransition,
true);
/**
* conditionNotInDictionary = true
* replaced
*/
LayoutTransitionsHelper.AddTransitionForCondition(targetTransitionList,
TransitionCondition.Add,
addTransition,
false);
/**
* conditionNotInDictionary = true
* new entry
*/
LayoutTransitionsHelper.AddTransitionForCondition(targetTransitionList,
TransitionCondition.ChangeOnAdd,
addTransition,
false);
tlog.Debug(tag, $"LayoutTransitionsHelperAddTransitionForCondition END (OK)");
}
internal void AddTransitionImpl(string name, Transition t)
{
TransitionList list;
if (!transitions.TryGetValue(name, out list))
{
list = new TransitionList();
transitions.Add(name, list);
}
list.Add(t.Source, t);
}
public override StateTransition GetNewTransition(TransitionList id)
{
switch (id)
{
case TransitionList.BooleanTransition: return(new BooleanTransition(1, Transition.NullTransition, StateID.NullStateID, false, false));
case TransitionList.TimeTransition: return(new TimeTransition(1, Transition.NullTransition, StateID.NullStateID, 0));
default: Debug.LogError("不支持生成"); return(null);
}
}
private TransitionList CreateLookbackTransitions(LRItemSet sourceItems)
{
var newTransitions = new TransitionList();
//Build set of initial cores - this is optimization for performance
//We need to find all initial items in all states that shift into one of sourceItems
// Each such initial item would have the core from the "initial" cores set that we build from source items.
var iniCores = new LR0ItemSet();
foreach (var sourceItem in sourceItems)
{
iniCores.Add(sourceItem.Core.Production.LR0Items[0]);
}
//find
foreach (var state in Data.States)
{
foreach (var iniItem in state.BuilderData.InitialItems)
{
if (!iniCores.Contains(iniItem.Core))
{
continue;
}
var currItem = iniItem;
while (currItem != null)
{
if (sourceItems.Contains(currItem))
{
//iniItem is initial item for currItem (one of source items)
// check if transition for iniItem's non-terminal exists
var ntLeft = iniItem.Core.Production.LValue;
Transition trans;
if (!state.BuilderData.Transitions.TryGetValue(ntLeft, out trans))
{
trans = new Transition(iniItem.State, iniItem.Core.Production.LValue);
newTransitions.Add(trans);
}
//Now for currItem, either add trans to Lookbackbacks, or "include" it into currItem.Transition
if (currItem.Core.IsFinal)
{
currItem.Lookbacks.Add(trans);
}
else if (currItem.Transition != null)
{
currItem.Transition.Include(trans);
}
}//if
//move to next items
currItem = currItem.ShiftedItem;
} //while
} //foreach iniItem
} //foreach state
return(newTransitions);
}
/// <summary>
/// Iterate transitions and replace Position Components if replacements found in list.
/// </summary>
private void FindAndReplaceAnimatorComponentsForProperty(TransitionList sourceTransitionList,
AnimatableProperties propertyToMatch,
ref TransitionComponents transitionComponentToUpdate)
{
foreach (LayoutTransition transition in sourceTransitionList)
{
if (transition.AnimatableProperty == propertyToMatch)
{
// Matched property to animate is for the propertyToMatch so use provided Animator.
transitionComponentToUpdate = transition.Animator;
}
}
}
/// <summary>
/// Adds the given transition and condition to a transition list.
/// </summary>
/// <param name="targetTransitionList">The list to add the transition to.</param>
/// <param name="condition">Condition for the transition.</param>
/// <param name="transition">The transition to add.</param>
/// <param name="explicitlySet">True is set explicitly, false if inherited.</param>
static public void AddTransitionForCondition(
Dictionary <TransitionCondition, TransitionList> targetTransitionList,
TransitionCondition condition,
LayoutTransition transition,
bool explicitlySet)
{
bool replaced = false;
bool conditionNotInDictionary = false;
TransitionList transitionListMatchingCondition;
if (targetTransitionList.TryGetValue(condition, out transitionListMatchingCondition))
{
if (transitionListMatchingCondition != null)
{
for (var index = 0; index < transitionListMatchingCondition.Count; index++)
{
if (transitionListMatchingCondition[index].AnimatableProperty == transition.AnimatableProperty)
{
if (explicitlySet)
{
transitionListMatchingCondition[index] = transition;
replaced = true;
continue;
}
}
}
}
}
else
{
conditionNotInDictionary = true;
}
if (replaced == false)
{
if (transitionListMatchingCondition == null)
{
transitionListMatchingCondition = new TransitionList();
}
transitionListMatchingCondition.Add(transition);
// Update dictionary with new or replaced entry.
if (conditionNotInDictionary)
{
targetTransitionList.Add(condition, transitionListMatchingCondition); // new entry
}
else
{
targetTransitionList[condition] = transitionListMatchingCondition; // replaced
}
}
}
private LRItemSet SelectNewItemsThatNeedLookback(TransitionList transitions)
{
//Select items with nullable tails that don't have lookbacks yet
var items = new LRItemSet();
foreach (var trans in transitions)
{
foreach (var item in trans.Items)
{
if (item.Core.TailIsNullable && item.Lookbacks.Count == 0) //only if it does not have lookbacks yet
{
items.Add(item);
}
}
}
return(items);
}
void SetupAnimationForCustomTransitions(TransitionList transitionsToAnimate, View view)
{
if (transitionsToAnimate.Count > 0)
{
foreach (LayoutTransition transition in transitionsToAnimate)
{
if (transition.AnimatableProperty != AnimatableProperties.Position)
{
_coreAnimation.AnimateTo(view,
transition.AnimatableProperty.ToString(),
transition.TargetValue,
transition.Animator.Delay,
transition.Animator.Duration,
transition.Animator.AlphaFunction);
}
}
}
}
static int NextState(int state, char c)
{
var cat = char.GetUnicodeCategory(c);
if (c == '*' || c == '/' || c == '-' || c == '^')
{
cat = UnicodeCategory.MathSymbol;
}
if (!IsValid(c))
{
return(-1);
}
Transition t = TransitionList.Where(tr => tr.InitalState == state && tr.Input == cat).FirstOrDefault();
if (t == null)
{
return(-1);
}
return(t.ResultState);
}
/// <summary>
/// Retreive the transition list for the given condition.
/// </summary>
/// <param name="sourceTransitionCollection">The source collection of transition lists to retrieve.</param>
/// <param name="condition">Condition for the transition.</param>
/// <param name="transitionsForCondition">transition list to return as out parameter.</param>
/// <returns>True if a transition list found for the given condition></returns>
static public bool GetTransitionsListForCondition(
Dictionary<TransitionCondition, TransitionList> sourceTransitionCollection,
TransitionCondition condition,
TransitionList transitionsForCondition )
{
TransitionCondition resolvedCondition = condition;
bool matched = false;
// LayoutChanged transitions overrides ChangeOnAdd and ChangeOnRemove as siblings will
// reposition to the new layout not to the insertion/removal of a sibling.
if ((condition & TransitionCondition.LayoutChanged) == TransitionCondition.LayoutChanged)
{
resolvedCondition = TransitionCondition.LayoutChanged;
}
if (sourceTransitionCollection.TryGetValue(resolvedCondition, out transitionsForCondition))
{
matched = true;
}
return matched;
}
public void LayoutTransitionsHelperGetTransitionsListForCondition()
{
tlog.Debug(tag, $"LayoutTransitionsHelperGetTransitionsListForCondition START");
TransitionList transitionList = new TransitionList();
LayoutTransition addTransition = new LayoutTransition(TransitionCondition.Add,
AnimatableProperties.Position,
0.3f,
new TransitionComponents()
);
LayoutTransition removeTransition = new LayoutTransition(TransitionCondition.Remove,
AnimatableProperties.Position,
0.0f,
new TransitionComponents()
);
Dictionary <TransitionCondition, TransitionList> targetTransitionList = new Dictionary <TransitionCondition, TransitionList>();
targetTransitionList.Add(TransitionCondition.Unspecified, transitionList);
targetTransitionList.Add(TransitionCondition.LayoutChanged, transitionList);
TransitionList transitionsForCondition = new TransitionList();
var result = LayoutTransitionsHelper.GetTransitionsListForCondition(targetTransitionList,
TransitionCondition.LayoutChanged,
transitionsForCondition);
Assert.AreEqual(true, result, "should be equal!");
result = LayoutTransitionsHelper.GetTransitionsListForCondition(targetTransitionList,
TransitionCondition.Add,
transitionsForCondition);
Assert.AreEqual(false, result, "should be equal!");
tlog.Debug(tag, $"LayoutTransitionsHelperGetTransitionsListForCondition END (OK)");
}
/// <summary>
/// Sets up the main animation with the animators for each item (each layoutPositionData structure)
/// </summary>
private void AddAnimatorsToAnimation(LayoutData layoutPositionData)
{
LayoutTransition positionTransition = new LayoutTransition();
LayoutTransition sizeTransition = new LayoutTransition();
TransitionCondition conditionForAnimators = layoutPositionData.ConditionForAnimation;
// LayoutChanged transitions overrides ChangeOnAdd and ChangeOnRemove as siblings will
// reposition to the new layout not to the insertion/removal of a sibling.
if (layoutPositionData.ConditionForAnimation.HasFlag(TransitionCondition.LayoutChanged))
{
conditionForAnimators = TransitionCondition.LayoutChanged;
}
// Set up a default transitions, will be overwritten if inherited from parent or set explicitly.
TransitionComponents positionTransitionComponents = CreateDefaultTransitionComponent(0, 300);
TransitionComponents sizeTransitionComponents = CreateDefaultTransitionComponent(0, 300);
bool matchedCustomTransitions = false;
TransitionList transitionsForCurrentCondition = new TransitionList();
// Note, Transitions set on View rather than LayoutItem so if the Layout changes the transition persist.
// Check if item to animate has it's own Transitions for this condition.
// If a key exists then a List of at least 1 transition exists.
if (layoutPositionData.Item.Owner.LayoutTransitions.ContainsKey(conditionForAnimators))
{
// Child has transitions for the condition
matchedCustomTransitions = layoutPositionData.Item.Owner.LayoutTransitions.TryGetValue(conditionForAnimators, out transitionsForCurrentCondition);
}
if (!matchedCustomTransitions)
{
// Inherit parent transitions as none already set on View for the condition.
ILayoutParent layoutParent = layoutPositionData.Item.GetParent();
if (layoutParent != null)
{
// Item doesn't have it's own transitions for this condition so copy parents if
// has a parent with transitions.
LayoutGroup layoutGroup = layoutParent as LayoutGroup;
TransitionList parentTransitionList;
// Note TryGetValue returns null if key not matched.
if (layoutGroup != null && layoutGroup.Owner.LayoutTransitions.TryGetValue(conditionForAnimators, out parentTransitionList))
{
// Copy parent transitions to temporary TransitionList. List contains transitions for the current condition.
LayoutTransitionsHelper.CopyTransitions(parentTransitionList,
transitionsForCurrentCondition);
}
}
}
// Position/Size transitions can be displayed for a layout changing to another layout or an item being added or removed.
// There can only be one position transition and one size position, they will be replaced if set multiple times.
// transitionsForCurrentCondition represent all non position (custom) properties that should be animated.
// Search for Position property in the transitionsForCurrentCondition list of custom transitions,
// and only use the particular parts of the animator as custom transitions should not effect all parameters of Position.
// Typically Delay, Duration and Alphafunction can be custom.
FindAndReplaceAnimatorComponentsForProperty(transitionsForCurrentCondition,
AnimatableProperties.Position,
ref positionTransitionComponents);
// Size
FindAndReplaceAnimatorComponentsForProperty(transitionsForCurrentCondition,
AnimatableProperties.Size,
ref sizeTransitionComponents);
// Add animators to the core Animation,
SetupAnimationForCustomTransitions(transitionsForCurrentCondition, layoutPositionData.Item.Owner);
SetupAnimationForPosition(layoutPositionData, positionTransitionComponents);
SetupAnimationForSize(layoutPositionData, sizeTransitionComponents);
// Dispose components
positionTransitionComponents.Dispose();
sizeTransitionComponents.Dispose();
}
private TransitionList CreateLookbackTransitions(LRItemSet sourceItems) {
var newTransitions = new TransitionList();
//Build set of initial cores - this is optimization for performance
//We need to find all initial items in all states that shift into one of sourceItems
// Each such initial item would have the core from the "initial" cores set that we build from source items.
var iniCores = new LR0ItemSet();
foreach(var sourceItem in sourceItems)
iniCores.Add(sourceItem.Core.Production.LR0Items[0]);
//find
foreach(var state in Data.States) {
foreach(var iniItem in state.BuilderData.InitialItems) {
if (!iniCores.Contains(iniItem.Core)) continue;
var currItem = iniItem;
while(currItem != null) {
if(sourceItems.Contains(currItem)) {
//iniItem is initial item for currItem (one of source items)
// check if transition for iniItem's non-terminal exists
var ntLeft = iniItem.Core.Production.LValue;
Transition trans;
if(!state.BuilderData.Transitions.TryGetValue(ntLeft, out trans)) {
trans = new Transition(iniItem.State, iniItem.Core.Production.LValue);
newTransitions.Add(trans);
}
//Now for currItem, either add trans to Lookbackbacks, or "include" it into currItem.Transition
if(currItem.Core.IsFinal)
currItem.Lookbacks.Add(trans);
else if(currItem.Transition != null)
currItem.Transition.Include(trans);
}//if
//move to next items
currItem = currItem.ShiftedItem;
}//while
}//foreach iniItem
}//foreach state
return newTransitions;
}
private LRItemSet SelectNewItemsThatNeedLookback(TransitionList transitions)
{
//Select items with nullable tails that don't have lookbacks yet
var items = new LRItemSet();
foreach(var trans in transitions)
foreach(var item in trans.Items)
if (item.Core.TailIsNullable && item.Lookbacks.Count == 0) //only if it does not have lookbacks yet
items.Add(item);
return items;
}
private TransitionList CreateLookbackTransitions(LRItemSet sourceItems)
{
var newTransitions = new TransitionList();
//Build set of initial cores - this is optimization for performance
//We need to find all initial items in all states that shift into one of sourceItems
// Each such initial item would have the core from the "initial" cores set that we build from source items.
var iniCores = new LR0ItemSet();
foreach(var sourceItem in sourceItems)
iniCores.Add(sourceItem.Core.Production.LR0Items[0]);
//find
foreach(var state in Data.States) {
foreach(var iniItem in state.BuilderData.InitialItems) {
if (!iniCores.Contains(iniItem.Core)) continue;
var iniItemNt = iniItem.Core.Production.LValue; // iniItem's non-terminal (left side of production)
Transition lookback = null; // local var for lookback - transition over iniItemNt
var currItem = iniItem; // iniItem is initial item for all currItem's in the shift chain.
while (currItem != null) {
if(sourceItems.Contains(currItem)) {
// We create transitions lazily, only when we actually need them. Check if we have iniItem's transition
// in local variable; if not, get it from state's transitions table; if not found, create it.
if(lookback == null && !state.BuilderData.Transitions.TryGetValue(iniItemNt, out lookback)) {
lookback = new Transition(state, iniItemNt);
newTransitions.Add(lookback);
}
//Now for currItem, either add trans to Lookbacks, or "include" it into currItem.Transition
// We need lookbacks ONLY for final items; for non-Final items we need proper Include lists on transitions
if (currItem.Core.IsFinal)
currItem.Lookbacks.Add(lookback);
else // if (currItem.Transition != null)
// Note: looks like checking for currItem.Transition is redundant - currItem is either:
// - Final - always the case for the first run of this method;
// - it has a transition after the first run, due to the way we select sourceItems list
// in SelectNewItemsThatNeedLookback (by transitions)
currItem.Transition.Include(lookback);
}//if
//move to next item
currItem = currItem.ShiftedItem;
}//while
}//foreach iniItem
}//foreach state
return newTransitions;
}
public TransitionList CreateDefaultTransitionList()
{
var list = new TransitionList();
return(list);
}
public abstract StateTransition GetNewTransition(TransitionList id);
/// <summary>
/// Sets up the main animation with the animators for each item (each layoutPositionData structure)
/// </summary>
private void AddAnimatorsToAnimation(LayoutData layoutPositionData)
{
LayoutTransition positionTransition = new LayoutTransition();
TransitionCondition conditionForAnimators = layoutPositionData.ConditionForAnimation;
// LayoutChanged transitions overrides ChangeOnAdd and ChangeOnRemove as siblings will
// reposition to the new layout not to the insertion/removal of a sibling.
if (layoutPositionData.ConditionForAnimation.HasFlag(TransitionCondition.LayoutChanged))
{
conditionForAnimators = TransitionCondition.LayoutChanged;
}
// Set up a default transition, will be overwritten if inherited from parent or set explicitly.
const int START_TIME = 0;
const int END_TIME = 100;
AlphaFunction alphaFunction = new AlphaFunction(AlphaFunction.BuiltinFunctions.Linear);
// positionTransitionComponents will be overwritten if set explicitly
TransitionComponents positionTransitionComponents = new TransitionComponents(START_TIME, END_TIME, alphaFunction);
bool matchedCustomTransitions = false;
// Inherit parent transitions if none already set on View for the condition.
// Transitions set on View rather than LayoutItem so if the Layout changes the transition persist.
// Still need to inherit Position animator from parent but not other animatable properties if already set.
TransitionList transitionsForCurrentCondition;
ILayoutParent layoutParent = layoutPositionData.Item.GetParent();
if (layoutParent != null)
{
// Check if item to aninmate has it's own Transitions for this condition.
if (layoutPositionData.Item.Owner.LayoutTransitions.ContainsKey(conditionForAnimators))
{
matchedCustomTransitions = true; // If a key exists then a List of atleast 1 transition exists.
}
else
{
// Item doesn't have it's own transitions for this condition so copy parents if
// has a parent with transitions.
transitionsForCurrentCondition = new TransitionList();
LayoutGroup layoutGroup = layoutParent as LayoutGroup;
TransitionList parentTransitionList;
// Note TryGetValue returns null if key not matched.
if (layoutGroup.Owner.LayoutTransitions.TryGetValue(conditionForAnimators, out parentTransitionList))
{
// Copy parent transitions for this condition to temporary TransitionList.
LayoutTransitionsHelper.CopyTransitions(parentTransitionList,
transitionsForCurrentCondition);
SetupAnimationForCustomTransitions(transitionsForCurrentCondition, layoutPositionData.Item.Owner);
matchedCustomTransitions = false;
}
}
}
// SetupAnimationXXXX functions add Animators to the core Animation, these can be custom or set by the
// layout system in the case of Positioning.
if (matchedCustomTransitions)
{
// Position transition can be for a layout changing to another layout or an item being added or removed.
// There can only be one position transition, it will be replaced if set multiple times.
// transitionsForCurrentCondition represent all non position (custom) properties that should be animated.
// There can be multiple properties hence returned as a list.
if (layoutPositionData.Item.Owner.LayoutTransitions.TryGetValue(conditionForAnimators, out transitionsForCurrentCondition))
{
// Search for Position property in the transitionsForCurrentCondition list of custom transitions,
// and only use the particular parts of the animator as custom transitions should not effect all parameters of Position.
// Typically Delay, Duration and Alphafunction can be custom.
FindAndReplaceAnimatorComponentsForProperty(transitionsForCurrentCondition,
AnimatableProperties.Position,
ref positionTransitionComponents);
SetupAnimationForCustomTransitions(transitionsForCurrentCondition, layoutPositionData.Item.Owner);
}
}
SetupAnimationForPosition(layoutPositionData, positionTransitionComponents);
SetupAnimationForText(layoutPositionData);
}
