private void OnDynamicTransitionStoryboardCompleted(
     Storyboard dynamicTransitionStoryboard, VisualTransition currentTransition)
 {
     VisualStateSource.Verbose("Dynamic transition storyboard completed. State: {0}", StateName);
     if (currentTransition.Storyboard != null ||
         currentTransition.GetExplicitStoryboardCompleted())
     {
         if (ShouldRunStateStoryboard())
         {
             VisualStateSource.Verbose("Running ToState storyboards.");
             Group.StartNewAndStopOldStoryboards(StateGroupsRoot, ToState.Storyboard);
         }
     }
     currentTransition.SetDynamicStoryboardCompleted(true);
 }
        private void PlayTransitionAnimations(
            VisualTransition currentTransition, Storyboard dynamicTransitionStoryboard)
        {
            // Create these local event handlers, so that we can pass the local variables
            // to the actual handler functions, while also being able to de-register the event
            // handlers again, to not create memory leaks.
            EventHandler dynamicStoryboardCompletedHandler = null;
            EventHandler currentStoryboardCompletedHandler = null;

            dynamicStoryboardCompletedHandler = (sender, e) =>
            {
                dynamicTransitionStoryboard.Completed -= dynamicStoryboardCompletedHandler;
                OnDynamicTransitionStoryboardCompleted(dynamicTransitionStoryboard, currentTransition);
            };
            currentStoryboardCompletedHandler = (sender, e) =>
            {
                currentTransition.Storyboard.Completed -= currentStoryboardCompletedHandler;
                OnCurrentTransitionStoryboardCompleted(currentTransition);
            };

            // Play the dynamically created storyboard every single time.
            VisualStateSource.Verbose("Preparing dynamically generated transition storyboard.");
            currentTransition.SetDynamicStoryboardCompleted(false);
            dynamicTransitionStoryboard.Completed += dynamicStoryboardCompletedHandler;

            // If a storyboard has been defined INSIDE the VisualTransition
            // (-> explicit storyboard), play that aswell.
            if (currentTransition.Storyboard != null &&
                currentTransition.GetExplicitStoryboardCompleted())
            {
                VisualStateSource.Verbose("Preparing explicit storyboard defined in transition.");
                currentTransition.SetExplicitStoryboardCompleted(false);
                currentTransition.Storyboard.Completed += currentStoryboardCompletedHandler;
            }

            VisualStateSource.Verbose("Starting storyboards.");
            Group.StartNewAndStopOldStoryboards(
                StateGroupsRoot,
                currentTransition.Storyboard,
                dynamicTransitionStoryboard);
        }
        private static bool GoToStateInternal(Control control, FrameworkElement element, VisualStateGroup group, VisualState state, bool useTransitions)
        {
            if (element == null)
            {
                throw new ArgumentNullException("element");
            }

            if (state == null)
            {
                throw new ArgumentNullException("state");
            }

            if (group == null)
            {
                throw new InvalidOperationException();
            }

            //VisualState lastState = group.CurrentState;
            VisualState lastState = group.GetCurrentState();

            if (lastState == state)
            {
                return(true);
            }

            // Get the transition Storyboard. Even if there are no transitions specified, there might
            // be properties that we're rolling back to their default values.
            VisualTransition transition = useTransitions ? ExtendedVisualStateManager.GetTransition(element, group, lastState, state) : null;

            // Generate dynamicTransition Storyboard
            Storyboard dynamicTransition = GenerateDynamicTransitionAnimations(element, group, state, transition);

            // If the transition is null, then we want to instantly snap. The dynamicTransition will
            // consist of everything that is being moved back to the default state.
            // If the transition.Duration and explicit storyboard duration is zero, then we want both the dynamic
            // and state Storyboards to happen in the same tick, so we start them at the same time.
            if (transition == null || (transition.GeneratedDuration == DurationZero &&
                                       (transition.Storyboard == null || transition.Storyboard.Duration == DurationZero)))
            {
                // Start new state Storyboard and stop any previously running Storyboards
                if (transition != null && transition.Storyboard != null)
                {
                    group.StartNewThenStopOld(element, transition.Storyboard, state.Storyboard);
                }
                else
                {
                    group.StartNewThenStopOld(element, state.Storyboard);
                }

                // Fire both CurrentStateChanging and CurrentStateChanged events
                //group.RaiseCurrentStateChanging(element, lastState, state, control);
                //group.RaiseCurrentStateChanged(element, lastState, state, control);
            }
            else
            {
                // In this case, we have an interstitial storyboard of duration > 0 and/or
                // explicit storyboard of duration >0 , so we need
                // to run them first, and then we'll run the state storyboard.
                // we have to wait for both storyboards to complete before
                // starting the steady state animations.
                transition.SetDynamicStoryboardCompleted(false);                  //transition.DynamicStoryboardCompleted = false;

                // Hook up generated Storyboard's Completed event handler
                dynamicTransition.Completed += delegate(object sender, Object e)
                {
                    // transition.ExplicitStoryboardCompleted) &&
                    if ((transition.Storyboard == null || transition.GetExplicitStoryboardCompleted()) &&

                        // If the element or control is removed from the tree, then the new
                        // storyboards will not be able to resolve target names. Thus,
                        // if the element or control is unloaded, don't start the new
                        // storyboards.
                        //(element.IsLoaded && (control == null || control.IsLoaded)))
                        (element.Parent != null && (control == null || control.Parent != null)))
                    {
                        group.StartNewThenStopOld(element, state.Storyboard);
                    }

                    //group.RaiseCurrentStateChanged(element, lastState, state, control);
                    transition.SetDynamicStoryboardCompleted(true);                      //transition.DynamicStoryboardCompleted = true;
                };

                // if (transition.Storyboard != null && transition.ExplicitStoryboardCompleted == true)
                if (transition.Storyboard != null && transition.GetExplicitStoryboardCompleted() == true)
                {
                    EventHandler <Object> transitionCompleted = null;
                    transitionCompleted = new EventHandler <Object>(delegate(object sender, Object e)
                    {
                        if (transition.GetDynamicStoryboardCompleted() &&

                            // If the element or control is removed from the tree, then the new
                            // storyboards will not be able to resolve target names. Thus,
                            // if the element or control is unloaded, don't start the new
                            // storyboards.
                            //(element.IsLoaded && (control == null || control.IsLoaded)))
                            (element.Parent != null && (control == null || control.Parent != null)))
                        {
                            group.StartNewThenStopOld(element, state.Storyboard);
                        }

                        //group.RaiseCurrentStateChanged(element, lastState, state, control);
                        transition.Storyboard.Completed -= transitionCompleted;
                        transition.SetExplicitStoryboardCompleted(true);
                    });

                    // hook up explicit storyboard's Completed event handler
                    transition.SetExplicitStoryboardCompleted(false);
                    transition.Storyboard.Completed += transitionCompleted;
                }

                // Start transition and dynamicTransition Storyboards
                // Stop any previously running Storyboards
                group.StartNewThenStopOld(element, transition.Storyboard, dynamicTransition);
                //group.RaiseCurrentStateChanging(element, lastState, state, control);
            }

            //group.CurrentState = state;
            group.SetCurrentState(state);

            return(true);
        }