C# Storyboard.Remove方法代码示例

        public static Task SmoothSetAsync(this FrameworkElement @this, DependencyProperty dp, double targetvalue,
            TimeSpan iDuration, CancellationToken iCancellationToken)
        {
            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
            DoubleAnimation anim = new DoubleAnimation(targetvalue, new Duration(iDuration));
            PropertyPath p = new PropertyPath("(0)", dp);
            Storyboard.SetTargetProperty(anim, p);
            Storyboard sb = new Storyboard();
            sb.Children.Add(anim);
            EventHandler handler = null;
            handler = delegate
            {
                sb.Completed -= handler;
                sb.Remove(@this);
                @this.SetValue(dp, targetvalue);
                tcs.TrySetResult(null);
            };
            sb.Completed += handler;
            sb.Begin(@this, true);

            iCancellationToken.Register(() =>
            {
                double v = (double)@this.GetValue(dp);  
                sb.Stop(); 
                sb.Remove(@this); 
                @this.SetValue(dp, v);
                tcs.TrySetCanceled();
            });

            return tcs.Task;
        }

    /// <summary>
    ///     Called when it's time to execute this storyboard action
    /// </summary> 
    internal override void Invoke( FrameworkElement containingFE, FrameworkContentElement containingFCE, Storyboard storyboard )
    { 
        Debug.Assert( containingFE != null || containingFCE != null, 
            "Caller of internal function failed to verify that we have a FE or FCE - we have neither." );
 
        if( containingFE != null )
        {
            storyboard.Remove(containingFE);
        } 
        else
        { 
            storyboard.Remove(containingFCE); 
        }
    } 

 public StepFiveControl(MainWindow window)
 {
     InitializeComponent();
     countdownControl.Initial(200, 170, 200,60);
     countdownControl.CountdownCompleted += () => {
         countdownControl.Visibility = Visibility.Collapsed;
         PlaySound();
     };
     sb = Resources["sb1"] as Storyboard;
     media.MediaEnded += OnSceneOver;
     media.MediaFailed += (sender, args) =>
     {
         _isMediaPlaying = false;
     };
     media.MediaOpened += (s, e) =>
     {
         //Panel.SetZIndex(media, 999);
         //border.Visibility = Visibility.Collapsed;
         //media.Opacity = 1;
         sb.Begin(media, true);
     };
     sb.Completed += (s, e) =>
     {
         sb.Remove(media);
         media.Opacity = 1;
     };
     Window = window;
 }

 public void Show()
 {
     XGrid.OpacityMask = this.Resources["OpenBrush"] as LinearGradientBrush;
     _stb = this.Resources["OpenBoard"] as Storyboard;
     _stb.Completed += (s, e) =>
     {
         if (_stb == null)
             return;
         _stb.Remove();
         _stb = null;
         XGrid.OpacityMask = null;
         _mainWindow.StateSwitch(State.Setting);
     };
     _stb.Begin();
 }

 public void Hide()
 {
     XGrid.OpacityMask = this.Resources["CloseBrush"] as LinearGradientBrush;
     _stb = this.Resources["CloseBoard"] as Storyboard;
     _stb.Completed += (s, e) =>
     {
         if (_stb == null)
             return;
         _stb.Remove();
         _stb = null;
         XGrid.OpacityMask = this.Resources["OpenBrush"] as LinearGradientBrush;
         SettingInstant.Save();
         _mainWindow.StateSwitch(State.Normal);
     };
     _stb.Begin();
 }

 public static void SmoothSet(this FrameworkElement @this, DependencyProperty dp, double targetvalue, TimeSpan iDuration)
 {
     DoubleAnimation anim = new DoubleAnimation(targetvalue, new Duration(iDuration));
     PropertyPath p = new PropertyPath("(0)", dp);
     Storyboard.SetTargetProperty(anim, p);
     Storyboard sb = new Storyboard();
     sb.Children.Add(anim);
     EventHandler handler = null;
     handler = delegate
     {
         sb.Completed -= handler;
         sb.Remove(@this);
         @this.SetValue(dp, targetvalue);
     };
     sb.Completed += handler;
     sb.Begin(@this, true);
 }

        public void StoryboardBasicTest()
        {
            DoubleAnimation widthAnimation = new DoubleAnimation { To = 100 };
            DoubleAnimation heightAnimation = new DoubleAnimation { From = 100 };

            Storyboard storyboard = new Storyboard();
            storyboard.Children.Add(widthAnimation);
            storyboard.Children.Add(heightAnimation);

            FrameworkElement element = new FrameworkElement { Width = 0, Height = 0 };

            Storyboard.SetTarget(widthAnimation, element);
            Storyboard.SetTargetProperty(widthAnimation, PropertyPath.FromDependencyProperty(FrameworkElement.WidthProperty));

            Storyboard.SetTarget(heightAnimation, element);
            Storyboard.SetTargetProperty(heightAnimation, PropertyPath.FromDependencyProperty(FrameworkElement.HeightProperty));

            TestRootClock rootClock = new TestRootClock();
            element.SetAnimatableRootClock(new AnimatableRootClock(rootClock, true));
            storyboard.Begin(element);

            rootClock.Tick(TimeSpan.FromSeconds(0));
            Assert.AreEqual(0, element.Width);
            Assert.AreEqual(100, element.Height);

            rootClock.Tick(TimeSpan.FromSeconds(0.1));
            Assert.AreEqual(10, element.Width);
            Assert.AreEqual(90, element.Height);

            rootClock.Tick(TimeSpan.FromSeconds(1));
            Assert.AreEqual(100, element.Width);
            Assert.AreEqual(0, element.Height);

            storyboard.Seek(element, TimeSpan.FromSeconds(0.5));
            rootClock.Tick(TimeSpan.FromSeconds(1));
            Assert.AreEqual(50, element.Width);
            Assert.AreEqual(50, element.Height);

            storyboard.Remove(element);
            rootClock.Tick(TimeSpan.FromSeconds(1));
            Assert.AreEqual(0, element.Width);
            Assert.AreEqual(0, element.Height);
        }

 public StepOneControl(MainWindow window)
 {
     InitializeComponent();
     sb = Resources["sb1"] as Storyboard;
     timer.Interval = new TimeSpan(0, 0, Appconfig.AutoPlayInterval);
     timer.Tick += timer_Tick;
     timer.Start();
     media.MediaEnded += OnSceneOver;
     media.MediaFailed += (sender, args) =>
     {
         _isMediaPlaying = false;
     };
     media.MediaOpened += (s, e) =>
     {
         //Panel.SetZIndex(media, 999);
         //border.Visibility = Visibility.Collapsed;
         //media.Opacity = 1;
         sb.Begin(media, true);
     };
     sb.Completed += (s, e) =>
     {
         sb.Remove(media);
         media.Opacity = 1;
     };
     Window = window;
     ElementAnimControl.LeftCount = new int[7] { 4, 3, 3, 3, 3, 3, 3 };
     ElementAnimControl.RightCount = new int[7] { 3, 3, 3, 3, 3, 3, 4 };
     ElementAnimControl.Initial(Appconfig.TiltImagesDirName);
     ElementAnimControl.PlayRightNextPage += i =>
     {
         HandOption.Instance.Page1State = HandDirection.R;
         window.Pause();
         _isMediaPlaying = true;
         ShowMedia();
     };
     ElementAnimControl.PlayLeftNextPage += i =>
     {
         HandOption.Instance.Page1State = HandDirection.L;
         window.Pause();
         _isMediaPlaying = true;
         ShowMedia();
     };
 }

        /*******************************************************************************************
         * btn_newGame_Click
         * - Função iniciar novo jogo
        *******************************************************************************************/
        private void btn_newGame_Click(object sender, RoutedEventArgs e)
        {
            storyboard = this.TryFindResource("luckyNum_anim") as Storyboard;

            storyboard.Remove(luckyRouletteNum);
            /*
            foreach (Image chip in winningChips_list)
            {
                storyboard.Stop(chip);
            }

            storyboard.SkipToFill();
            */

            clearBets();
            btn_newGame.Visibility = Visibility.Hidden;
            bola.Visibility = Visibility.Hidden;
            openTable.IsEnabled = true;
            chipGrid.IsEnabled = true;
            lbl_hint.Content = "Selecione a ficha para apostar!";
        }

 public void LoadRightImage()
 {
     Image2.Source = new BitmapImage(new Uri(_imagePathList[_current - 1], UriKind.RelativeOrAbsolute));
     Image1.OpacityMask = this.Resources["CloseBrush"] as LinearGradientBrush;
     _stb = this.Resources["CloseBoard"] as Storyboard;
     _stb.Completed += (s, e) =>
     {
         if (_stb == null)
             return;
         _stb.Remove();
         _stb = null;
         Image1.Source = Image2.Source;
         Image1.OpacityMask = null;
         _current--;
         _mainWindow.StateSwitch(State.Normal);
         _mainWindow.CheckButton();
     };
     _stb.Begin();
 }

        void PanelLayoutUpdated(object sender, EventArgs e)
        {
            // At this point, the panel has moved the children to the new locations, but hasn't

              // been rendered

              foreach (UIElement child in _panel.Children)
              {

              // Figure out where child actually is right now. This is a combination of where the

              // panel put it and any render transform currently applied

            //  Point currentPosition = child.TransformToAncestor(_panel).Transform(new Point());
             Vector vectorNow =  VisualTreeHelper.GetOffset(child);
             Point currentPosition = new Point(vectorNow.X, vectorNow.Y);

              // See what transform is being applied

              Transform currentTransform = child.RenderTransform;

              // Compute where the panel actually arranged it to

              Point arrangePosition = currentPosition;

              // If we had previously stored an arrange position, see if it has moved

              if (child.GetValue(PreviousRectProperty) != DependencyProperty.UnsetValue)
              {
                  var savedRect = PanelAnimation.GetPreviousRect(child);

                  Point savedArrangePosition = savedRect.TopLeft;

                  // If the arrange position hasn't changed, then we've already set up animations, etc

                  // and don't need to do anything

                  if (!AreReallyClose(savedArrangePosition, arrangePosition))
                  {

                      // If we apply the current transform to the saved arrange position, we'll see where

                      // it was last rendered

                     // Point lastRenderPosition = currentTransform.Transform(savedArrangePosition);

                      Point lastRenderPosition = savedArrangePosition;

                      // Transform the child from the new location back to the old position

                      TranslateTransform newTransform = new TranslateTransform();

                      child.RenderTransform = newTransform;

                      Storyboard transition = new Storyboard();
                      var xAnimation = MakeAnimation(lastRenderPosition.X - arrangePosition.X);
                      var yAnimation = MakeAnimation(lastRenderPosition.Y - arrangePosition.Y);

                      Storyboard.SetTarget(xAnimation, child);
                      Storyboard.SetTargetProperty(xAnimation, new PropertyPath("(UIElement.RenderTransform).(TranslateTransform.X)"));
                     // Storyboard.SetTarget(child, xAnimation);

                      Storyboard.SetTarget(yAnimation, child);
                      Storyboard.SetTargetProperty(yAnimation, new PropertyPath("(UIElement.RenderTransform).(TranslateTransform.Y)"));
                    //  Storyboard.SetTarget( yAnimation);
                      transition.Children.Add(xAnimation);
                      transition.Children.Add(yAnimation);
                      transition.Duration = TimeSpan.FromMilliseconds(1000);
                      transition.Completed += (s, ev) => {
                       // transition.be
                          transition.Remove();
                      };
                      transition.Begin((FrameworkElement)child,true);

                      //transition.Children.Add()

                      // Decay the transformation with an animation

                    //  newTransform.BeginAnimation(TranslateTransform.XProperty, MakeAnimation(lastRenderPosition.X - arrangePosition.X));

            //                      newTransform.BeginAnimation(TranslateTransform.YProperty, MakeAnimation(lastRenderPosition.Y - arrangePosition.Y));

                  }

              }

              // Save off the previous arrange position

            //  child.SetValue(SavedArrangePositionProperty, arrangePosition);
              PanelAnimation.SetPreviousRect(child, new Rect(arrangePosition, child.DesiredSize));

              }
        }

        private bool TrySetVerticalOffset(double offset)
        {
            if (_IsScrolling)
                return false;

            _IsScrolling = true;

            double oldoff = VerticalOffset;
            double newoffset = CalculateVerticalOffset(offset);

            double delta = Math.Abs(oldoff - newoffset);

            if (delta == 0)
            {
                _IsScrolling = false;
                return false;
            }

            if (delta > ViewportHeight)
            {
                VerticalOffset = newoffset;
                if (ScrollOwner != null)
                    ScrollOwner.InvalidateScrollInfo();
 
                _IsScrolling = false;
                _ScrollingOffset = 0;
                InvalidateMeasure();
               
            }
            else
            {
                double deltatrans =  (oldoff - newoffset) * ItemHeight;
                DoubleAnimation anim = new DoubleAnimation(deltatrans, new Duration(TimeToTransition));
                PropertyPath p = new PropertyPath("(0).(1)", RenderTransformProperty, TranslateTransform.YProperty);
                Storyboard.SetTargetProperty(anim, p);
                Storyboard sb = new Storyboard();
                sb.Children.Add(anim);
                EventHandler handler = null;
                handler = delegate
                {
                    sb.Completed -= handler;
                    sb.Remove(this);
                    _transform.Y = deltatrans;
                    VerticalOffset = newoffset;

                    _IsScrolling = false;
                    _ScrollingOffset = 0;

                    InvalidateMeasure();
                    //_transform.X = 0;

                    if (ScrollOwner != null)
                        ScrollOwner.InvalidateScrollInfo();
                };
                sb.Completed += handler;
                _IsScrolling = true;

                if (oldoff - newoffset > 0)
                    _ScrollingOffset = (int)(newoffset - oldoff);

                VerticalOffset = newoffset;
                InvalidateMeasure();

                Action Ba = () => sb.Begin(this, true);
                this.Dispatcher.BeginInvoke(Ba, DispatcherPriority.Input);
            }
            return true;
        }

        private void FlyingGet(List<Card.Ruban> rubans,
            double x1, double y1, double x2, double y2, bool fade)
        {
            //<Canvas x:Name="cardLock" Canvas.Left="80" Canvas.Top="90"
            // Width="450" Height="125" Background="LightCoral"/>
            Canvas flyingBody = new Canvas() { Width = 450, Height = 125 };
            //flyingBody.Background = new SolidColorBrush(Colors.LightCoral);
            Canvas.SetLeft(flyingBody, x1);
            Canvas.SetTop(flyingBody, y1);
            flyingBody.Visibility = Visibility.Visible;
            // Clear Tux
            int sz = rubans.Count;
            for (int i = 0; i < sz; ++i)
            {
                rubans[i].Index = i;
                Canvas.SetLeft(rubans[i], i * 30);
                flyingBody.Children.Add(rubans[i]);
            }
            lock (aniCanvas.Children)
            {
                aniCanvas.Children.Add(flyingBody);
            }
            DoubleAnimation aniAppr = new DoubleAnimation() { From = 0, To = 1, Duration = SURA };
            Storyboard.SetTarget(aniAppr, flyingBody);
            Storyboard.SetTargetProperty(aniAppr, new PropertyPath(UIElement.OpacityProperty));
            aniAppr.BeginTime = TimeSpan.FromSeconds(0);

            DoubleAnimation aniX = new DoubleAnimation() { From = x1, To = x2, Duration = DURA };
            Storyboard.SetTarget(aniX, flyingBody);
            Storyboard.SetTargetProperty(aniX, new PropertyPath(Canvas.LeftProperty));
            aniX.BeginTime = SURA;

            DoubleAnimation aniY = new DoubleAnimation() { From = y1, To = y2, Duration = DURA };
            Storyboard.SetTarget(aniY, flyingBody);
            Storyboard.SetTargetProperty(aniY, new PropertyPath(Canvas.TopProperty));
            aniY.BeginTime = SURA;

            Storyboard sb = new Storyboard();
            sb.Children.Add(aniAppr);
            sb.Children.Add(aniX);
            sb.Children.Add(aniY);

            if (fade)
            {
                DoubleAnimation aniFade = new DoubleAnimation() { From = 1, To = 0, Duration = SURA };
                Storyboard.SetTarget(aniFade, flyingBody);
                Storyboard.SetTargetProperty(aniFade, new PropertyPath(UIElement.OpacityProperty));
                aniFade.BeginTime = SURA + DURA;
                sb.Children.Add(aniFade);
            }

            sb.Begin();
            new Thread(delegate()
            {
                if (fade)
                    Thread.Sleep(SURA + DURA + SURA);
                else
                    Thread.Sleep(SURA + DURA);
                aniCanvas.Dispatcher.BeginInvoke((Action)(() =>
                {
                    lock (aniCanvas.Children)
                    {
                        aniCanvas.Children.Remove(flyingBody);
                    }
                    sb.Remove();
                }));
            }).Start();
        }

        private void FlyingShow(List<Card.Ruban> rubans, double x, double y, bool isLong)
        {
            Canvas flyingBody = new Canvas() { Width = 450, Height = 125 };
            Canvas.SetLeft(flyingBody, x);
            Canvas.SetTop(flyingBody, y);
            flyingBody.Visibility = Visibility.Visible;
            // Clear Tux
            int sz = rubans.Count;
            for (int i = 0; i < sz; ++i)
            {
                rubans[i].Index = i;
                Canvas.SetLeft(rubans[i], i * 30);
                flyingBody.Children.Add(rubans[i]);
            }
            lock (aniCanvas.Children)
            {
                aniCanvas.Children.Add(flyingBody);
            }
            TimeSpan holdDura = isLong ? LDURA : DURA;
            DoubleAnimation aniAppr = new DoubleAnimation() { From = 0, To = 1, Duration = SURA };
            Storyboard.SetTarget(aniAppr, flyingBody);
            Storyboard.SetTargetProperty(aniAppr, new PropertyPath(UIElement.OpacityProperty));
            aniAppr.BeginTime = TimeSpan.FromSeconds(0);

            DoubleAnimation aniFade = new DoubleAnimation() { From = 1, To = 0, Duration = SURA };
            Storyboard.SetTarget(aniFade, flyingBody);
            Storyboard.SetTargetProperty(aniFade, new PropertyPath(UIElement.OpacityProperty));
            aniFade.BeginTime = SURA + holdDura;

            Storyboard sb = new Storyboard();
            sb.Children.Add(aniAppr);
            sb.Children.Add(aniFade);

            sb.Begin();
            new Thread(delegate()
            {
                Thread.Sleep(SURA + holdDura + SURA);
                aniCanvas.Dispatcher.BeginInvoke((Action)(() =>
                {
                    lock (aniCanvas.Children)
                    {
                        aniCanvas.Children.Remove(flyingBody);
                    }
                    sb.Remove();
                }));
            }).Start();
        }

        private void PushMessage()
        {
            if (_IsChanging)
                return;

            if (_Queue.Count==0)
                return;
      
            _IsChanging = true;
      
            _Next = _Queue.Dequeue();
            Next.Content = _Next;

            Storyboard sb = new Storyboard();

            DoubleAnimation db = new DoubleAnimation();
            db.From = 0;
            db.To = -30;
            db.Duration = TransitionTime;

            Storyboard.SetTarget(db, this.Panel);
            Storyboard.SetTargetProperty(db, new PropertyPath("RenderTransform.Y"));

            sb.Children.Add(db);

            EventHandler handler = null;
            handler = delegate
            {
                Current.Content = Next.Content; 
                Transf.Y = 0;
                sb.Completed -= handler;
                sb.Remove();                       
                _IsChanging = false;
                PushMessage();
            };

            sb.Completed += handler;

            sb.Begin();
           
        }