public void BeginAnimation( DependencyProperty dp, AnimationTimeline animation, HandoffBehavior handoffBehavior) { throw new NotImplementedException(); }
private void UpdateThumb() { if (_ThumbTranslate != null && _SwitchTrack != null && _ThumbIndicator != null) { double destination = IsChecked.GetValueOrDefault() ? ActualWidth - (_SwitchTrack.Margin.Left + _SwitchTrack.Margin.Right + _ThumbIndicator.ActualWidth) : 0; _thumbAnimation = new DoubleAnimation(); _thumbAnimation.To = destination; _thumbAnimation.Duration = TimeSpan.FromMilliseconds(500); _thumbAnimation.EasingFunction = new ExponentialEase() { Exponent = 9 }; _thumbAnimation.FillBehavior = FillBehavior.Stop; AnimationTimeline currentAnimation = _thumbAnimation; _thumbAnimation.Completed += (sender, e) => { if (_thumbAnimation != null && currentAnimation == _thumbAnimation) { _ThumbTranslate.X = destination; _thumbAnimation = null; } }; _ThumbTranslate.BeginAnimation(TranslateTransform.XProperty, _thumbAnimation); } }
void da_Completed(object sender, EventArgs e) { AnimationTimeline timeline = (sender as AnimationClock).Timeline; /* !!! 通过附加属性把UI对象取回 !!! */ object uiElement = Storyboard.GetTarget(timeline); TextBlock t = uiElement as TextBlock; StackPanel sp = t.Parent as StackPanel; sp.Children.Remove(t); if (sp.Children.Count <= 0) { if (win != null) { win.Close(); } win = null; return; } win.Left = SystemParameters.WorkArea.Width - win.Width; win.Top = SystemParameters.WorkArea.Height - win.Height - 20; }
/// <summary> /// Starts an animation for a DependencyProperty. The animation will /// begin when the next frame is rendered. /// </summary> /// <param name="dp"> /// The DependencyProperty to animate. /// </param> /// <param name="animation"> /// <para>The AnimationTimeline to used to animate the property.</para> /// <para>If the AnimationTimeline's BeginTime is null, any current animations /// will be removed and the current value of the property will be held.</para> /// <para>If this value is null, all animations will be removed from the property /// and the property value will revert back to its base value.</para> /// </param> /// <param name="handoffBehavior"> /// Specifies how the new animation should interact with any current /// animations already affecting the property value. /// </param> public void BeginAnimation(DependencyProperty dp, AnimationTimeline animation, HandoffBehavior handoffBehavior) { if (dp == null) { throw new ArgumentNullException("dp"); } if (!AnimationStorage.IsPropertyAnimatable(this, dp)) { #pragma warning disable 56506 // Suppress presharp warning: Parameter 'dp' to this public method must be validated: A null-dereference can occur here. throw new ArgumentException(SR.Get(SRID.Animation_DependencyPropertyIsNotAnimatable, dp.Name, this.GetType()), "dp"); #pragma warning restore 56506 } if (animation != null && !AnimationStorage.IsAnimationValid(dp, animation)) { throw new ArgumentException(SR.Get(SRID.Animation_AnimationTimelineTypeMismatch, animation.GetType(), dp.Name, dp.PropertyType), "animation"); } if (!HandoffBehaviorEnum.IsDefined(handoffBehavior)) { throw new ArgumentException(SR.Get(SRID.Animation_UnrecognizedHandoffBehavior)); } if (IsSealed) { throw new InvalidOperationException(SR.Get(SRID.IAnimatable_CantAnimateSealedDO, dp, this.GetType())); } AnimationStorage.BeginAnimation(this, dp, animation, handoffBehavior); }
public static void AnimatePropertyTo <T, R, AT>(this T element, Expression <Func <T, R> > p, R finalValue, double duration, bool autoReverse) where T : IAnimatable where AT : AnimationTimeline { AnimationTimeline animation = (AnimationTimeline)Activator.CreateInstance(typeof(AT)); if (animation == null) { return; } var prop = (p.Body as MemberExpression).Member.Name; var currentValue = p.Compile()(element); DependencyPropertyDescriptor dFrom = DependencyPropertyDescriptor.FromName("From", animation.GetType(), animation.GetType()); animation.SetValue(dFrom.DependencyProperty, currentValue); DependencyPropertyDescriptor dTo = DependencyPropertyDescriptor.FromName("To", animation.GetType(), animation.GetType()); animation.SetValue(dTo.DependencyProperty, finalValue); animation.Duration = new Duration(TimeSpan.FromSeconds(duration)); animation.AutoReverse = autoReverse; DependencyPropertyDescriptor d = DependencyPropertyDescriptor.FromName(prop, typeof(T), typeof(T)); element.BeginAnimation(d.DependencyProperty, null); element.BeginAnimation(d.DependencyProperty, animation); }
public void AddAnimationTrack(string layer) { var track = CreateInstance <AnimationTrack>(); USUndoManager.RegisterCreatedObjectUndo(track, "Add New Track"); track.Layer = MecanimAnimationUtility.LayerNameToIndex(AnimationTimeline.AffectedObject.gameObject, layer); USUndoManager.RegisterCompleteObjectUndo(AnimationTimeline, "Add New Track"); AnimationTimeline.AddTrack(track); var hierarchyItem = CreateInstance(typeof(USAnimationTimelineTrackHierarchyItem)) as USAnimationTimelineTrackHierarchyItem; USUndoManager.RegisterCreatedObjectUndo(hierarchyItem, "Add New Track"); hierarchyItem.AnimationTrack = track; hierarchyItem.AnimationTimelineHierarchy = this; hierarchyItem.AnimationTimeline = AnimationTimeline; hierarchyItem.Initialize(AnimationTimeline); USUndoManager.RegisterCompleteObjectUndo(USHierarchy, "Add New Track"); USHierarchy.RootItems.Add(hierarchyItem as IUSHierarchyItem); if (AnimationTimeline.AnimationTracks.Count == 1) { IsExpanded = true; } }
/// <summary> /// Sets the animation out for the message. /// </summary> /// <param name="animation"></param> public void SetAnimationOut(AnimationTimeline animation) { if (this.Message is INotificationAnimation notificationAnimation) { notificationAnimation.AnimationOut = animation; } }
private static AnimationClock Animate( DependencyObject animatable, DependencyProperty prop, AnimationTimeline anim, int duration, double?accel, double?decel, EventHandler func) { anim.AccelerationRatio = accel.GetValueOrDefault(0.0); anim.DecelerationRatio = decel.GetValueOrDefault(0.0); anim.Duration = (Duration)TimeSpan.FromMilliseconds((double)duration); anim.Freeze(); AnimationClock animClock = anim.CreateClock(); animClock.Completed += new EventHandler(animClock_Completed); if (func != null) { animClock.Completed += func; } animClock.Controller.Begin(); Animator.ClearAnimation(animatable, prop); ((IAnimatable)animatable).ApplyAnimationClock(prop, animClock); return(animClock); void animClock_Completed(object sender, EventArgs e) { Animator.ClearAnimation(animatable, prop); // ISSUE: method pointer animClock.Completed -= new EventHandler((object)this, __methodptr(\u003CAnimate\u003Eg__animClock_Completed\u007C0)); } }
/// <summary> /// Sets the animation in for the message. /// </summary> /// <param name="animation"></param> public void SetAnimationIn(AnimationTimeline animation) { if (this.Message is INotificationAnimation) { ((INotificationAnimation)this.Message).AnimationIn = animation; } }
private void Animation_Completed(object sender, EventArgs e) { AnimationTimeline timeline = (sender as AnimationClock).Timeline; Grid uIElement = Storyboard.GetTarget(timeline) as Grid; positionDic[uIElement.Name].CanvasLeft = Canvas.GetLeft(uIElement); positionDic[uIElement.Name].CanvasTop = Canvas.GetTop(uIElement); uIElement.BeginAnimation(Canvas.LeftProperty, null); Canvas.SetLeft(uIElement, positionDic[uIElement.Name].CanvasLeft); //Border b=null; //foreach (var item in borderMap) //{ // var border = item.Key; // if (Canvas.GetLeft(uIElement) == Canvas.GetLeft(border) && // Canvas.GetTop(uIElement) == Canvas.GetTop(border)) // { // b = border; // } //} //if (b != null) //{ // borderMap[b] = uIElement; //} }
private void RemoveAnimationTrack() { USUndoManager.RegisterCompleteObjectUndo(AnimationTimeline, "Remove Track"); AnimationTimeline.RemoveTrack(AnimationTrack); AnimationTimelineHierarchy.RemoveAnimationTrack(AnimationTrack); }
/// <summary> /// Enqueues the specified element. /// </summary> /// <param name="element">The element.</param> /// <param name="animation">The animation.</param> public void Enqueue(FrameworkElement element, AnimationTimeline animation) { if (element != null && animation != null) { this.animationQueue.Enqueue(new AnimationItem(element, animation)); } }
private void AddAnimation(double beginTime, UIElement element, AnimationTimeline anim, DependencyProperty property) { anim.BeginTime = TimeSpan.FromSeconds(beginTime); Storyboard.SetTarget(anim, element); Storyboard.SetTargetProperty(anim, new PropertyPath(property)); storyboard.Children.Add(anim); }
private void CreateFadeInAnimation() { fadeInAnimation = new DoubleAnimation(0, 1, new Duration(TimeSpan.FromSeconds(2))) { DecelerationRatio = 0.7, FillBehavior = FillBehavior.HoldEnd }; }
private void CreateEndlessFadeAnimation() { endlessFadeAnimation = new DoubleAnimation(0, 0.4, new Duration(TimeSpan.FromSeconds(0.2))) { AutoReverse = true }; endlessFadeAnimation.Completed += FadeInAnimation_Completed; }
private void CreateHideSearchAnimation() { searchHideAnimation = new DoubleAnimation(1, 0.0, new Duration(TimeSpan.FromSeconds(0.5))) { FillBehavior = FillBehavior.HoldEnd }; searchHideAnimation.Completed += SearchHideAnimation_Completed; }
/// <inheritdoc/> public override void AddToStoryboard(Storyboard storyBoard, AnimationTimeline timeline = null) { var animation = timeline ?? Get(); Storyboard.SetTargetProperty(animation, new PropertyPath("Opacity")); storyBoard.Children.Add(animation); }
public static Storyboard CreateStoryboard(AnimationTimeline timeline) { Storyboard storyboard = new Storyboard(); storyboard.Children.Add(timeline); return(storyboard); }
/// <summary> /// Sets the animation out for the message. /// </summary> /// <param name="builder">The builder.</param> /// <param name="animation">The animation time line.</param> /// <returns>Returns the notification message builder.</returns> public static NotificationMessageBuilder AnimationOut( this NotificationMessageBuilder builder, AnimationTimeline animation) { builder.SetAnimationOut(animation); return(builder); }
static void SlideIn(FrameworkElement frameworkElement) { AnimationTimeline marginAnimation = CreateSlideInAnimation(frameworkElement); frameworkElement.BeginAnimation(FrameworkElement.MarginProperty, marginAnimation); frameworkElement.Visibility = Visibility.Visible; DisableHiddenFrameworkElement(frameworkElement); }
private void remove(object sender, EventArgs e) { AnimationTimeline timeline = (sender as AnimationClock).Timeline; TextBlock uiElement = Storyboard.GetTarget(timeline) as TextBlock; stackpanel.Children.Remove(uiElement); stackpanel.UpdateLayout(); }
/// <summary> /// Function for starting animation /// </summary> public void Animate() { AnimationTimeline animation = null; if (ThicknessProperty != null) { var thickness = new Thickness(); thickness.Left = Element.Margin.Left; thickness.Top = Element.Margin.Top; thickness.Right = Element.Margin.Right; thickness.Bottom = Element.Margin.Bottom; for (int i = 0; i < ThicknessProperty.Length; i++) { switch (ThicknessProperty[i]) { case ThicknessAnimationProperty.Left: thickness.Left = State ? EndValue[i] : StartValue[i]; break; case ThicknessAnimationProperty.Top: thickness.Top = State ? EndValue[i] : StartValue[i]; break; case ThicknessAnimationProperty.Right: thickness.Right = State ? EndValue[i] : StartValue[i]; break; case ThicknessAnimationProperty.Bottom: thickness.Bottom = State ? EndValue[i] : StartValue[i]; break; } } animation = new ThicknessAnimation(thickness, Time); } else { animation = new DoubleAnimation { From = State ? StartValue[0] : EndValue[0], To = State ? EndValue[0] : StartValue[0], Duration = Time }; } try { Element.BeginAnimation(AnimateProperty, animation); } catch (Exception) { System.Diagnostics.Debug.WriteLine($"{Key} Error"); } State = !State; }
/// <inheritdoc/> public override void AddToStoryboard(Storyboard storyBoard, AnimationTimeline timeline = null) { var animation = timeline ?? Get(); Storyboard.SetTargetName(animation, RENDERTRANSFORM_OBJECT_NAME); Storyboard.SetTargetProperty(animation, new PropertyPath(Direction == RenderTransformDirection.Horizontal ? "X" : "Y")); storyBoard.Children.Add(animation); }
private void CreateFadeOutAnimation() { fadeOutAnimation = new DoubleAnimation(0, new Duration(TimeSpan.FromSeconds(3))) { DecelerationRatio = 0.7, FillBehavior = FillBehavior.Stop }; fadeOutAnimation.Completed += FadeAnimation_Completed; }
public static void DoAnimation(this FrameworkElement targetElement, AnimationTimeline animation, DependencyProperty targetProperty) { Storyboard storyboard = new Storyboard(); Storyboard.SetTarget(animation, targetElement); Storyboard.SetTargetProperty(animation, new PropertyPath(targetProperty)); storyboard.Children.Add(animation); storyboard.Begin(); }
public void RemoveAnimationTrack(AnimationTrack track) { USUndoManager.RegisterCompleteObjectUndo(AnimationTimeline, "Add New Track"); AnimationTimeline.RemoveTrack(track); USUndoManager.RegisterCompleteObjectUndo(USHierarchy, "Add New Track"); USHierarchy.RootItems.Remove(USHierarchy.RootItems.Where(item => ((USAnimationTimelineTrackHierarchyItem)item).AnimationTrack == track).First()); USUndoManager.DestroyImmediate(track); }
public MainWindow() { InitializeComponent(); TransparencyAnimation = new DoubleAnimation { From = 0, To = 1, Duration = TimeSpan.FromSeconds(0.5) }; }
public static void BeginAnimation(IAnimatable Item, DependencyProperty dp, AnimationTimeline ATL, object FromValue, object ToValue, Action OnCompleted, SetExtentAnimationTimelineDelegate SetExtentValue) { if (ToValue == null) { return; } if (Item != null && Item is DependencyObject) { ATL.FillBehavior = FillBehavior.HoldEnd; if (SetExtentValue != null) { SetExtentValue(ATL); } FillBehavior StatusValue = ATL.FillBehavior; ATL.FillBehavior = FillBehavior.Stop; DependencyObject ConvertItem = Item as DependencyObject; object TargetValue = null; if (StatusValue == FillBehavior.Stop || ATL.AutoReverse) { if (FromValue == null) { TargetValue = ConvertItem.GetValue(dp); } else { TargetValue = FromValue; } } else { TargetValue = ToValue; } ATL.Completed += new EventHandler( delegate(object sender, EventArgs e) { ConvertItem.SetValue(dp, TargetValue); object CurValue = ConvertItem.GetValue(dp); if (TargetValue != null && !TargetValue.Equals(CurValue)) { return; } if (OnCompleted != null) { OnCompleted(); } }); Item.BeginAnimation(dp, ATL, HandoffBehavior.SnapshotAndReplace); } }
public static void Add(DependencyObject element, AnimationKind type, AnimationTimeline animation) { switch (type) { case AnimationKind.BackgroundColor: Storyboard.SetTargetProperty(animation, new PropertyPath("Background.Color")); break; case AnimationKind.BorderColor: Storyboard.SetTargetProperty(animation, new PropertyPath("(Border.BorderBrush).(SolidColorBrush.Color)")); break; case AnimationKind.BackgroundOpacity: Storyboard.SetTargetProperty(animation, new PropertyPath("Background.Opacity")); break; case AnimationKind.DropShadowOpacity: Storyboard.SetTargetProperty(animation, new PropertyPath("Effect.Opacity")); break; case AnimationKind.DropShadowBlur: Storyboard.SetTargetProperty(animation, new PropertyPath("Effect.BlurRadius")); break; case AnimationKind.Opacity: Storyboard.SetTargetProperty(animation, new PropertyPath("Opacity")); break; case AnimationKind.TranslateX: Storyboard.SetTargetProperty(animation, new PropertyPath("(UIElement.RenderTransform).(TranslateTransform.X)")); break; case AnimationKind.TranslateY: Storyboard.SetTargetProperty(animation, new PropertyPath("(UIElement.RenderTransform).(TranslateTransform.Y)")); break; case AnimationKind.Margin: Storyboard.SetTargetProperty(animation, new PropertyPath("Margin")); break; case AnimationKind.Width: Storyboard.SetTargetProperty(animation, new PropertyPath("Width")); break; case AnimationKind.Height: Storyboard.SetTargetProperty(animation, new PropertyPath("Height")); break; default: break; } Storyboard.SetTarget(animation, element); sboard.Children.Add(animation); }
private void disappear(object sender, EventArgs e) { AnimationTimeline timeline = (sender as AnimationClock).Timeline; TextBlock uiElement = Storyboard.GetTarget(timeline) as TextBlock; //动画淡出 DoubleAnimation daV = new DoubleAnimation(1, 0, new Duration(TimeSpan.FromMilliseconds(animation_dis))); daV.Completed += new EventHandler(remove); Storyboard.SetTarget(daV, uiElement); uiElement.BeginAnimation(UIElement.OpacityProperty, daV); }
public void BeginAnimation(DependencyProperty property, AnimationTimeline animation) { BeginAnimation(property, animation, HandoffBehavior.SnapshotAndReplace); }
public void BeginAnimation(DependencyProperty property, AnimationTimeline animation, HandoffBehavior handoffBehavior) {}
protected internal AnimationClock(AnimationTimeline timeline) : base(timeline) {}
/// <summary> /// Creates a new empty AnimationClock to be used in a Clock /// tree. /// </summary> /// <param name="animation">The Animation used to define the new /// AnimationClock.</param> protected internal AnimationClock(AnimationTimeline animation) : base(animation) { }