Exemplo n.º 1
0
        private void StartStateMachineInternal()
        {
            var state = GetState(StartState);

            if (AssociatedVisualStateManager != null)
            {
                AssociatedVisualStateManager.TransitionState(Name, null, StartState.ToString());
            }


            state.Enter(StartState);

            CurrentState = StartState;

            if (!state.TryAutomaticTransition())
            {
                state.ResumeTransitions();
            }

            RaiseStateMachineStarted();
        }
Exemplo n.º 2
0
        internal void TransitionStateInternal <TTrigger>(T fromState, T toState, TTrigger trigger, Action <TTrigger> transitionAction)
        {
            //we have to check, that the same event may only come in once. this solves an issue with the tracking mechanism
            if (trigger is EventArgs)
            {
                if (trigger.Equals(_lastTrigger))
                {
                    _lastTrigger = trigger;
                    return;
                }
                _lastTrigger = trigger;
            }

            TransitionOverride(fromState, toState, trigger);

            if (!CurrentState.Equals(fromState))
            {
                return;
            }

            var isInternalTransition = fromState.Equals(toState);

            Task <bool> vsmTransition = null;

            if (!isInternalTransition && AssociatedVisualStateManager != null)
            {
                vsmTransition = AssociatedVisualStateManager.TransitionState(Name, fromState.ToString(), toState.ToString());
            }

            var currentState = GetState(fromState);
            var futureState  = GetState(toState);

            //exit the current state
            if (!isInternalTransition)
            {
                currentState.IgnoreTransitions();
                currentState.Exit(toState);
            }

            //call the transition action
            if (transitionAction != null)
            {
                Action safeAction = () =>
                {
                    try
                    {
                        transitionAction(trigger);
                    }
                    catch (Exception e)
                    {
                        RaiseStateMachineException(e);
                    }
                };

                if (CurrentDispatcher != null)
                {
                    CurrentDispatcher.Invoke(safeAction, null);
                }
                else
                {
                    safeAction();
                }
            }

            //enter the next state
            if (!isInternalTransition)
            {
                futureState.Enter(fromState);
                futureState.ResumeTransitions();

                CurrentState = toState;

                RaiseStateChanged(fromState, toState);
            }

            //we can only make automatic transitions if we entered the current state from somewhere else
            if (!isInternalTransition)
            {
                if (vsmTransition == null || vsmTransition.IsCompleted)
                {
                    futureState.TryAutomaticTransition();
                }
                else
                {
                    vsmTransition.ContinueWith(result => futureState.TryAutomaticTransition());
                }
            }
        }