RectAnimation.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ Net / Net / 3.5.50727.3053 / DEVDIV / depot / DevDiv / releases / Orcas / SP / wpf / src / Core / CSharp / System / Windows / Media / Animation / Generated / RectAnimation.cs / 1 / RectAnimation.cs

                            //---------------------------------------------------------------------------- 
//
// 
//    Copyright (C) Microsoft Corporation.  All rights reserved.
//  
//
// This file was generated, please do not edit it directly. 
// 
// Please see http://wiki/default.aspx/Microsoft.Projects.Avalon/MilCodeGen.html for more information.
// 
//---------------------------------------------------------------------------

using MS.Internal;
using MS.Internal.KnownBoxes; 
using MS.Utility;
 
using System; 
using System.Collections;
using System.ComponentModel; 
using System.Diagnostics;
using System.Globalization;
using System.Runtime.InteropServices;
using System.Windows.Media; 
using System.Windows.Media.Media3D;
using System.Windows.Media.Animation; 
 
using MS.Internal.PresentationCore;
 
namespace System.Windows.Media.Animation
{

    ///  
    /// Animates the value of a Rect property using linear interpolation
    /// between two values.  The values are determined by the combination of 
    /// From, To, or By values that are set on the animation. 
    /// 
    public partial class RectAnimation : 
        RectAnimationBase
    {
        #region Data
 
        /// 
        /// This is used if the user has specified From, To, and/or By values. 
        ///  
        private Rect[] _keyValues;
 
        private AnimationType _animationType;
        private bool _isAnimationFunctionValid;

        #endregion 

        #region Constructors 
 
        /// 
        /// Static ctor for RectAnimation establishes 
        /// dependency properties, using as much shared data as possible.
        /// 
        static RectAnimation()
        { 
            Type typeofProp = typeof(Rect?);
            Type typeofThis = typeof(RectAnimation); 
            PropertyChangedCallback propCallback = new PropertyChangedCallback(AnimationFunction_Changed); 
            ValidateValueCallback validateCallback = new ValidateValueCallback(ValidateFromToOrByValue);
 
            FromProperty = DependencyProperty.Register(
                "From",
                typeofProp,
                typeofThis, 
                new PropertyMetadata((Rect?)null, propCallback),
                validateCallback); 
 
            ToProperty = DependencyProperty.Register(
                "To", 
                typeofProp,
                typeofThis,
                new PropertyMetadata((Rect?)null, propCallback),
                validateCallback); 

            ByProperty = DependencyProperty.Register( 
                "By", 
                typeofProp,
                typeofThis, 
                new PropertyMetadata((Rect?)null, propCallback),
                validateCallback);
        }
 

        ///  
        /// Creates a new RectAnimation with all properties set to 
        /// their default values.
        ///  
        public RectAnimation()
            : base()
        {
        } 

        ///  
        /// Creates a new RectAnimation that will animate a 
        /// Rect property from its base value to the value specified
        /// by the "toValue" parameter of this constructor. 
        /// 
        public RectAnimation(Rect toValue, Duration duration)
            : this()
        { 
            To = toValue;
            Duration = duration; 
        } 

        ///  
        /// Creates a new RectAnimation that will animate a
        /// Rect property from its base value to the value specified
        /// by the "toValue" parameter of this constructor.
        ///  
        public RectAnimation(Rect toValue, Duration duration, FillBehavior fillBehavior)
            : this() 
        { 
            To = toValue;
            Duration = duration; 
            FillBehavior = fillBehavior;
        }

        ///  
        /// Creates a new RectAnimation that will animate a
        /// Rect property from the "fromValue" parameter of this constructor 
        /// to the "toValue" parameter. 
        /// 
        public RectAnimation(Rect fromValue, Rect toValue, Duration duration) 
            : this()
        {
            From = fromValue;
            To = toValue; 
            Duration = duration;
        } 
 
        /// 
        /// Creates a new RectAnimation that will animate a 
        /// Rect property from the "fromValue" parameter of this constructor
        /// to the "toValue" parameter.
        /// 
        public RectAnimation(Rect fromValue, Rect toValue, Duration duration, FillBehavior fillBehavior) 
            : this()
        { 
            From = fromValue; 
            To = toValue;
            Duration = duration; 
            FillBehavior = fillBehavior;
        }

        #endregion 

        #region Freezable 
 
        /// 
        /// Creates a copy of this RectAnimation 
        /// 
        /// The copy
        public new RectAnimation Clone()
        { 
            return (RectAnimation)base.Clone();
        } 
 
        //
        // Note that we don't override the Clone virtuals (CloneCore, CloneCurrentValueCore, 
        // GetAsFrozenCore, and GetCurrentValueAsFrozenCore) even though this class has state
        // not stored in a DP.
        //
        // We don't need to clone _animationType and _keyValues because they are the the cached 
        // results of animation function validation, which can be recomputed.  The other remaining
        // field, isAnimationFunctionValid, defaults to false, which causes this recomputation to happen. 
        // 

        ///  
        /// Implementation of Freezable.CreateInstanceCore.
        /// 
        /// The new Freezable.
        protected override Freezable CreateInstanceCore() 
        {
            return new RectAnimation(); 
        } 

        #endregion 

        #region Methods

        ///  
        /// Calculates the value this animation believes should be the current value for the property.
        ///  
        ///  
        /// This value is the suggested origin value provided to the animation
        /// to be used if the animation does not have its own concept of a 
        /// start value. If this animation is the first in a composition chain
        /// this value will be the snapshot value if one is available or the
        /// base property value if it is not; otherise this value will be the
        /// value returned by the previous animation in the chain with an 
        /// animationClock that is not Stopped.
        ///  
        ///  
        /// This value is the suggested destination value provided to the animation
        /// to be used if the animation does not have its own concept of an 
        /// end value. This value will be the base value if the animation is
        /// in the first composition layer of animations on a property;
        /// otherwise this value will be the output value from the previous
        /// composition layer of animations for the property. 
        /// 
        ///  
        /// This is the animationClock which can generate the CurrentTime or 
        /// CurrentProgress value to be used by the animation to generate its
        /// output value. 
        /// 
        /// 
        /// The value this animation believes should be the current value for the property.
        ///  
        protected override Rect GetCurrentValueCore(Rect defaultOriginValue, Rect defaultDestinationValue, AnimationClock animationClock)
        { 
            Debug.Assert(animationClock.CurrentState != ClockState.Stopped); 

            if (!_isAnimationFunctionValid) 
            {
                ValidateAnimationFunction();
            }
 
            double progress = animationClock.CurrentProgress.Value;
 
            Rect   from        = new Rect(); 
            Rect   to          = new Rect();
            Rect   accumulated = new Rect(); 
            Rect   foundation  = new Rect();

            // need to validate the default origin and destination values if
            // the animation uses them as the from, to, or foundation values 
            bool validateOrigin = false;
            bool validateDestination = false; 
 
            switch(_animationType)
            { 
                case AnimationType.Automatic:

                    from    = defaultOriginValue;
                    to      = defaultDestinationValue; 

                    validateOrigin = true; 
                    validateDestination = true; 

                    break; 

                case AnimationType.From:

                    from    = _keyValues[0]; 
                    to      = defaultDestinationValue;
 
                    validateDestination = true; 

                    break; 

                case AnimationType.To:

                    from = defaultOriginValue; 
                    to = _keyValues[0];
 
                    validateOrigin = true; 

                    break; 

                case AnimationType.By:

                    // According to the SMIL specification, a By animation is 
                    // always additive.  But we don't force this so that a
                    // user can re-use a By animation and have it replace the 
                    // animations that precede it in the list without having 
                    // to manually set the From value to the base value.
 
                    to          = _keyValues[0];
                    foundation  = defaultOriginValue;

                    validateOrigin = true; 

                    break; 
 
                case AnimationType.FromTo:
 
                    from    = _keyValues[0];
                    to      = _keyValues[1];

                    if (IsAdditive) 
                    {
                        foundation = defaultOriginValue; 
                        validateOrigin = true; 
                    }
 
                    break;

                case AnimationType.FromBy:
 
                    from    = _keyValues[0];
                    to      = AnimatedTypeHelpers.AddRect(_keyValues[0], _keyValues[1]); 
 
                    if (IsAdditive)
                    { 
                        foundation = defaultOriginValue;
                        validateOrigin = true;
                    }
 
                    break;
 
                default: 

                    Debug.Fail("Unknown animation type."); 

                    break;
            }
 
            if (validateOrigin
                && !AnimatedTypeHelpers.IsValidAnimationValueRect(defaultOriginValue)) 
            { 
                throw new InvalidOperationException(
                    SR.Get( 
                        SRID.Animation_Invalid_DefaultValue,
                        this.GetType(),
                        "origin",
                        defaultOriginValue.ToString(CultureInfo.InvariantCulture))); 
            }
 
            if (validateDestination 
                && !AnimatedTypeHelpers.IsValidAnimationValueRect(defaultDestinationValue))
            { 
                throw new InvalidOperationException(
                    SR.Get(
                        SRID.Animation_Invalid_DefaultValue,
                        this.GetType(), 
                        "destination",
                        defaultDestinationValue.ToString(CultureInfo.InvariantCulture))); 
            } 

 
            if (IsCumulative)
            {
                double currentRepeat = (double)(animationClock.CurrentIteration - 1);
 
                if (currentRepeat > 0.0)
                { 
                    Rect accumulator = AnimatedTypeHelpers.SubtractRect(to, from); 

                    accumulated = AnimatedTypeHelpers.ScaleRect(accumulator, currentRepeat); 
                }
            }

            // return foundation + accumulated + from + ((to - from) * progress) 

            return AnimatedTypeHelpers.AddRect( 
                foundation, 
                AnimatedTypeHelpers.AddRect(
                    accumulated, 
                    AnimatedTypeHelpers.InterpolateRect(from, to, progress)));
        }

        private void ValidateAnimationFunction() 
        {
            _animationType = AnimationType.Automatic; 
            _keyValues = null; 

            if (From.HasValue) 
            {
                if (To.HasValue)
                {
                    _animationType = AnimationType.FromTo; 
                    _keyValues = new Rect[2];
                    _keyValues[0] = From.Value; 
                    _keyValues[1] = To.Value; 
                }
                else if (By.HasValue) 
                {
                    _animationType = AnimationType.FromBy;
                    _keyValues = new Rect[2];
                    _keyValues[0] = From.Value; 
                    _keyValues[1] = By.Value;
                } 
                else 
                {
                    _animationType = AnimationType.From; 
                    _keyValues = new Rect[1];
                    _keyValues[0] = From.Value;
                }
            } 
            else if (To.HasValue)
            { 
                _animationType = AnimationType.To; 
                _keyValues = new Rect[1];
                _keyValues[0] = To.Value; 
            }
            else if (By.HasValue)
            {
                _animationType = AnimationType.By; 
                _keyValues = new Rect[1];
                _keyValues[0] = By.Value; 
            } 

            _isAnimationFunctionValid = true; 
        }

        #endregion
 
        #region Properties
 
        private static void AnimationFunction_Changed(DependencyObject d, DependencyPropertyChangedEventArgs e) 
        {
            RectAnimation a = (RectAnimation)d; 

            a._isAnimationFunctionValid = false;
            a.PropertyChanged(e.Property);
        } 

        private static bool ValidateFromToOrByValue(object value) 
        { 
            Rect? typedValue = (Rect?)value;
 
            if (typedValue.HasValue)
            {
                return AnimatedTypeHelpers.IsValidAnimationValueRect(typedValue.Value);
            } 
            else
            { 
                return true; 
            }
        } 

        /// 
        /// FromProperty
        ///  
        public static readonly DependencyProperty FromProperty;
 
        ///  
        /// From
        ///  
        public Rect? From
        {
            get
            { 
                return (Rect?)GetValue(FromProperty);
            } 
            set 
            {
                SetValueInternal(FromProperty, value); 
            }
        }

        ///  
        /// ToProperty
        ///  
        public static readonly DependencyProperty ToProperty; 

        ///  
        /// To
        /// 
        public Rect? To
        { 
            get
            { 
                return (Rect?)GetValue(ToProperty); 
            }
            set 
            {
                SetValueInternal(ToProperty, value);
            }
        } 

        ///  
        /// ByProperty 
        /// 
        public static readonly DependencyProperty ByProperty; 

        /// 
        /// By
        ///  
        public Rect? By
        { 
            get 
            {
                return (Rect?)GetValue(ByProperty); 
            }
            set
            {
                SetValueInternal(ByProperty, value); 
            }
        } 
 
        /// 
        /// If this property is set to true the animation will add its value to 
        /// the base value instead of replacing it entirely.
        /// 
        public bool IsAdditive
        { 
            get
            { 
                return (bool)GetValue(IsAdditiveProperty); 
            }
            set 
            {
                SetValueInternal(IsAdditiveProperty, BooleanBoxes.Box(value));
            }
        } 

        ///  
        /// It this property is set to true, the animation will accumulate its 
        /// value over repeats.  For instance if you have a From value of 0.0 and
        /// a To value of 1.0, the animation return values from 1.0 to 2.0 over 
        /// the second reteat cycle, and 2.0 to 3.0 over the third, etc.
        /// 
        public bool IsCumulative
        { 
            get
            { 
                return (bool)GetValue(IsCumulativeProperty); 
            }
            set 
            {
                SetValueInternal(IsCumulativeProperty, BooleanBoxes.Box(value));
            }
        } 

        #endregion 
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
//---------------------------------------------------------------------------- 
//
// 
//    Copyright (C) Microsoft Corporation.  All rights reserved.
//  
//
// This file was generated, please do not edit it directly. 
// 
// Please see http://wiki/default.aspx/Microsoft.Projects.Avalon/MilCodeGen.html for more information.
// 
//---------------------------------------------------------------------------

using MS.Internal;
using MS.Internal.KnownBoxes; 
using MS.Utility;
 
using System; 
using System.Collections;
using System.ComponentModel; 
using System.Diagnostics;
using System.Globalization;
using System.Runtime.InteropServices;
using System.Windows.Media; 
using System.Windows.Media.Media3D;
using System.Windows.Media.Animation; 
 
using MS.Internal.PresentationCore;
 
namespace System.Windows.Media.Animation
{

    ///  
    /// Animates the value of a Rect property using linear interpolation
    /// between two values.  The values are determined by the combination of 
    /// From, To, or By values that are set on the animation. 
    /// 
    public partial class RectAnimation : 
        RectAnimationBase
    {
        #region Data
 
        /// 
        /// This is used if the user has specified From, To, and/or By values. 
        ///  
        private Rect[] _keyValues;
 
        private AnimationType _animationType;
        private bool _isAnimationFunctionValid;

        #endregion 

        #region Constructors 
 
        /// 
        /// Static ctor for RectAnimation establishes 
        /// dependency properties, using as much shared data as possible.
        /// 
        static RectAnimation()
        { 
            Type typeofProp = typeof(Rect?);
            Type typeofThis = typeof(RectAnimation); 
            PropertyChangedCallback propCallback = new PropertyChangedCallback(AnimationFunction_Changed); 
            ValidateValueCallback validateCallback = new ValidateValueCallback(ValidateFromToOrByValue);
 
            FromProperty = DependencyProperty.Register(
                "From",
                typeofProp,
                typeofThis, 
                new PropertyMetadata((Rect?)null, propCallback),
                validateCallback); 
 
            ToProperty = DependencyProperty.Register(
                "To", 
                typeofProp,
                typeofThis,
                new PropertyMetadata((Rect?)null, propCallback),
                validateCallback); 

            ByProperty = DependencyProperty.Register( 
                "By", 
                typeofProp,
                typeofThis, 
                new PropertyMetadata((Rect?)null, propCallback),
                validateCallback);
        }
 

        ///  
        /// Creates a new RectAnimation with all properties set to 
        /// their default values.
        ///  
        public RectAnimation()
            : base()
        {
        } 

        ///  
        /// Creates a new RectAnimation that will animate a 
        /// Rect property from its base value to the value specified
        /// by the "toValue" parameter of this constructor. 
        /// 
        public RectAnimation(Rect toValue, Duration duration)
            : this()
        { 
            To = toValue;
            Duration = duration; 
        } 

        ///  
        /// Creates a new RectAnimation that will animate a
        /// Rect property from its base value to the value specified
        /// by the "toValue" parameter of this constructor.
        ///  
        public RectAnimation(Rect toValue, Duration duration, FillBehavior fillBehavior)
            : this() 
        { 
            To = toValue;
            Duration = duration; 
            FillBehavior = fillBehavior;
        }

        ///  
        /// Creates a new RectAnimation that will animate a
        /// Rect property from the "fromValue" parameter of this constructor 
        /// to the "toValue" parameter. 
        /// 
        public RectAnimation(Rect fromValue, Rect toValue, Duration duration) 
            : this()
        {
            From = fromValue;
            To = toValue; 
            Duration = duration;
        } 
 
        /// 
        /// Creates a new RectAnimation that will animate a 
        /// Rect property from the "fromValue" parameter of this constructor
        /// to the "toValue" parameter.
        /// 
        public RectAnimation(Rect fromValue, Rect toValue, Duration duration, FillBehavior fillBehavior) 
            : this()
        { 
            From = fromValue; 
            To = toValue;
            Duration = duration; 
            FillBehavior = fillBehavior;
        }

        #endregion 

        #region Freezable 
 
        /// 
        /// Creates a copy of this RectAnimation 
        /// 
        /// The copy
        public new RectAnimation Clone()
        { 
            return (RectAnimation)base.Clone();
        } 
 
        //
        // Note that we don't override the Clone virtuals (CloneCore, CloneCurrentValueCore, 
        // GetAsFrozenCore, and GetCurrentValueAsFrozenCore) even though this class has state
        // not stored in a DP.
        //
        // We don't need to clone _animationType and _keyValues because they are the the cached 
        // results of animation function validation, which can be recomputed.  The other remaining
        // field, isAnimationFunctionValid, defaults to false, which causes this recomputation to happen. 
        // 

        ///  
        /// Implementation of Freezable.CreateInstanceCore.
        /// 
        /// The new Freezable.
        protected override Freezable CreateInstanceCore() 
        {
            return new RectAnimation(); 
        } 

        #endregion 

        #region Methods

        ///  
        /// Calculates the value this animation believes should be the current value for the property.
        ///  
        ///  
        /// This value is the suggested origin value provided to the animation
        /// to be used if the animation does not have its own concept of a 
        /// start value. If this animation is the first in a composition chain
        /// this value will be the snapshot value if one is available or the
        /// base property value if it is not; otherise this value will be the
        /// value returned by the previous animation in the chain with an 
        /// animationClock that is not Stopped.
        ///  
        ///  
        /// This value is the suggested destination value provided to the animation
        /// to be used if the animation does not have its own concept of an 
        /// end value. This value will be the base value if the animation is
        /// in the first composition layer of animations on a property;
        /// otherwise this value will be the output value from the previous
        /// composition layer of animations for the property. 
        /// 
        ///  
        /// This is the animationClock which can generate the CurrentTime or 
        /// CurrentProgress value to be used by the animation to generate its
        /// output value. 
        /// 
        /// 
        /// The value this animation believes should be the current value for the property.
        ///  
        protected override Rect GetCurrentValueCore(Rect defaultOriginValue, Rect defaultDestinationValue, AnimationClock animationClock)
        { 
            Debug.Assert(animationClock.CurrentState != ClockState.Stopped); 

            if (!_isAnimationFunctionValid) 
            {
                ValidateAnimationFunction();
            }
 
            double progress = animationClock.CurrentProgress.Value;
 
            Rect   from        = new Rect(); 
            Rect   to          = new Rect();
            Rect   accumulated = new Rect(); 
            Rect   foundation  = new Rect();

            // need to validate the default origin and destination values if
            // the animation uses them as the from, to, or foundation values 
            bool validateOrigin = false;
            bool validateDestination = false; 
 
            switch(_animationType)
            { 
                case AnimationType.Automatic:

                    from    = defaultOriginValue;
                    to      = defaultDestinationValue; 

                    validateOrigin = true; 
                    validateDestination = true; 

                    break; 

                case AnimationType.From:

                    from    = _keyValues[0]; 
                    to      = defaultDestinationValue;
 
                    validateDestination = true; 

                    break; 

                case AnimationType.To:

                    from = defaultOriginValue; 
                    to = _keyValues[0];
 
                    validateOrigin = true; 

                    break; 

                case AnimationType.By:

                    // According to the SMIL specification, a By animation is 
                    // always additive.  But we don't force this so that a
                    // user can re-use a By animation and have it replace the 
                    // animations that precede it in the list without having 
                    // to manually set the From value to the base value.
 
                    to          = _keyValues[0];
                    foundation  = defaultOriginValue;

                    validateOrigin = true; 

                    break; 
 
                case AnimationType.FromTo:
 
                    from    = _keyValues[0];
                    to      = _keyValues[1];

                    if (IsAdditive) 
                    {
                        foundation = defaultOriginValue; 
                        validateOrigin = true; 
                    }
 
                    break;

                case AnimationType.FromBy:
 
                    from    = _keyValues[0];
                    to      = AnimatedTypeHelpers.AddRect(_keyValues[0], _keyValues[1]); 
 
                    if (IsAdditive)
                    { 
                        foundation = defaultOriginValue;
                        validateOrigin = true;
                    }
 
                    break;
 
                default: 

                    Debug.Fail("Unknown animation type."); 

                    break;
            }
 
            if (validateOrigin
                && !AnimatedTypeHelpers.IsValidAnimationValueRect(defaultOriginValue)) 
            { 
                throw new InvalidOperationException(
                    SR.Get( 
                        SRID.Animation_Invalid_DefaultValue,
                        this.GetType(),
                        "origin",
                        defaultOriginValue.ToString(CultureInfo.InvariantCulture))); 
            }
 
            if (validateDestination 
                && !AnimatedTypeHelpers.IsValidAnimationValueRect(defaultDestinationValue))
            { 
                throw new InvalidOperationException(
                    SR.Get(
                        SRID.Animation_Invalid_DefaultValue,
                        this.GetType(), 
                        "destination",
                        defaultDestinationValue.ToString(CultureInfo.InvariantCulture))); 
            } 

 
            if (IsCumulative)
            {
                double currentRepeat = (double)(animationClock.CurrentIteration - 1);
 
                if (currentRepeat > 0.0)
                { 
                    Rect accumulator = AnimatedTypeHelpers.SubtractRect(to, from); 

                    accumulated = AnimatedTypeHelpers.ScaleRect(accumulator, currentRepeat); 
                }
            }

            // return foundation + accumulated + from + ((to - from) * progress) 

            return AnimatedTypeHelpers.AddRect( 
                foundation, 
                AnimatedTypeHelpers.AddRect(
                    accumulated, 
                    AnimatedTypeHelpers.InterpolateRect(from, to, progress)));
        }

        private void ValidateAnimationFunction() 
        {
            _animationType = AnimationType.Automatic; 
            _keyValues = null; 

            if (From.HasValue) 
            {
                if (To.HasValue)
                {
                    _animationType = AnimationType.FromTo; 
                    _keyValues = new Rect[2];
                    _keyValues[0] = From.Value; 
                    _keyValues[1] = To.Value; 
                }
                else if (By.HasValue) 
                {
                    _animationType = AnimationType.FromBy;
                    _keyValues = new Rect[2];
                    _keyValues[0] = From.Value; 
                    _keyValues[1] = By.Value;
                } 
                else 
                {
                    _animationType = AnimationType.From; 
                    _keyValues = new Rect[1];
                    _keyValues[0] = From.Value;
                }
            } 
            else if (To.HasValue)
            { 
                _animationType = AnimationType.To; 
                _keyValues = new Rect[1];
                _keyValues[0] = To.Value; 
            }
            else if (By.HasValue)
            {
                _animationType = AnimationType.By; 
                _keyValues = new Rect[1];
                _keyValues[0] = By.Value; 
            } 

            _isAnimationFunctionValid = true; 
        }

        #endregion
 
        #region Properties
 
        private static void AnimationFunction_Changed(DependencyObject d, DependencyPropertyChangedEventArgs e) 
        {
            RectAnimation a = (RectAnimation)d; 

            a._isAnimationFunctionValid = false;
            a.PropertyChanged(e.Property);
        } 

        private static bool ValidateFromToOrByValue(object value) 
        { 
            Rect? typedValue = (Rect?)value;
 
            if (typedValue.HasValue)
            {
                return AnimatedTypeHelpers.IsValidAnimationValueRect(typedValue.Value);
            } 
            else
            { 
                return true; 
            }
        } 

        /// 
        /// FromProperty
        ///  
        public static readonly DependencyProperty FromProperty;
 
        ///  
        /// From
        ///  
        public Rect? From
        {
            get
            { 
                return (Rect?)GetValue(FromProperty);
            } 
            set 
            {
                SetValueInternal(FromProperty, value); 
            }
        }

        ///  
        /// ToProperty
        ///  
        public static readonly DependencyProperty ToProperty; 

        ///  
        /// To
        /// 
        public Rect? To
        { 
            get
            { 
                return (Rect?)GetValue(ToProperty); 
            }
            set 
            {
                SetValueInternal(ToProperty, value);
            }
        } 

        ///  
        /// ByProperty 
        /// 
        public static readonly DependencyProperty ByProperty; 

        /// 
        /// By
        ///  
        public Rect? By
        { 
            get 
            {
                return (Rect?)GetValue(ByProperty); 
            }
            set
            {
                SetValueInternal(ByProperty, value); 
            }
        } 
 
        /// 
        /// If this property is set to true the animation will add its value to 
        /// the base value instead of replacing it entirely.
        /// 
        public bool IsAdditive
        { 
            get
            { 
                return (bool)GetValue(IsAdditiveProperty); 
            }
            set 
            {
                SetValueInternal(IsAdditiveProperty, BooleanBoxes.Box(value));
            }
        } 

        ///  
        /// It this property is set to true, the animation will accumulate its 
        /// value over repeats.  For instance if you have a From value of 0.0 and
        /// a To value of 1.0, the animation return values from 1.0 to 2.0 over 
        /// the second reteat cycle, and 2.0 to 3.0 over the third, etc.
        /// 
        public bool IsCumulative
        { 
            get
            { 
                return (bool)GetValue(IsCumulativeProperty); 
            }
            set 
            {
                SetValueInternal(IsCumulativeProperty, BooleanBoxes.Box(value));
            }
        } 

        #endregion 
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK