コード例 #1
0
    protected override void CopyCurrentValueCore(Animatable sourceAnimatable)
    {
      // The timeline to copy properties from. 
      // If this parameter is null, this timeline is constructed with default property values.

//			if(sourceAnimatable == null)
//				CopyCore(sourceFreezable);
    }
コード例 #2
0
ファイル: DeploymentAnimation.cs プロジェクト: BdGL3/CXPortal
 public DeploymentAnimation(Dispatcher dispatcher, Animatable animationedObject, bool isDeploying, double animationTime, double stowedValue, double deployedValue)
 {
     _Dispatcher = dispatcher;
     _AnimationedObject = animationedObject;
     _IsDeploying = isDeploying;
     _StowedValue = stowedValue;
     _DeployedValue = deployedValue;
     AnimationTime = animationTime;
     _StopAnimation = new DoubleAnimation();
     _StopAnimation.BeginTime = null;
 }
コード例 #3
0
 //动画
 public static void DoMove(Animatable uie, DependencyProperty dp, double to, double ar, double dr, double duration)
 {
     var doubleAnimation = new DoubleAnimation
         {
             To = to,
             Duration = TimeSpan.FromSeconds(duration),
             AccelerationRatio = ar,
             DecelerationRatio = dr,
             FillBehavior = FillBehavior.HoldEnd
         };//创建双精度动画对象
     uie.BeginAnimation(dp, doubleAnimation);//设置动画应用的属性并启动动画
 }
コード例 #4
0
        internal void Initialize(DependencyObject d, DependencyProperty dp)
        {
            Debug.Assert(_dependencyObject == null);
            Debug.Assert(_dependencyProperty == null);

            Animatable a = d as Animatable;

            if (a != null)
            {
                _dependencyObject = a.GetWeakReference();
            }
            else
            {
                //

                _dependencyObject = new WeakReference(d);
            }

            _dependencyProperty = dp;
        }
コード例 #5
0
ファイル: Scenario.cs プロジェクト: JuroGandalf/Ragnarok
        /*private List<Tuple<IAnimatable, DependencyProperty>> animatedPropertyList =
            new List<Tuple<IAnimatable, DependencyProperty>>();*/

        /// <summary>
        /// アニメーションを開始します。
        /// </summary>
        public void Begin(Animatable target)
        {
            foreach (var anim in Children)
            {
                if (anim == null)
                {
                    continue;
                }

                var animTarget = GetTarget(anim);
                if (animTarget == null)
                {
                    animTarget = target;

                    var targetPath = GetTargetPath(anim);
                    if (!string.IsNullOrEmpty(targetPath))
                    {
                        var targetProperty = WPFUtil.GetDependencyProperty(
                            target.GetType(),
                            targetPath);

                        if (targetProperty != null)
                        {
                            var t = target.GetValue(targetProperty) as Animatable;
                            if (t != null)
                            {
                                animTarget = t;
                            }
                        }
                    }
                }

                var property = WPFUtil.GetDependencyProperty(
                    animTarget.GetType(),
                    GetTargetProperty(anim));

                if (property != null)
                {
                    animTarget.BeginAnimation(property, anim);
                }

                /*this.animatedPropertyList.Add(
                    Tuple.Create(animTarget, property));*/
            }
        }
コード例 #6
0
ファイル: ImageSource.cs プロジェクト: arangas/MediaPortal-1
 protected override void CopyCurrentValueCore(Animatable sourceAnimatable) {}
コード例 #7
0
ファイル: ViewCubeVisual3D.cs プロジェクト: litdev1/LitDev
 /// <summary>
 /// The animate opacity.
 /// </summary>
 /// <param name="obj">
 /// The obj.
 /// </param>
 /// <param name="toOpacity">
 /// The to opacity.
 /// </param>
 /// <param name="animationTime">
 /// The animation time.
 /// </param>
 private void AnimateOpacity(Animatable obj, double toOpacity, double animationTime)
 {
     var animation = new DoubleAnimation(toOpacity, new Duration(TimeSpan.FromMilliseconds(animationTime)))
         {
             AccelerationRatio = 0.3,
             DecelerationRatio = 0.5
         };
     animation.Completed += this.AnimationCompleted;
     obj.BeginAnimation(UIElement.OpacityProperty, animation);
 }
コード例 #8
0
		static void Animate(Animatable element, DependencyProperty property, double to)
		{
			element.BeginAnimation(property, new DoubleAnimation(to, new Duration(animationTime), FillBehavior.HoldEnd),
			                       HandoffBehavior.SnapshotAndReplace);
		}
コード例 #9
0
        /// <summary>
        /// This should be called at the end of any method that alters the
        /// storage in any way.  This method will make sure the peer dp is
        /// set correctly and notify Animatables if something changes.
        /// </summary>
        internal void WritePostscript()
        {
            DependencyObject d = (DependencyObject)_dependencyObject.Target;

            if (d == null)
            {
                return;
            }

            FrugalMap animatedPropertyMap = AnimatedPropertyMapField.GetValue(d);

            if (animatedPropertyMap.Count == 0 ||
                animatedPropertyMap[_dependencyProperty.GlobalIndex] == DependencyProperty.UnsetValue)
            {
                if (!IsEmpty)
                {
                    // This is kind of tricky:
                    //
                    // Because FrugalMap is a struct instead of a class, we must
                    // be sure to add this AnimationStorage to the map before
                    // setting the FrugalMap into the UncommonField storage. If
                    // we don't and the FrugalMap is empty then an empty FrugalMap
                    // will be set into the UncommonField storage. If we were to
                    // then add our AnimationStorage to the local FrugalMap, it
                    // would only allocate its own internal storage at that point
                    // which would not apply to the FrugalMap we set into the
                    // UncommonField storage. Once a FrugalMap has allocated its
                    // internal storage, though, that storage is copied with the
                    // FrugalMap. This is what will happen when we add our
                    // AnimationStorage to the FrugalMap first as we do below:

                    animatedPropertyMap[_dependencyProperty.GlobalIndex] = this;

                    // Since FrugalMap is a struct and adding a new value to it
                    // may re-allocate the storage, we need to set this value
                    // each time we make a change to the map.

                    AnimatedPropertyMapField.SetValue(d, animatedPropertyMap);

                    if (animatedPropertyMap.Count == 1)
                    {
                        d.IAnimatable_HasAnimatedProperties = true;
                    }

                    // If this the target is an Animatable we'll need to
                    // invalidate it so that the animation resource for this
                    // newly animated property will be passed across to the UCE.
                    Animatable a = d as Animatable;

                    if (a != null)
                    {
                        a.RegisterForAsyncUpdateResource();
                    }

                    // If this AnimationStorage is a resource, add it to the
                    // channel now.
                    DUCE.IResource animationResource = this as DUCE.IResource;

                    if (animationResource != null)
                    {
                        DUCE.IResource targetResource = d as DUCE.IResource;

                        if (targetResource != null)
                        {
                            using (CompositionEngineLock.Acquire())
                            {
                                int channelCount = targetResource.GetChannelCount();

                                for (int i = 0; i < channelCount; i++)
                                {
                                    DUCE.Channel channel = targetResource.GetChannel(i);
                                    if (!targetResource.GetHandle(channel).IsNull)
                                    {
                                        animationResource.AddRefOnChannel(channel);
                                    }
                                }
                            }
                        }
                    }
                }
            }
            else
            {
                Debug.Assert(animatedPropertyMap.Count > 0);
                Debug.Assert(animatedPropertyMap[_dependencyProperty.GlobalIndex] != DependencyProperty.UnsetValue);

                if (IsEmpty)
                {
                    // If this AnimationStorage is a resource, release it from
                    // the channel now.
                    DUCE.IResource animationResource = this as DUCE.IResource;

                    if (animationResource != null)
                    {
                        DUCE.IResource targetResource = d as DUCE.IResource;

                        if (targetResource != null)
                        {
                            using (CompositionEngineLock.Acquire())
                            {
                                int channelCount = targetResource.GetChannelCount();

                                for (int i = 0; i < channelCount; i++)
                                {
                                    DUCE.Channel channel = targetResource.GetChannel(i);
                                    if (!targetResource.GetHandle(channel).IsNull)
                                    {
                                        animationResource.ReleaseOnChannel(channel);
                                    }
                                }
                            }
                        }
                    }

                    // If this the target is an Animatable we'll need to
                    // invalidate it so that the animation resource for this
                    // no longer animated property will no longer be passed
                    // across to the UCE.
                    Animatable a = d as Animatable;

                    if (a != null)
                    {
                        a.RegisterForAsyncUpdateResource();
                    }

                    animatedPropertyMap[_dependencyProperty.GlobalIndex] = DependencyProperty.UnsetValue;

                    if (animatedPropertyMap.Count == 0)
                    {
                        AnimatedPropertyMapField.ClearValue(d);

                        d.IAnimatable_HasAnimatedProperties = false;
                    }
                    else
                    {
                        AnimatedPropertyMapField.SetValue(d, animatedPropertyMap);
                    }

                    // We've removed animation storage for this DP, so if we were storing the local
                    // base value here then it has to go back to its non-animated storage spot.
                    if (_baseValue != DependencyProperty.UnsetValue)
                    {
                        d.SetValue(_dependencyProperty, _baseValue);
                    }
                }
            }

            // recompute animated value
            d.InvalidateProperty(_dependencyProperty);
        }
コード例 #10
0
        /*private void face_MouseLeave(object sender, MouseEventArgs e)
        {
                        var el = (ModelUIElement3D) sender;
                        var model = el.Model as GeometryModel3D;
                        var mg = model.Material as MaterialGroup;
                        var dm = mg.Children[0] as DiffuseMaterial;
                        AnimateOpacity(dm.Brush, 0.8, 200);
        }

        private void face_MouseEnter(object sender, MouseEventArgs e)
        {
            var el = (ModelUIElement3D) sender;
                var model = el.Model as GeometryModel3D;
                var mg=model.Material as MaterialGroup;
                var dm=mg.Children[0] as DiffuseMaterial;
                AnimateOpacity(dm.Brush, 1.0, 200);
        }*/


        private void AnimateOpacity(Animatable obj, double toOpacity, double animationTime)
        {
            var a = new DoubleAnimation(toOpacity,
                                        new Duration(TimeSpan.FromMilliseconds(animationTime))) { AccelerationRatio = 0.3, DecelerationRatio = 0.5 };
            a.Completed += new EventHandler(a_Completed);
            obj.BeginAnimation(UIElement.OpacityProperty, a);
        }