public void When_ControlTemplate_And_Animation() { var SUT = new ContentControl() { Tag = 42 }; DoubleAnimation anim = null; var template = new ControlTemplate(() => { var g = new Grid(); var vg = new VisualStateGroup(); var t1 = new VisualTransition(); var sb = new Storyboard(); anim = new DoubleAnimation(); anim.SetBinding(DoubleAnimation.ToProperty, new Binding() { Path = "Tag", RelativeSource = RelativeSource.TemplatedParent }); sb.Children.Add(anim); t1.Storyboard = sb; vg.Transitions.Add(t1); VisualStateManager.SetVisualStateGroups(g, new List <VisualStateGroup> { vg }); return(g); }); SUT.Template = template; SUT.ApplyTemplate(); Assert.IsNotNull(anim); }
private bool TransitionEffectAwareGoToStateCore(FrameworkElement control, FrameworkElement stateGroupsRoot, string stateName, VisualStateGroup group, VisualState state, bool useTransitions, VisualTransition transition, bool animateWithTransitionEffect, VisualState previousState) { IEasingFunction generatedEasingFunction = null; if (animateWithTransitionEffect) { generatedEasingFunction = transition.GeneratedEasingFunction; var function2 = new DummyEasingFunction { DummyValue = FinishesWithZeroOpacity(control, stateGroupsRoot, state, previousState) ? 0.01 : 0.0 }; transition.GeneratedEasingFunction = function2; } var flag = base.GoToStateCore(control, stateGroupsRoot, stateName, group, state, useTransitions); if (animateWithTransitionEffect) { transition.GeneratedEasingFunction = generatedEasingFunction; if (flag) { AnimateTransitionEffect(stateGroupsRoot, transition); } } SetCurrentState(group, state); return(flag); }
private static VisualTransition FindTransition(VisualStateGroup group, VisualState previousState, VisualState state) { var str = previousState != null ? previousState.Name : string.Empty; var str2 = state != null ? state.Name : string.Empty; var num = -1; VisualTransition transition = null; foreach (VisualTransition transition2 in group.Transitions) { var num2 = 0; if (transition2.From == str) { num2++; } else if (!string.IsNullOrEmpty(transition2.From)) { continue; } if (transition2.To == str2) { num2 += 2; } else if (!string.IsNullOrEmpty(transition2.To)) { continue; } if (num2 > num) { num = num2; transition = transition2; } } return(transition); }
private static void AnimateTransitionEffect(FrameworkElement stateGroupsRoot, VisualTransition transition) { var element = new DoubleAnimation { Duration = transition.GeneratedDuration, EasingFunction = transition.GeneratedEasingFunction, From = 0.0, To = 1.0 }; var sb = new Storyboard { Duration = transition.GeneratedDuration, Children = { element } }; Storyboard.SetTarget(element, stateGroupsRoot); Storyboard.SetTargetProperty(element, new PropertyPath("(0).(1)", UIElement.EffectProperty, TransitionEffect.ProgressProperty)); if (stateGroupsRoot is Panel panel && panel.Background == null) { SetDidCacheBackground(panel, true); TransferLocalValue(panel, Panel.BackgroundProperty, CachedBackgroundProperty); panel.Background = Brushes.Transparent; } sb.Completed += delegate { if (Equals(GetTransitionEffectStoryboard(stateGroupsRoot), sb)) { FinishTransitionEffectAnimation(stateGroupsRoot); } }; SetTransitionEffectStoryboard(stateGroupsRoot, sb); sb.Begin(); }
/// <summary> /// Returns a value indicating whether the specified <paramref name="transition"/> /// can be treated as a default transition inside a collection. /// This is the case, if its <see cref="VisualTransition.From"/> and /// <see cref="VisualTransition.To"/> properties are <c>null</c>. /// </summary> /// <param name="transition">The transition to be checked.</param> /// <returns> /// <c>true</c> if the transition can be treated as default; false if not. /// </returns> public static bool IsDefault(this VisualTransition transition) { if (transition == null) { throw new ArgumentNullException(nameof(transition)); } return(transition.From == null && transition.To == null); }
/// <summary> /// Returns a value indicating whether the specified <paramref name="transition"/> /// or its underlying storyboard has a generated duration of 0. /// </summary> /// <param name="transition">The transition.</param> public static bool HasZeroDuration(this VisualTransition transition) { if (transition == null) { throw new ArgumentNullException(nameof(transition)); } return(transition.GeneratedDuration == new Duration(TimeSpan.Zero) && (transition.Storyboard == null || transition.Storyboard.Duration == new Duration(TimeSpan.Zero))); }
protected override void OnApplyTemplate() { base.OnApplyTemplate(); LabelsHiddenToShown = GetTemplateChild("LabelsHiddenToShown") as VisualTransition; LabelsShownToHidden = GetTemplateChild("LabelsShownToHidden") as VisualTransition; LabelsHidden = GetTemplateChild("LabelsHidden") as VisualState; LabelsHidden.Storyboard.Begin(); }
private Storyboard CreateDynamicTransitionStoryboard(VisualTransition currentTransition) { var storyboard = new Storyboard(); var easingFunction = currentTransition?.GeneratedEasingFunction; storyboard.Duration = currentTransition?.GeneratedDuration ?? new Duration(TimeSpan.Zero); FillDynamicTransitionStoryboard(storyboard, currentTransition, easingFunction); return(storyboard); }
private void OnCurrentTransitionStoryboardCompleted(VisualTransition currentTransition) { VisualStateSource.Verbose("Explicit storyboard completed. State: {0}", StateName); if (currentTransition.GetDynamicStoryboardCompleted() && ShouldRunStateStoryboard()) { VisualStateSource.Verbose("Running ToState storyboards."); Group.StartNewAndStopOldStoryboards(StateGroupsRoot, ToState.Storyboard); } currentTransition.SetExplicitStoryboardCompleted(true); }
private void Border_ManipulationDelta(object sender, ManipulationDeltaRoutedEventArgs e) { e.Handled = true; // 仅当 SplitView 处于 Overlay 模式时(窗口宽度最小时) if (mySplit.DisplayMode == SplitViewDisplayMode.Overlay) { if (PaneRoot == null) { // 找到 SplitView 控件中,模板的父容器 Grid grid = Utility.FindVisualChild <Grid>(mySplit); PaneRoot = grid.FindName("PaneRoot") as Grid; if (from_ClosedToOpenOverlayLeft_Transition == null) { // 获取 SplitView 模板中“视觉状态集合” IList <VisualStateGroup> stateGroup = VisualStateManager.GetVisualStateGroups(grid); // 获取 VisualTransition 对象的集合。 IList <VisualTransition> transitions = stateGroup[0].Transitions; // 找到 SplitView.IsPaneOpen 设置为 true 时,播放的 transition from_ClosedToOpenOverlayLeft_Transition = transitions?.Where(train => train.From == "Closed" && train.To == "OpenOverlayLeft").First(); // 遍历所有 transitions,打印到输出窗口 foreach (var tran in transitions) { Debug.WriteLine("From : " + tran.From + " To : " + tran.To); } } } // 默认为 Collapsed,所以先显示它 PaneRoot.Visibility = Visibility.Visible; // 当在 Border 上向右滑动,并且滑动的总距离需要小于 Panel 的默认宽度。否则会脱离左侧窗口,继续向右拖动 if (e.Cumulative.Translation.X >= 0 && e.Cumulative.Translation.X < mySplit.OpenPaneLength) { CompositeTransform ct = PaneRoot.RenderTransform as CompositeTransform; ct.TranslateX = (e.Cumulative.Translation.X - mySplit.OpenPaneLength); } } }
private bool IsTransitionBetterMatch(VisualTransition current, VisualTransition transitionToTest) { return(GetMatchPriorityNumber(current) < GetMatchPriorityNumber(transitionToTest)); sbyte GetMatchPriorityNumber(VisualTransition transition) { const sbyte PerfectMatch = 3, ToMatch = 2, FromMatch = 1, DefaultTransitionMatch = 0, NoMatch = -1; if (transition == null) { return(NoMatch); } VisualState transitionFromState = Group.GetStateByName(transition.From); VisualState transitionToState = Group.GetStateByName(transition.To); if (FromState == transitionFromState && ToState == transitionToState) { return(PerfectMatch); } else if (ToState == transitionToState && transitionFromState == null) { return(ToMatch); } else if (FromState == transitionFromState && transitionToState == null) { return(FromMatch); } else if (transition.IsDefault()) { return(DefaultTransitionMatch); } else { return(NoMatch); } } }
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 VisualTransition GetCurrentVisualTransition() { if (!UseTransitions) { return(null); } VisualTransition result = null; foreach (VisualTransition transition in Group.Transitions) { // We want to find the transition which matches the current states the best. // -> If there is a transition whose From/To properties match both states, use it. // If not, use a transition which matches only one state. // If none of that is found, use a transition without any From/To values (a default one). if (IsTransitionBetterMatch(result, transition)) { result = transition; } } return(result); }
private static VisualTransition Transition(Control control, int? @from = null, int?to = null, params int[] frames) { var transition = new VisualTransition(); var animationName = "transition"; if (@from is int f) { transition.From = "state" + f; animationName += "_from_state" + f; } if (to is int t) { transition.To = "state" + t; animationName += "_to_state" + t; } transition.Storyboard = AnimateTag(control, animationName, frames); return(transition); }
/// <summary> /// Transitions to another state by generating dynamic transitioning animations. /// </summary> /// <returns> /// Always returns <c>true</c>. /// </returns> protected override bool GoToStateCore() { VisualTransition currentTransition = GetCurrentVisualTransition(); Storyboard dynamicTransitionStoryboard = CreateDynamicTransitionStoryboard(currentTransition); if (currentTransition == null || currentTransition.HasZeroDuration()) { // Without a transition (or a transition which has no duration), the animations // defined in the ToState are supposed to start immediately. VisualStateSource.Verbose( "Not using transitions. Transitions available: {0}", currentTransition != null); PlayToStateAnimations(currentTransition); } else { VisualStateSource.Verbose("Using generated transition storyboard..."); PlayTransitionAnimations(currentTransition, dynamicTransitionStoryboard); } return(true); }
private void FillDynamicTransitionStoryboard( Storyboard storyboard, VisualTransition currentTransition, IEasingFunction easingFunction) { ISet <Timeline> currentGroupTimelines = FlattenTimelines(Group.GetCurrentStoryboards().ToArray()); ISet <Timeline> transitionTimelines = FlattenTimelines(currentTransition?.Storyboard); ISet <Timeline> toStateTimelines = FlattenTimelines(ToState.Storyboard); // If the transition already covers an animation, there is no need for that animation. // Also, if there is already a "To" animation, we must never use a "From" animation, // because the two animations would fight over the same property. currentGroupTimelines.ExceptWith(transitionTimelines); toStateTimelines.ExceptWith(transitionTimelines); currentGroupTimelines.ExceptWith(toStateTimelines); IList <Timeline> toTransitions = CreateToTransitions(toStateTimelines, easingFunction); foreach (var toTransition in toTransitions) { AddTimelineToCurrentStoryboard(toTransition); currentGroupTimelines.Remove(toTransition); } IList <Timeline> fromTransitions = CreateFromTransitions(currentGroupTimelines, easingFunction); foreach (var fromTransition in fromTransitions) { AddTimelineToCurrentStoryboard(fromTransition); } void AddTimelineToCurrentStoryboard(Timeline timeline) { if (timeline != null) { timeline.Duration = storyboard.Duration; storyboard.Children.Add(timeline); } } }
private static bool PrepareTransitionEffectImage(FrameworkElement stateGroupsRoot, bool useTransitions, VisualTransition transition) { var effect = transition == null ? null : GetTransitionEffect(transition); var flag = false; if (effect != null) { effect = effect.CloneCurrentValue(); if (useTransitions) { flag = true; var pixelWidth = (int)Math.Max(1.0, stateGroupsRoot.ActualWidth); var pixelHeight = (int)Math.Max(1.0, stateGroupsRoot.ActualHeight); var bitmap = new RenderTargetBitmap(pixelWidth, pixelHeight, 96.0, 96.0, PixelFormats.Pbgra32); bitmap.Render(stateGroupsRoot); var brush = new ImageBrush { ImageSource = bitmap }; effect.OldImage = brush; } var transitionEffectStoryboard = GetTransitionEffectStoryboard(stateGroupsRoot); if (transitionEffectStoryboard != null) { transitionEffectStoryboard.Stop(); FinishTransitionEffectAnimation(stateGroupsRoot); } if (useTransitions) { TransferLocalValue(stateGroupsRoot, UIElement.EffectProperty, CachedEffectProperty); stateGroupsRoot.Effect = effect; } } return(flag); }
/// <summary> /// Get the most appropriate transition between two states. /// </summary> /// <param name="element">Element being transitioned.</param> /// <param name="group">Group being transitioned.</param> /// <param name="from">VisualState being transitioned from.</param> /// <param name="to">VisualState being transitioned to.</param> /// <returns> /// The most appropriate transition between the desired states. /// </returns> internal static VisualTransition GetTransition(FrameworkElement element, VisualStateGroup group, VisualState from, VisualState to) { if (element == null) { throw new ArgumentNullException("element"); } if (group == null) { throw new ArgumentNullException("group"); } if (to == null) { throw new ArgumentNullException("to"); } VisualTransition best = null; VisualTransition defaultTransition = null; int bestScore = -1; IList <VisualTransition> transitions = (IList <VisualTransition>)group.Transitions; if (transitions != null) { foreach (VisualTransition transition in transitions) { if (defaultTransition == null && IsDefault(transition)) { defaultTransition = transition; continue; } int score = -1; VisualState transitionFromState = group.GetState(transition.From); VisualState transitionToState = group.GetState(transition.To); if (from == transitionFromState) { score += 1; } else if (transitionFromState != null) { continue; } if (to == transitionToState) { score += 2; } else if (transitionToState != null) { continue; } if (score > bestScore) { bestScore = score; best = transition; } } } return(best ?? defaultTransition); }
public static void SetDynamicStoryboardCompleted(this VisualTransition transition, bool dynamicStoryboardCompleted) { transition.SetValue(DynamicStoryboardCompletedProperty, dynamicStoryboardCompleted); }
public static bool GetDynamicStoryboardCompleted(this VisualTransition transition) { var _value = transition.GetValue(DynamicStoryboardCompletedProperty) ?? false; return(Convert.ToBoolean(_value)); }
public static void SetExplicitStoryboardCompleted(this VisualTransition transition, bool explicitStoryboardCompleted) { transition.SetValue(ExplicitStoryboardCompletedProperty, explicitStoryboardCompleted); }
private static Storyboard CreateLayoutTransitionStoryboard(VisualTransition transition, List <FrameworkElement> movingElements, Dictionary <FrameworkElement, double> oldOpacities) { var duration = transition?.GeneratedDuration ?? new Duration(TimeSpan.Zero); var generatedEasingFunction = transition?.GeneratedEasingFunction; var storyboard = new Storyboard { Duration = duration }; foreach (var element in movingElements) { if (element.Parent is WrapperCanvas parent) { var animation = new DoubleAnimation { From = 1.0, To = 0.0, Duration = duration, EasingFunction = generatedEasingFunction }; Storyboard.SetTarget(animation, parent); Storyboard.SetTargetProperty(animation, new PropertyPath(WrapperCanvas.SimulationProgressProperty)); storyboard.Children.Add(animation); parent.SimulationProgress = 1.0; var newRect = parent.NewRect; if (!IsClose(parent.Width, newRect.Width)) { var animation3 = new DoubleAnimation { From = newRect.Width, To = newRect.Width, Duration = duration }; Storyboard.SetTarget(animation3, parent); Storyboard.SetTargetProperty(animation3, new PropertyPath(FrameworkElement.WidthProperty)); storyboard.Children.Add(animation3); } if (!IsClose(parent.Height, newRect.Height)) { var animation5 = new DoubleAnimation { From = newRect.Height, To = newRect.Height, Duration = duration }; Storyboard.SetTarget(animation5, parent); Storyboard.SetTargetProperty(animation5, new PropertyPath(FrameworkElement.HeightProperty)); storyboard.Children.Add(animation5); } if (parent.DestinationVisibilityCache == Visibility.Collapsed) { var margin = parent.Margin; if (!IsClose(margin.Left, 0.0) || !IsClose(margin.Top, 0.0) || !IsClose(margin.Right, 0.0) || !IsClose(margin.Bottom, 0.0)) { var frames = new ObjectAnimationUsingKeyFrames { Duration = duration }; var frame2 = new DiscreteObjectKeyFrame { KeyTime = TimeSpan.Zero }; var thickness2 = new Thickness(); frame2.Value = thickness2; var keyFrame = frame2; frames.KeyFrames.Add(keyFrame); Storyboard.SetTarget(frames, parent); Storyboard.SetTargetProperty(frames, new PropertyPath(FrameworkElement.MarginProperty)); storyboard.Children.Add(frames); } if (!IsClose(parent.MinWidth, 0.0)) { var animation7 = new DoubleAnimation { From = 0.0, To = 0.0, Duration = duration }; Storyboard.SetTarget(animation7, parent); Storyboard.SetTargetProperty(animation7, new PropertyPath(FrameworkElement.MinWidthProperty)); storyboard.Children.Add(animation7); } if (!IsClose(parent.MinHeight, 0.0)) { var animation9 = new DoubleAnimation { From = 0.0, To = 0.0, Duration = duration }; Storyboard.SetTarget(animation9, parent); Storyboard.SetTargetProperty(animation9, new PropertyPath(FrameworkElement.MinHeightProperty)); storyboard.Children.Add(animation9); } } } } foreach (var element2 in oldOpacities.Keys) { if (element2.Parent is WrapperCanvas canvas2) { var a = oldOpacities[element2]; var num2 = canvas2.DestinationVisibilityCache == Visibility.Visible ? 1.0 : 0.0; if (!IsClose(a, 1.0) || !IsClose(num2, 1.0)) { var animation11 = new DoubleAnimation { From = a, To = num2, Duration = duration, EasingFunction = generatedEasingFunction }; Storyboard.SetTarget(animation11, canvas2); Storyboard.SetTargetProperty(animation11, new PropertyPath(UIElement.OpacityProperty)); storyboard.Children.Add(animation11); } } } return(storyboard); }
public static bool GetExplicitStoryboardCompleted(this VisualTransition transition) { return((bool)transition.GetValue(_explicitStoryboardCompletedPropertyKey.DependencyProperty)); }
public static void SetExplicitStoryboardCompleted(this VisualTransition transition, bool value) { transition.SetValue(_explicitStoryboardCompletedPropertyKey, value); }
private static bool IsDefaultTransition(VisualTransition transition) { return(transition.From == null && transition.To == null); }
private static Storyboard GenerateDynamicTransitionAnimations(FrameworkElement root, VisualStateGroup group, VisualState newState, VisualTransition transition) { Storyboard dynamic = new Storyboard(); if (transition != null && transition.GeneratedDuration != null) { dynamic.Duration = transition.GeneratedDuration; } else { dynamic.Duration = new Duration(TimeSpan.Zero); } Dictionary <TimelineDataToken, Timeline> currentAnimations = FlattenTimelines(group.GetCurrentStoryboards()); Dictionary <TimelineDataToken, Timeline> transitionAnimations = FlattenTimelines(transition != null ? transition.Storyboard : null); Dictionary <TimelineDataToken, Timeline> newStateAnimations = FlattenTimelines(newState.Storyboard); // Remove any animations that the transition already animates. // There is no need to create an interstitial animation if one already exists. foreach (KeyValuePair <TimelineDataToken, Timeline> pair in transitionAnimations) { currentAnimations.Remove(pair.Key); newStateAnimations.Remove(pair.Key); } // Generate the "to" animations foreach (KeyValuePair <TimelineDataToken, Timeline> pair in newStateAnimations) { // The new "To" Animation -- the root is passed as a reference point for name // lookup. Timeline toAnimation = GenerateToAnimation(root, pair.Value, true); // If the animation is of a type that we can't generate transition animations // for, GenerateToAnimation will return null, and we should just keep going. if (toAnimation != null) { toAnimation.Duration = dynamic.Duration; dynamic.Children.Add(toAnimation); } // Remove this from the list of current state animations we have to consider next currentAnimations.Remove(pair.Key); } // Generate the "from" animations foreach (KeyValuePair <TimelineDataToken, Timeline> pair in currentAnimations) { Timeline fromAnimation = GenerateFromAnimation(pair.Value); if (fromAnimation != null) { fromAnimation.Duration = dynamic.Duration; string targetName = Storyboard.GetTargetName(pair.Value); Storyboard.SetTargetName(fromAnimation, targetName); // If the targetName of the existing Animation is known, then look up the // target DependencyObject target = String.IsNullOrEmpty(targetName) ? null : root.FindName(targetName) as DependencyObject; if (target != null) { Storyboard.SetTarget(fromAnimation, target); } string propertyName = Storyboard.GetTargetProperty(pair.Value); Storyboard.SetTargetProperty(fromAnimation, propertyName); dynamic.Children.Add(fromAnimation); } } return(dynamic); }
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); }
internal static bool IsDefault(VisualTransition transition) { return(transition.From == null && transition.To == null); }
public IngameUI() { this.transitions = new VisualTransition(); this.hud = new Dictionary<InputState.Move, DirectionalIndicator>(); }
private bool GoToStateInternal(FrameworkElement control, FrameworkElement stateGroupsRoot, VisualStateGroup group, VisualState state, bool useTransitions) { if (stateGroupsRoot == null) { throw new ArgumentNullException("stateGroupsRoot"); } if (state == null) { throw new ArgumentNullException("state"); } if (group == null) { throw new InvalidOperationException(); } VisualState lastState = group.CurrentState; 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 ? GetTransition(stateGroupsRoot, group, lastState, state) : null; // 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(stateGroupsRoot, transition.Storyboard, state.Storyboard); } else { group.StartNewThenStopOld(stateGroupsRoot, state.Storyboard); } // Fire both CurrentStateChanging and CurrentStateChanged events RaiseCurrentStateChanging(group, lastState, state, control, stateGroupsRoot); RaiseCurrentStateChanged(group, lastState, state, control, stateGroupsRoot); } else { if (transition.Storyboard != null /* && transition.ExplicitStoryboardCompleted == true*/) { EventHandler transitionCompleted = null; transitionCompleted = new EventHandler(delegate(object sender, EventArgs e) { if (ShouldRunStateStoryboard(control, stateGroupsRoot, state, group)) { group.StartNewThenStopOld(stateGroupsRoot, state.Storyboard); } RaiseCurrentStateChanged(group, lastState, state, control, stateGroupsRoot); transition.Storyboard.Completed -= transitionCompleted; //transition.ExplicitStoryboardCompleted = true; }); // hook up explicit storyboard's Completed event handler //transition.ExplicitStoryboardCompleted = false; transition.Storyboard.Completed += transitionCompleted; } // Start transition and dynamicTransition Storyboards // Stop any previously running Storyboards group.StartNewThenStopOld(stateGroupsRoot, transition.Storyboard); RaiseCurrentStateChanging(group, lastState, state, control, stateGroupsRoot); } group.SetCurrentState(state); return(true); }
private void PlayToStateAnimations(VisualTransition currentTransition) { // Immediately start playing the ToState animations. Group.StartNewAndStopOldStoryboards( StateGroupsRoot, currentTransition?.Storyboard, ToState.Storyboard); }