Code:
/ Net / Net / 3.5.50727.3053 / DEVDIV / depot / DevDiv / releases / Orcas / SP / wpf / src / Core / CSharp / System / Windows / Media / Animation / Generated / SplineKeyFrames.cs / 1 / SplineKeyFrames.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 System; using System.Collections; using System.ComponentModel; using System.Diagnostics; using System.Windows.Media; using System.Windows.Media.Media3D; using MS.Internal.PresentationCore; namespace System.Windows.Media.Animation { ////// This class is used as part of a ByteKeyFrameCollection in /// conjunction with a KeyFrameByteAnimation to animate a /// Byte property value along a set of key frames. /// /// This ByteKeyFrame interpolates between the Byte Value of /// the previous key frame and its own Value to produce its output value. /// public partial class SplineByteKeyFrame : ByteKeyFrame { #region Constructors ////// Creates a new SplineByteKeyFrame. /// public SplineByteKeyFrame() : base() { } ////// Creates a new SplineByteKeyFrame. /// public SplineByteKeyFrame(Byte value) : this() { Value = value; } ////// Creates a new SplineByteKeyFrame. /// public SplineByteKeyFrame(Byte value, KeyTime keyTime) : this() { Value = value; KeyTime = keyTime; } ////// Creates a new SplineByteKeyFrame. /// public SplineByteKeyFrame(Byte value, KeyTime keyTime, KeySpline keySpline) : this() { if (keySpline == null) { throw new ArgumentNullException("keySpline"); } Value = value; KeyTime = keyTime; KeySpline = keySpline; } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new SplineByteKeyFrame(); } #endregion #region ByteKeyFrame ////// Implemented to linearly interpolate between the baseValue and the /// Value of this KeyFrame using the keyFrameProgress. /// protected override Byte InterpolateValueCore(Byte baseValue, double keyFrameProgress) { if (keyFrameProgress == 0.0) { return baseValue; } else if (keyFrameProgress == 1.0) { return Value; } else { double splineProgress = KeySpline.GetSplineProgress(keyFrameProgress); return AnimatedTypeHelpers.InterpolateByte(baseValue, Value, splineProgress); } } #endregion #region Public Properties ////// KeySpline Property /// public static readonly DependencyProperty KeySplineProperty = DependencyProperty.Register( "KeySpline", typeof(KeySpline), typeof(SplineByteKeyFrame), new PropertyMetadata(new KeySpline())); ////// The KeySpline defines the way that progress will be altered for this /// key frame. /// public KeySpline KeySpline { get { return (KeySpline)GetValue(KeySplineProperty); } set { if (value == null) { throw new ArgumentNullException("value"); } SetValue(KeySplineProperty, value); } } #endregion } ////// This class is used as part of a ColorKeyFrameCollection in /// conjunction with a KeyFrameColorAnimation to animate a /// Color property value along a set of key frames. /// /// This ColorKeyFrame interpolates between the Color Value of /// the previous key frame and its own Value to produce its output value. /// public partial class SplineColorKeyFrame : ColorKeyFrame { #region Constructors ////// Creates a new SplineColorKeyFrame. /// public SplineColorKeyFrame() : base() { } ////// Creates a new SplineColorKeyFrame. /// public SplineColorKeyFrame(Color value) : this() { Value = value; } ////// Creates a new SplineColorKeyFrame. /// public SplineColorKeyFrame(Color value, KeyTime keyTime) : this() { Value = value; KeyTime = keyTime; } ////// Creates a new SplineColorKeyFrame. /// public SplineColorKeyFrame(Color value, KeyTime keyTime, KeySpline keySpline) : this() { if (keySpline == null) { throw new ArgumentNullException("keySpline"); } Value = value; KeyTime = keyTime; KeySpline = keySpline; } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new SplineColorKeyFrame(); } #endregion #region ColorKeyFrame ////// Implemented to linearly interpolate between the baseValue and the /// Value of this KeyFrame using the keyFrameProgress. /// protected override Color InterpolateValueCore(Color baseValue, double keyFrameProgress) { if (keyFrameProgress == 0.0) { return baseValue; } else if (keyFrameProgress == 1.0) { return Value; } else { double splineProgress = KeySpline.GetSplineProgress(keyFrameProgress); return AnimatedTypeHelpers.InterpolateColor(baseValue, Value, splineProgress); } } #endregion #region Public Properties ////// KeySpline Property /// public static readonly DependencyProperty KeySplineProperty = DependencyProperty.Register( "KeySpline", typeof(KeySpline), typeof(SplineColorKeyFrame), new PropertyMetadata(new KeySpline())); ////// The KeySpline defines the way that progress will be altered for this /// key frame. /// public KeySpline KeySpline { get { return (KeySpline)GetValue(KeySplineProperty); } set { if (value == null) { throw new ArgumentNullException("value"); } SetValue(KeySplineProperty, value); } } #endregion } ////// This class is used as part of a DecimalKeyFrameCollection in /// conjunction with a KeyFrameDecimalAnimation to animate a /// Decimal property value along a set of key frames. /// /// This DecimalKeyFrame interpolates between the Decimal Value of /// the previous key frame and its own Value to produce its output value. /// public partial class SplineDecimalKeyFrame : DecimalKeyFrame { #region Constructors ////// Creates a new SplineDecimalKeyFrame. /// public SplineDecimalKeyFrame() : base() { } ////// Creates a new SplineDecimalKeyFrame. /// public SplineDecimalKeyFrame(Decimal value) : this() { Value = value; } ////// Creates a new SplineDecimalKeyFrame. /// public SplineDecimalKeyFrame(Decimal value, KeyTime keyTime) : this() { Value = value; KeyTime = keyTime; } ////// Creates a new SplineDecimalKeyFrame. /// public SplineDecimalKeyFrame(Decimal value, KeyTime keyTime, KeySpline keySpline) : this() { if (keySpline == null) { throw new ArgumentNullException("keySpline"); } Value = value; KeyTime = keyTime; KeySpline = keySpline; } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new SplineDecimalKeyFrame(); } #endregion #region DecimalKeyFrame ////// Implemented to linearly interpolate between the baseValue and the /// Value of this KeyFrame using the keyFrameProgress. /// protected override Decimal InterpolateValueCore(Decimal baseValue, double keyFrameProgress) { if (keyFrameProgress == 0.0) { return baseValue; } else if (keyFrameProgress == 1.0) { return Value; } else { double splineProgress = KeySpline.GetSplineProgress(keyFrameProgress); return AnimatedTypeHelpers.InterpolateDecimal(baseValue, Value, splineProgress); } } #endregion #region Public Properties ////// KeySpline Property /// public static readonly DependencyProperty KeySplineProperty = DependencyProperty.Register( "KeySpline", typeof(KeySpline), typeof(SplineDecimalKeyFrame), new PropertyMetadata(new KeySpline())); ////// The KeySpline defines the way that progress will be altered for this /// key frame. /// public KeySpline KeySpline { get { return (KeySpline)GetValue(KeySplineProperty); } set { if (value == null) { throw new ArgumentNullException("value"); } SetValue(KeySplineProperty, value); } } #endregion } ////// This class is used as part of a DoubleKeyFrameCollection in /// conjunction with a KeyFrameDoubleAnimation to animate a /// Double property value along a set of key frames. /// /// This DoubleKeyFrame interpolates between the Double Value of /// the previous key frame and its own Value to produce its output value. /// public partial class SplineDoubleKeyFrame : DoubleKeyFrame { #region Constructors ////// Creates a new SplineDoubleKeyFrame. /// public SplineDoubleKeyFrame() : base() { } ////// Creates a new SplineDoubleKeyFrame. /// public SplineDoubleKeyFrame(Double value) : this() { Value = value; } ////// Creates a new SplineDoubleKeyFrame. /// public SplineDoubleKeyFrame(Double value, KeyTime keyTime) : this() { Value = value; KeyTime = keyTime; } ////// Creates a new SplineDoubleKeyFrame. /// public SplineDoubleKeyFrame(Double value, KeyTime keyTime, KeySpline keySpline) : this() { if (keySpline == null) { throw new ArgumentNullException("keySpline"); } Value = value; KeyTime = keyTime; KeySpline = keySpline; } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new SplineDoubleKeyFrame(); } #endregion #region DoubleKeyFrame ////// Implemented to linearly interpolate between the baseValue and the /// Value of this KeyFrame using the keyFrameProgress. /// protected override Double InterpolateValueCore(Double baseValue, double keyFrameProgress) { if (keyFrameProgress == 0.0) { return baseValue; } else if (keyFrameProgress == 1.0) { return Value; } else { double splineProgress = KeySpline.GetSplineProgress(keyFrameProgress); return AnimatedTypeHelpers.InterpolateDouble(baseValue, Value, splineProgress); } } #endregion #region Public Properties ////// KeySpline Property /// public static readonly DependencyProperty KeySplineProperty = DependencyProperty.Register( "KeySpline", typeof(KeySpline), typeof(SplineDoubleKeyFrame), new PropertyMetadata(new KeySpline())); ////// The KeySpline defines the way that progress will be altered for this /// key frame. /// public KeySpline KeySpline { get { return (KeySpline)GetValue(KeySplineProperty); } set { if (value == null) { throw new ArgumentNullException("value"); } SetValue(KeySplineProperty, value); } } #endregion } ////// This class is used as part of a Int16KeyFrameCollection in /// conjunction with a KeyFrameInt16Animation to animate a /// Int16 property value along a set of key frames. /// /// This Int16KeyFrame interpolates between the Int16 Value of /// the previous key frame and its own Value to produce its output value. /// public partial class SplineInt16KeyFrame : Int16KeyFrame { #region Constructors ////// Creates a new SplineInt16KeyFrame. /// public SplineInt16KeyFrame() : base() { } ////// Creates a new SplineInt16KeyFrame. /// public SplineInt16KeyFrame(Int16 value) : this() { Value = value; } ////// Creates a new SplineInt16KeyFrame. /// public SplineInt16KeyFrame(Int16 value, KeyTime keyTime) : this() { Value = value; KeyTime = keyTime; } ////// Creates a new SplineInt16KeyFrame. /// public SplineInt16KeyFrame(Int16 value, KeyTime keyTime, KeySpline keySpline) : this() { if (keySpline == null) { throw new ArgumentNullException("keySpline"); } Value = value; KeyTime = keyTime; KeySpline = keySpline; } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new SplineInt16KeyFrame(); } #endregion #region Int16KeyFrame ////// Implemented to linearly interpolate between the baseValue and the /// Value of this KeyFrame using the keyFrameProgress. /// protected override Int16 InterpolateValueCore(Int16 baseValue, double keyFrameProgress) { if (keyFrameProgress == 0.0) { return baseValue; } else if (keyFrameProgress == 1.0) { return Value; } else { double splineProgress = KeySpline.GetSplineProgress(keyFrameProgress); return AnimatedTypeHelpers.InterpolateInt16(baseValue, Value, splineProgress); } } #endregion #region Public Properties ////// KeySpline Property /// public static readonly DependencyProperty KeySplineProperty = DependencyProperty.Register( "KeySpline", typeof(KeySpline), typeof(SplineInt16KeyFrame), new PropertyMetadata(new KeySpline())); ////// The KeySpline defines the way that progress will be altered for this /// key frame. /// public KeySpline KeySpline { get { return (KeySpline)GetValue(KeySplineProperty); } set { if (value == null) { throw new ArgumentNullException("value"); } SetValue(KeySplineProperty, value); } } #endregion } ////// This class is used as part of a Int32KeyFrameCollection in /// conjunction with a KeyFrameInt32Animation to animate a /// Int32 property value along a set of key frames. /// /// This Int32KeyFrame interpolates between the Int32 Value of /// the previous key frame and its own Value to produce its output value. /// public partial class SplineInt32KeyFrame : Int32KeyFrame { #region Constructors ////// Creates a new SplineInt32KeyFrame. /// public SplineInt32KeyFrame() : base() { } ////// Creates a new SplineInt32KeyFrame. /// public SplineInt32KeyFrame(Int32 value) : this() { Value = value; } ////// Creates a new SplineInt32KeyFrame. /// public SplineInt32KeyFrame(Int32 value, KeyTime keyTime) : this() { Value = value; KeyTime = keyTime; } ////// Creates a new SplineInt32KeyFrame. /// public SplineInt32KeyFrame(Int32 value, KeyTime keyTime, KeySpline keySpline) : this() { if (keySpline == null) { throw new ArgumentNullException("keySpline"); } Value = value; KeyTime = keyTime; KeySpline = keySpline; } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new SplineInt32KeyFrame(); } #endregion #region Int32KeyFrame ////// Implemented to linearly interpolate between the baseValue and the /// Value of this KeyFrame using the keyFrameProgress. /// protected override Int32 InterpolateValueCore(Int32 baseValue, double keyFrameProgress) { if (keyFrameProgress == 0.0) { return baseValue; } else if (keyFrameProgress == 1.0) { return Value; } else { double splineProgress = KeySpline.GetSplineProgress(keyFrameProgress); return AnimatedTypeHelpers.InterpolateInt32(baseValue, Value, splineProgress); } } #endregion #region Public Properties ////// KeySpline Property /// public static readonly DependencyProperty KeySplineProperty = DependencyProperty.Register( "KeySpline", typeof(KeySpline), typeof(SplineInt32KeyFrame), new PropertyMetadata(new KeySpline())); ////// The KeySpline defines the way that progress will be altered for this /// key frame. /// public KeySpline KeySpline { get { return (KeySpline)GetValue(KeySplineProperty); } set { if (value == null) { throw new ArgumentNullException("value"); } SetValue(KeySplineProperty, value); } } #endregion } ////// This class is used as part of a Int64KeyFrameCollection in /// conjunction with a KeyFrameInt64Animation to animate a /// Int64 property value along a set of key frames. /// /// This Int64KeyFrame interpolates between the Int64 Value of /// the previous key frame and its own Value to produce its output value. /// public partial class SplineInt64KeyFrame : Int64KeyFrame { #region Constructors ////// Creates a new SplineInt64KeyFrame. /// public SplineInt64KeyFrame() : base() { } ////// Creates a new SplineInt64KeyFrame. /// public SplineInt64KeyFrame(Int64 value) : this() { Value = value; } ////// Creates a new SplineInt64KeyFrame. /// public SplineInt64KeyFrame(Int64 value, KeyTime keyTime) : this() { Value = value; KeyTime = keyTime; } ////// Creates a new SplineInt64KeyFrame. /// public SplineInt64KeyFrame(Int64 value, KeyTime keyTime, KeySpline keySpline) : this() { if (keySpline == null) { throw new ArgumentNullException("keySpline"); } Value = value; KeyTime = keyTime; KeySpline = keySpline; } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new SplineInt64KeyFrame(); } #endregion #region Int64KeyFrame ////// Implemented to linearly interpolate between the baseValue and the /// Value of this KeyFrame using the keyFrameProgress. /// protected override Int64 InterpolateValueCore(Int64 baseValue, double keyFrameProgress) { if (keyFrameProgress == 0.0) { return baseValue; } else if (keyFrameProgress == 1.0) { return Value; } else { double splineProgress = KeySpline.GetSplineProgress(keyFrameProgress); return AnimatedTypeHelpers.InterpolateInt64(baseValue, Value, splineProgress); } } #endregion #region Public Properties ////// KeySpline Property /// public static readonly DependencyProperty KeySplineProperty = DependencyProperty.Register( "KeySpline", typeof(KeySpline), typeof(SplineInt64KeyFrame), new PropertyMetadata(new KeySpline())); ////// The KeySpline defines the way that progress will be altered for this /// key frame. /// public KeySpline KeySpline { get { return (KeySpline)GetValue(KeySplineProperty); } set { if (value == null) { throw new ArgumentNullException("value"); } SetValue(KeySplineProperty, value); } } #endregion } ////// This class is used as part of a PointKeyFrameCollection in /// conjunction with a KeyFramePointAnimation to animate a /// Point property value along a set of key frames. /// /// This PointKeyFrame interpolates between the Point Value of /// the previous key frame and its own Value to produce its output value. /// public partial class SplinePointKeyFrame : PointKeyFrame { #region Constructors ////// Creates a new SplinePointKeyFrame. /// public SplinePointKeyFrame() : base() { } ////// Creates a new SplinePointKeyFrame. /// public SplinePointKeyFrame(Point value) : this() { Value = value; } ////// Creates a new SplinePointKeyFrame. /// public SplinePointKeyFrame(Point value, KeyTime keyTime) : this() { Value = value; KeyTime = keyTime; } ////// Creates a new SplinePointKeyFrame. /// public SplinePointKeyFrame(Point value, KeyTime keyTime, KeySpline keySpline) : this() { if (keySpline == null) { throw new ArgumentNullException("keySpline"); } Value = value; KeyTime = keyTime; KeySpline = keySpline; } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new SplinePointKeyFrame(); } #endregion #region PointKeyFrame ////// Implemented to linearly interpolate between the baseValue and the /// Value of this KeyFrame using the keyFrameProgress. /// protected override Point InterpolateValueCore(Point baseValue, double keyFrameProgress) { if (keyFrameProgress == 0.0) { return baseValue; } else if (keyFrameProgress == 1.0) { return Value; } else { double splineProgress = KeySpline.GetSplineProgress(keyFrameProgress); return AnimatedTypeHelpers.InterpolatePoint(baseValue, Value, splineProgress); } } #endregion #region Public Properties ////// KeySpline Property /// public static readonly DependencyProperty KeySplineProperty = DependencyProperty.Register( "KeySpline", typeof(KeySpline), typeof(SplinePointKeyFrame), new PropertyMetadata(new KeySpline())); ////// The KeySpline defines the way that progress will be altered for this /// key frame. /// public KeySpline KeySpline { get { return (KeySpline)GetValue(KeySplineProperty); } set { if (value == null) { throw new ArgumentNullException("value"); } SetValue(KeySplineProperty, value); } } #endregion } ////// This class is used as part of a Point3DKeyFrameCollection in /// conjunction with a KeyFramePoint3DAnimation to animate a /// Point3D property value along a set of key frames. /// /// This Point3DKeyFrame interpolates between the Point3D Value of /// the previous key frame and its own Value to produce its output value. /// public partial class SplinePoint3DKeyFrame : Point3DKeyFrame { #region Constructors ////// Creates a new SplinePoint3DKeyFrame. /// public SplinePoint3DKeyFrame() : base() { } ////// Creates a new SplinePoint3DKeyFrame. /// public SplinePoint3DKeyFrame(Point3D value) : this() { Value = value; } ////// Creates a new SplinePoint3DKeyFrame. /// public SplinePoint3DKeyFrame(Point3D value, KeyTime keyTime) : this() { Value = value; KeyTime = keyTime; } ////// Creates a new SplinePoint3DKeyFrame. /// public SplinePoint3DKeyFrame(Point3D value, KeyTime keyTime, KeySpline keySpline) : this() { if (keySpline == null) { throw new ArgumentNullException("keySpline"); } Value = value; KeyTime = keyTime; KeySpline = keySpline; } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new SplinePoint3DKeyFrame(); } #endregion #region Point3DKeyFrame ////// Implemented to linearly interpolate between the baseValue and the /// Value of this KeyFrame using the keyFrameProgress. /// protected override Point3D InterpolateValueCore(Point3D baseValue, double keyFrameProgress) { if (keyFrameProgress == 0.0) { return baseValue; } else if (keyFrameProgress == 1.0) { return Value; } else { double splineProgress = KeySpline.GetSplineProgress(keyFrameProgress); return AnimatedTypeHelpers.InterpolatePoint3D(baseValue, Value, splineProgress); } } #endregion #region Public Properties ////// KeySpline Property /// public static readonly DependencyProperty KeySplineProperty = DependencyProperty.Register( "KeySpline", typeof(KeySpline), typeof(SplinePoint3DKeyFrame), new PropertyMetadata(new KeySpline())); ////// The KeySpline defines the way that progress will be altered for this /// key frame. /// public KeySpline KeySpline { get { return (KeySpline)GetValue(KeySplineProperty); } set { if (value == null) { throw new ArgumentNullException("value"); } SetValue(KeySplineProperty, value); } } #endregion } ////// This class is used as part of a QuaternionKeyFrameCollection in /// conjunction with a KeyFrameQuaternionAnimation to animate a /// Quaternion property value along a set of key frames. /// /// This QuaternionKeyFrame interpolates between the Quaternion Value of /// the previous key frame and its own Value to produce its output value. /// public partial class SplineQuaternionKeyFrame : QuaternionKeyFrame { #region Constructors ////// Creates a new SplineQuaternionKeyFrame. /// public SplineQuaternionKeyFrame() : base() { } ////// Creates a new SplineQuaternionKeyFrame. /// public SplineQuaternionKeyFrame(Quaternion value) : this() { Value = value; } ////// Creates a new SplineQuaternionKeyFrame. /// public SplineQuaternionKeyFrame(Quaternion value, KeyTime keyTime) : this() { Value = value; KeyTime = keyTime; } ////// Creates a new SplineQuaternionKeyFrame. /// public SplineQuaternionKeyFrame(Quaternion value, KeyTime keyTime, KeySpline keySpline) : this() { if (keySpline == null) { throw new ArgumentNullException("keySpline"); } Value = value; KeyTime = keyTime; KeySpline = keySpline; } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new SplineQuaternionKeyFrame(); } #endregion #region QuaternionKeyFrame ////// Implemented to linearly interpolate between the baseValue and the /// Value of this KeyFrame using the keyFrameProgress. /// protected override Quaternion InterpolateValueCore(Quaternion baseValue, double keyFrameProgress) { if (keyFrameProgress == 0.0) { return baseValue; } else if (keyFrameProgress == 1.0) { return Value; } else { double splineProgress = KeySpline.GetSplineProgress(keyFrameProgress); return AnimatedTypeHelpers.InterpolateQuaternion(baseValue, Value, splineProgress, UseShortestPath); } } #endregion #region Public Properties ////// KeySpline Property /// public static readonly DependencyProperty KeySplineProperty = DependencyProperty.Register( "KeySpline", typeof(KeySpline), typeof(SplineQuaternionKeyFrame), new PropertyMetadata(new KeySpline())); ////// The KeySpline defines the way that progress will be altered for this /// key frame. /// public KeySpline KeySpline { get { return (KeySpline)GetValue(KeySplineProperty); } set { if (value == null) { throw new ArgumentNullException("value"); } SetValue(KeySplineProperty, value); } } #endregion } ////// This class is used as part of a Rotation3DKeyFrameCollection in /// conjunction with a KeyFrameRotation3DAnimation to animate a /// Rotation3D property value along a set of key frames. /// /// This Rotation3DKeyFrame interpolates between the Rotation3D Value of /// the previous key frame and its own Value to produce its output value. /// public partial class SplineRotation3DKeyFrame : Rotation3DKeyFrame { #region Constructors ////// Creates a new SplineRotation3DKeyFrame. /// public SplineRotation3DKeyFrame() : base() { } ////// Creates a new SplineRotation3DKeyFrame. /// public SplineRotation3DKeyFrame(Rotation3D value) : this() { Value = value; } ////// Creates a new SplineRotation3DKeyFrame. /// public SplineRotation3DKeyFrame(Rotation3D value, KeyTime keyTime) : this() { Value = value; KeyTime = keyTime; } ////// Creates a new SplineRotation3DKeyFrame. /// public SplineRotation3DKeyFrame(Rotation3D value, KeyTime keyTime, KeySpline keySpline) : this() { if (keySpline == null) { throw new ArgumentNullException("keySpline"); } Value = value; KeyTime = keyTime; KeySpline = keySpline; } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new SplineRotation3DKeyFrame(); } #endregion #region Rotation3DKeyFrame ////// Implemented to linearly interpolate between the baseValue and the /// Value of this KeyFrame using the keyFrameProgress. /// protected override Rotation3D InterpolateValueCore(Rotation3D baseValue, double keyFrameProgress) { if (keyFrameProgress == 0.0) { return baseValue; } else if (keyFrameProgress == 1.0) { return Value; } else { double splineProgress = KeySpline.GetSplineProgress(keyFrameProgress); return AnimatedTypeHelpers.InterpolateRotation3D(baseValue, Value, splineProgress); } } #endregion #region Public Properties ////// KeySpline Property /// public static readonly DependencyProperty KeySplineProperty = DependencyProperty.Register( "KeySpline", typeof(KeySpline), typeof(SplineRotation3DKeyFrame), new PropertyMetadata(new KeySpline())); ////// The KeySpline defines the way that progress will be altered for this /// key frame. /// public KeySpline KeySpline { get { return (KeySpline)GetValue(KeySplineProperty); } set { if (value == null) { throw new ArgumentNullException("value"); } SetValue(KeySplineProperty, value); } } #endregion } ////// This class is used as part of a RectKeyFrameCollection in /// conjunction with a KeyFrameRectAnimation to animate a /// Rect property value along a set of key frames. /// /// This RectKeyFrame interpolates between the Rect Value of /// the previous key frame and its own Value to produce its output value. /// public partial class SplineRectKeyFrame : RectKeyFrame { #region Constructors ////// Creates a new SplineRectKeyFrame. /// public SplineRectKeyFrame() : base() { } ////// Creates a new SplineRectKeyFrame. /// public SplineRectKeyFrame(Rect value) : this() { Value = value; } ////// Creates a new SplineRectKeyFrame. /// public SplineRectKeyFrame(Rect value, KeyTime keyTime) : this() { Value = value; KeyTime = keyTime; } ////// Creates a new SplineRectKeyFrame. /// public SplineRectKeyFrame(Rect value, KeyTime keyTime, KeySpline keySpline) : this() { if (keySpline == null) { throw new ArgumentNullException("keySpline"); } Value = value; KeyTime = keyTime; KeySpline = keySpline; } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new SplineRectKeyFrame(); } #endregion #region RectKeyFrame ////// Implemented to linearly interpolate between the baseValue and the /// Value of this KeyFrame using the keyFrameProgress. /// protected override Rect InterpolateValueCore(Rect baseValue, double keyFrameProgress) { if (keyFrameProgress == 0.0) { return baseValue; } else if (keyFrameProgress == 1.0) { return Value; } else { double splineProgress = KeySpline.GetSplineProgress(keyFrameProgress); return AnimatedTypeHelpers.InterpolateRect(baseValue, Value, splineProgress); } } #endregion #region Public Properties ////// KeySpline Property /// public static readonly DependencyProperty KeySplineProperty = DependencyProperty.Register( "KeySpline", typeof(KeySpline), typeof(SplineRectKeyFrame), new PropertyMetadata(new KeySpline())); ////// The KeySpline defines the way that progress will be altered for this /// key frame. /// public KeySpline KeySpline { get { return (KeySpline)GetValue(KeySplineProperty); } set { if (value == null) { throw new ArgumentNullException("value"); } SetValue(KeySplineProperty, value); } } #endregion } ////// This class is used as part of a SingleKeyFrameCollection in /// conjunction with a KeyFrameSingleAnimation to animate a /// Single property value along a set of key frames. /// /// This SingleKeyFrame interpolates between the Single Value of /// the previous key frame and its own Value to produce its output value. /// public partial class SplineSingleKeyFrame : SingleKeyFrame { #region Constructors ////// Creates a new SplineSingleKeyFrame. /// public SplineSingleKeyFrame() : base() { } ////// Creates a new SplineSingleKeyFrame. /// public SplineSingleKeyFrame(Single value) : this() { Value = value; } ////// Creates a new SplineSingleKeyFrame. /// public SplineSingleKeyFrame(Single value, KeyTime keyTime) : this() { Value = value; KeyTime = keyTime; } ////// Creates a new SplineSingleKeyFrame. /// public SplineSingleKeyFrame(Single value, KeyTime keyTime, KeySpline keySpline) : this() { if (keySpline == null) { throw new ArgumentNullException("keySpline"); } Value = value; KeyTime = keyTime; KeySpline = keySpline; } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new SplineSingleKeyFrame(); } #endregion #region SingleKeyFrame ////// Implemented to linearly interpolate between the baseValue and the /// Value of this KeyFrame using the keyFrameProgress. /// protected override Single InterpolateValueCore(Single baseValue, double keyFrameProgress) { if (keyFrameProgress == 0.0) { return baseValue; } else if (keyFrameProgress == 1.0) { return Value; } else { double splineProgress = KeySpline.GetSplineProgress(keyFrameProgress); return AnimatedTypeHelpers.InterpolateSingle(baseValue, Value, splineProgress); } } #endregion #region Public Properties ////// KeySpline Property /// public static readonly DependencyProperty KeySplineProperty = DependencyProperty.Register( "KeySpline", typeof(KeySpline), typeof(SplineSingleKeyFrame), new PropertyMetadata(new KeySpline())); ////// The KeySpline defines the way that progress will be altered for this /// key frame. /// public KeySpline KeySpline { get { return (KeySpline)GetValue(KeySplineProperty); } set { if (value == null) { throw new ArgumentNullException("value"); } SetValue(KeySplineProperty, value); } } #endregion } ////// This class is used as part of a SizeKeyFrameCollection in /// conjunction with a KeyFrameSizeAnimation to animate a /// Size property value along a set of key frames. /// /// This SizeKeyFrame interpolates between the Size Value of /// the previous key frame and its own Value to produce its output value. /// public partial class SplineSizeKeyFrame : SizeKeyFrame { #region Constructors ////// Creates a new SplineSizeKeyFrame. /// public SplineSizeKeyFrame() : base() { } ////// Creates a new SplineSizeKeyFrame. /// public SplineSizeKeyFrame(Size value) : this() { Value = value; } ////// Creates a new SplineSizeKeyFrame. /// public SplineSizeKeyFrame(Size value, KeyTime keyTime) : this() { Value = value; KeyTime = keyTime; } ////// Creates a new SplineSizeKeyFrame. /// public SplineSizeKeyFrame(Size value, KeyTime keyTime, KeySpline keySpline) : this() { if (keySpline == null) { throw new ArgumentNullException("keySpline"); } Value = value; KeyTime = keyTime; KeySpline = keySpline; } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new SplineSizeKeyFrame(); } #endregion #region SizeKeyFrame ////// Implemented to linearly interpolate between the baseValue and the /// Value of this KeyFrame using the keyFrameProgress. /// protected override Size InterpolateValueCore(Size baseValue, double keyFrameProgress) { if (keyFrameProgress == 0.0) { return baseValue; } else if (keyFrameProgress == 1.0) { return Value; } else { double splineProgress = KeySpline.GetSplineProgress(keyFrameProgress); return AnimatedTypeHelpers.InterpolateSize(baseValue, Value, splineProgress); } } #endregion #region Public Properties ////// KeySpline Property /// public static readonly DependencyProperty KeySplineProperty = DependencyProperty.Register( "KeySpline", typeof(KeySpline), typeof(SplineSizeKeyFrame), new PropertyMetadata(new KeySpline())); ////// The KeySpline defines the way that progress will be altered for this /// key frame. /// public KeySpline KeySpline { get { return (KeySpline)GetValue(KeySplineProperty); } set { if (value == null) { throw new ArgumentNullException("value"); } SetValue(KeySplineProperty, value); } } #endregion } ////// This class is used as part of a VectorKeyFrameCollection in /// conjunction with a KeyFrameVectorAnimation to animate a /// Vector property value along a set of key frames. /// /// This VectorKeyFrame interpolates between the Vector Value of /// the previous key frame and its own Value to produce its output value. /// public partial class SplineVectorKeyFrame : VectorKeyFrame { #region Constructors ////// Creates a new SplineVectorKeyFrame. /// public SplineVectorKeyFrame() : base() { } ////// Creates a new SplineVectorKeyFrame. /// public SplineVectorKeyFrame(Vector value) : this() { Value = value; } ////// Creates a new SplineVectorKeyFrame. /// public SplineVectorKeyFrame(Vector value, KeyTime keyTime) : this() { Value = value; KeyTime = keyTime; } ////// Creates a new SplineVectorKeyFrame. /// public SplineVectorKeyFrame(Vector value, KeyTime keyTime, KeySpline keySpline) : this() { if (keySpline == null) { throw new ArgumentNullException("keySpline"); } Value = value; KeyTime = keyTime; KeySpline = keySpline; } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new SplineVectorKeyFrame(); } #endregion #region VectorKeyFrame ////// Implemented to linearly interpolate between the baseValue and the /// Value of this KeyFrame using the keyFrameProgress. /// protected override Vector InterpolateValueCore(Vector baseValue, double keyFrameProgress) { if (keyFrameProgress == 0.0) { return baseValue; } else if (keyFrameProgress == 1.0) { return Value; } else { double splineProgress = KeySpline.GetSplineProgress(keyFrameProgress); return AnimatedTypeHelpers.InterpolateVector(baseValue, Value, splineProgress); } } #endregion #region Public Properties ////// KeySpline Property /// public static readonly DependencyProperty KeySplineProperty = DependencyProperty.Register( "KeySpline", typeof(KeySpline), typeof(SplineVectorKeyFrame), new PropertyMetadata(new KeySpline())); ////// The KeySpline defines the way that progress will be altered for this /// key frame. /// public KeySpline KeySpline { get { return (KeySpline)GetValue(KeySplineProperty); } set { if (value == null) { throw new ArgumentNullException("value"); } SetValue(KeySplineProperty, value); } } #endregion } ////// This class is used as part of a Vector3DKeyFrameCollection in /// conjunction with a KeyFrameVector3DAnimation to animate a /// Vector3D property value along a set of key frames. /// /// This Vector3DKeyFrame interpolates between the Vector3D Value of /// the previous key frame and its own Value to produce its output value. /// public partial class SplineVector3DKeyFrame : Vector3DKeyFrame { #region Constructors ////// Creates a new SplineVector3DKeyFrame. /// public SplineVector3DKeyFrame() : base() { } ////// Creates a new SplineVector3DKeyFrame. /// public SplineVector3DKeyFrame(Vector3D value) : this() { Value = value; } ////// Creates a new SplineVector3DKeyFrame. /// public SplineVector3DKeyFrame(Vector3D value, KeyTime keyTime) : this() { Value = value; KeyTime = keyTime; } ////// Creates a new SplineVector3DKeyFrame. /// public SplineVector3DKeyFrame(Vector3D value, KeyTime keyTime, KeySpline keySpline) : this() { if (keySpline == null) { throw new ArgumentNullException("keySpline"); } Value = value; KeyTime = keyTime; KeySpline = keySpline; } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new SplineVector3DKeyFrame(); } #endregion #region Vector3DKeyFrame ////// Implemented to linearly interpolate between the baseValue and the /// Value of this KeyFrame using the keyFrameProgress. /// protected override Vector3D InterpolateValueCore(Vector3D baseValue, double keyFrameProgress) { if (keyFrameProgress == 0.0) { return baseValue; } else if (keyFrameProgress == 1.0) { return Value; } else { double splineProgress = KeySpline.GetSplineProgress(keyFrameProgress); return AnimatedTypeHelpers.InterpolateVector3D(baseValue, Value, splineProgress); } } #endregion #region Public Properties ////// KeySpline Property /// public static readonly DependencyProperty KeySplineProperty = DependencyProperty.Register( "KeySpline", typeof(KeySpline), typeof(SplineVector3DKeyFrame), new PropertyMetadata(new KeySpline())); ////// The KeySpline defines the way that progress will be altered for this /// key frame. /// public KeySpline KeySpline { get { return (KeySpline)GetValue(KeySplineProperty); } set { if (value == null) { throw new ArgumentNullException("value"); } SetValue(KeySplineProperty, 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 System; using System.Collections; using System.ComponentModel; using System.Diagnostics; using System.Windows.Media; using System.Windows.Media.Media3D; using MS.Internal.PresentationCore; namespace System.Windows.Media.Animation { ////// This class is used as part of a ByteKeyFrameCollection in /// conjunction with a KeyFrameByteAnimation to animate a /// Byte property value along a set of key frames. /// /// This ByteKeyFrame interpolates between the Byte Value of /// the previous key frame and its own Value to produce its output value. /// public partial class SplineByteKeyFrame : ByteKeyFrame { #region Constructors ////// Creates a new SplineByteKeyFrame. /// public SplineByteKeyFrame() : base() { } ////// Creates a new SplineByteKeyFrame. /// public SplineByteKeyFrame(Byte value) : this() { Value = value; } ////// Creates a new SplineByteKeyFrame. /// public SplineByteKeyFrame(Byte value, KeyTime keyTime) : this() { Value = value; KeyTime = keyTime; } ////// Creates a new SplineByteKeyFrame. /// public SplineByteKeyFrame(Byte value, KeyTime keyTime, KeySpline keySpline) : this() { if (keySpline == null) { throw new ArgumentNullException("keySpline"); } Value = value; KeyTime = keyTime; KeySpline = keySpline; } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new SplineByteKeyFrame(); } #endregion #region ByteKeyFrame ////// Implemented to linearly interpolate between the baseValue and the /// Value of this KeyFrame using the keyFrameProgress. /// protected override Byte InterpolateValueCore(Byte baseValue, double keyFrameProgress) { if (keyFrameProgress == 0.0) { return baseValue; } else if (keyFrameProgress == 1.0) { return Value; } else { double splineProgress = KeySpline.GetSplineProgress(keyFrameProgress); return AnimatedTypeHelpers.InterpolateByte(baseValue, Value, splineProgress); } } #endregion #region Public Properties ////// KeySpline Property /// public static readonly DependencyProperty KeySplineProperty = DependencyProperty.Register( "KeySpline", typeof(KeySpline), typeof(SplineByteKeyFrame), new PropertyMetadata(new KeySpline())); ////// The KeySpline defines the way that progress will be altered for this /// key frame. /// public KeySpline KeySpline { get { return (KeySpline)GetValue(KeySplineProperty); } set { if (value == null) { throw new ArgumentNullException("value"); } SetValue(KeySplineProperty, value); } } #endregion } ////// This class is used as part of a ColorKeyFrameCollection in /// conjunction with a KeyFrameColorAnimation to animate a /// Color property value along a set of key frames. /// /// This ColorKeyFrame interpolates between the Color Value of /// the previous key frame and its own Value to produce its output value. /// public partial class SplineColorKeyFrame : ColorKeyFrame { #region Constructors ////// Creates a new SplineColorKeyFrame. /// public SplineColorKeyFrame() : base() { } ////// Creates a new SplineColorKeyFrame. /// public SplineColorKeyFrame(Color value) : this() { Value = value; } ////// Creates a new SplineColorKeyFrame. /// public SplineColorKeyFrame(Color value, KeyTime keyTime) : this() { Value = value; KeyTime = keyTime; } ////// Creates a new SplineColorKeyFrame. /// public SplineColorKeyFrame(Color value, KeyTime keyTime, KeySpline keySpline) : this() { if (keySpline == null) { throw new ArgumentNullException("keySpline"); } Value = value; KeyTime = keyTime; KeySpline = keySpline; } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new SplineColorKeyFrame(); } #endregion #region ColorKeyFrame ////// Implemented to linearly interpolate between the baseValue and the /// Value of this KeyFrame using the keyFrameProgress. /// protected override Color InterpolateValueCore(Color baseValue, double keyFrameProgress) { if (keyFrameProgress == 0.0) { return baseValue; } else if (keyFrameProgress == 1.0) { return Value; } else { double splineProgress = KeySpline.GetSplineProgress(keyFrameProgress); return AnimatedTypeHelpers.InterpolateColor(baseValue, Value, splineProgress); } } #endregion #region Public Properties ////// KeySpline Property /// public static readonly DependencyProperty KeySplineProperty = DependencyProperty.Register( "KeySpline", typeof(KeySpline), typeof(SplineColorKeyFrame), new PropertyMetadata(new KeySpline())); ////// The KeySpline defines the way that progress will be altered for this /// key frame. /// public KeySpline KeySpline { get { return (KeySpline)GetValue(KeySplineProperty); } set { if (value == null) { throw new ArgumentNullException("value"); } SetValue(KeySplineProperty, value); } } #endregion } ////// This class is used as part of a DecimalKeyFrameCollection in /// conjunction with a KeyFrameDecimalAnimation to animate a /// Decimal property value along a set of key frames. /// /// This DecimalKeyFrame interpolates between the Decimal Value of /// the previous key frame and its own Value to produce its output value. /// public partial class SplineDecimalKeyFrame : DecimalKeyFrame { #region Constructors ////// Creates a new SplineDecimalKeyFrame. /// public SplineDecimalKeyFrame() : base() { } ////// Creates a new SplineDecimalKeyFrame. /// public SplineDecimalKeyFrame(Decimal value) : this() { Value = value; } ////// Creates a new SplineDecimalKeyFrame. /// public SplineDecimalKeyFrame(Decimal value, KeyTime keyTime) : this() { Value = value; KeyTime = keyTime; } ////// Creates a new SplineDecimalKeyFrame. /// public SplineDecimalKeyFrame(Decimal value, KeyTime keyTime, KeySpline keySpline) : this() { if (keySpline == null) { throw new ArgumentNullException("keySpline"); } Value = value; KeyTime = keyTime; KeySpline = keySpline; } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new SplineDecimalKeyFrame(); } #endregion #region DecimalKeyFrame ////// Implemented to linearly interpolate between the baseValue and the /// Value of this KeyFrame using the keyFrameProgress. /// protected override Decimal InterpolateValueCore(Decimal baseValue, double keyFrameProgress) { if (keyFrameProgress == 0.0) { return baseValue; } else if (keyFrameProgress == 1.0) { return Value; } else { double splineProgress = KeySpline.GetSplineProgress(keyFrameProgress); return AnimatedTypeHelpers.InterpolateDecimal(baseValue, Value, splineProgress); } } #endregion #region Public Properties ////// KeySpline Property /// public static readonly DependencyProperty KeySplineProperty = DependencyProperty.Register( "KeySpline", typeof(KeySpline), typeof(SplineDecimalKeyFrame), new PropertyMetadata(new KeySpline())); ////// The KeySpline defines the way that progress will be altered for this /// key frame. /// public KeySpline KeySpline { get { return (KeySpline)GetValue(KeySplineProperty); } set { if (value == null) { throw new ArgumentNullException("value"); } SetValue(KeySplineProperty, value); } } #endregion } ////// This class is used as part of a DoubleKeyFrameCollection in /// conjunction with a KeyFrameDoubleAnimation to animate a /// Double property value along a set of key frames. /// /// This DoubleKeyFrame interpolates between the Double Value of /// the previous key frame and its own Value to produce its output value. /// public partial class SplineDoubleKeyFrame : DoubleKeyFrame { #region Constructors ////// Creates a new SplineDoubleKeyFrame. /// public SplineDoubleKeyFrame() : base() { } ////// Creates a new SplineDoubleKeyFrame. /// public SplineDoubleKeyFrame(Double value) : this() { Value = value; } ////// Creates a new SplineDoubleKeyFrame. /// public SplineDoubleKeyFrame(Double value, KeyTime keyTime) : this() { Value = value; KeyTime = keyTime; } ////// Creates a new SplineDoubleKeyFrame. /// public SplineDoubleKeyFrame(Double value, KeyTime keyTime, KeySpline keySpline) : this() { if (keySpline == null) { throw new ArgumentNullException("keySpline"); } Value = value; KeyTime = keyTime; KeySpline = keySpline; } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new SplineDoubleKeyFrame(); } #endregion #region DoubleKeyFrame ////// Implemented to linearly interpolate between the baseValue and the /// Value of this KeyFrame using the keyFrameProgress. /// protected override Double InterpolateValueCore(Double baseValue, double keyFrameProgress) { if (keyFrameProgress == 0.0) { return baseValue; } else if (keyFrameProgress == 1.0) { return Value; } else { double splineProgress = KeySpline.GetSplineProgress(keyFrameProgress); return AnimatedTypeHelpers.InterpolateDouble(baseValue, Value, splineProgress); } } #endregion #region Public Properties ////// KeySpline Property /// public static readonly DependencyProperty KeySplineProperty = DependencyProperty.Register( "KeySpline", typeof(KeySpline), typeof(SplineDoubleKeyFrame), new PropertyMetadata(new KeySpline())); ////// The KeySpline defines the way that progress will be altered for this /// key frame. /// public KeySpline KeySpline { get { return (KeySpline)GetValue(KeySplineProperty); } set { if (value == null) { throw new ArgumentNullException("value"); } SetValue(KeySplineProperty, value); } } #endregion } ////// This class is used as part of a Int16KeyFrameCollection in /// conjunction with a KeyFrameInt16Animation to animate a /// Int16 property value along a set of key frames. /// /// This Int16KeyFrame interpolates between the Int16 Value of /// the previous key frame and its own Value to produce its output value. /// public partial class SplineInt16KeyFrame : Int16KeyFrame { #region Constructors ////// Creates a new SplineInt16KeyFrame. /// public SplineInt16KeyFrame() : base() { } ////// Creates a new SplineInt16KeyFrame. /// public SplineInt16KeyFrame(Int16 value) : this() { Value = value; } ////// Creates a new SplineInt16KeyFrame. /// public SplineInt16KeyFrame(Int16 value, KeyTime keyTime) : this() { Value = value; KeyTime = keyTime; } ////// Creates a new SplineInt16KeyFrame. /// public SplineInt16KeyFrame(Int16 value, KeyTime keyTime, KeySpline keySpline) : this() { if (keySpline == null) { throw new ArgumentNullException("keySpline"); } Value = value; KeyTime = keyTime; KeySpline = keySpline; } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new SplineInt16KeyFrame(); } #endregion #region Int16KeyFrame ////// Implemented to linearly interpolate between the baseValue and the /// Value of this KeyFrame using the keyFrameProgress. /// protected override Int16 InterpolateValueCore(Int16 baseValue, double keyFrameProgress) { if (keyFrameProgress == 0.0) { return baseValue; } else if (keyFrameProgress == 1.0) { return Value; } else { double splineProgress = KeySpline.GetSplineProgress(keyFrameProgress); return AnimatedTypeHelpers.InterpolateInt16(baseValue, Value, splineProgress); } } #endregion #region Public Properties ////// KeySpline Property /// public static readonly DependencyProperty KeySplineProperty = DependencyProperty.Register( "KeySpline", typeof(KeySpline), typeof(SplineInt16KeyFrame), new PropertyMetadata(new KeySpline())); ////// The KeySpline defines the way that progress will be altered for this /// key frame. /// public KeySpline KeySpline { get { return (KeySpline)GetValue(KeySplineProperty); } set { if (value == null) { throw new ArgumentNullException("value"); } SetValue(KeySplineProperty, value); } } #endregion } ////// This class is used as part of a Int32KeyFrameCollection in /// conjunction with a KeyFrameInt32Animation to animate a /// Int32 property value along a set of key frames. /// /// This Int32KeyFrame interpolates between the Int32 Value of /// the previous key frame and its own Value to produce its output value. /// public partial class SplineInt32KeyFrame : Int32KeyFrame { #region Constructors ////// Creates a new SplineInt32KeyFrame. /// public SplineInt32KeyFrame() : base() { } ////// Creates a new SplineInt32KeyFrame. /// public SplineInt32KeyFrame(Int32 value) : this() { Value = value; } ////// Creates a new SplineInt32KeyFrame. /// public SplineInt32KeyFrame(Int32 value, KeyTime keyTime) : this() { Value = value; KeyTime = keyTime; } ////// Creates a new SplineInt32KeyFrame. /// public SplineInt32KeyFrame(Int32 value, KeyTime keyTime, KeySpline keySpline) : this() { if (keySpline == null) { throw new ArgumentNullException("keySpline"); } Value = value; KeyTime = keyTime; KeySpline = keySpline; } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new SplineInt32KeyFrame(); } #endregion #region Int32KeyFrame ////// Implemented to linearly interpolate between the baseValue and the /// Value of this KeyFrame using the keyFrameProgress. /// protected override Int32 InterpolateValueCore(Int32 baseValue, double keyFrameProgress) { if (keyFrameProgress == 0.0) { return baseValue; } else if (keyFrameProgress == 1.0) { return Value; } else { double splineProgress = KeySpline.GetSplineProgress(keyFrameProgress); return AnimatedTypeHelpers.InterpolateInt32(baseValue, Value, splineProgress); } } #endregion #region Public Properties ////// KeySpline Property /// public static readonly DependencyProperty KeySplineProperty = DependencyProperty.Register( "KeySpline", typeof(KeySpline), typeof(SplineInt32KeyFrame), new PropertyMetadata(new KeySpline())); ////// The KeySpline defines the way that progress will be altered for this /// key frame. /// public KeySpline KeySpline { get { return (KeySpline)GetValue(KeySplineProperty); } set { if (value == null) { throw new ArgumentNullException("value"); } SetValue(KeySplineProperty, value); } } #endregion } ////// This class is used as part of a Int64KeyFrameCollection in /// conjunction with a KeyFrameInt64Animation to animate a /// Int64 property value along a set of key frames. /// /// This Int64KeyFrame interpolates between the Int64 Value of /// the previous key frame and its own Value to produce its output value. /// public partial class SplineInt64KeyFrame : Int64KeyFrame { #region Constructors ////// Creates a new SplineInt64KeyFrame. /// public SplineInt64KeyFrame() : base() { } ////// Creates a new SplineInt64KeyFrame. /// public SplineInt64KeyFrame(Int64 value) : this() { Value = value; } ////// Creates a new SplineInt64KeyFrame. /// public SplineInt64KeyFrame(Int64 value, KeyTime keyTime) : this() { Value = value; KeyTime = keyTime; } ////// Creates a new SplineInt64KeyFrame. /// public SplineInt64KeyFrame(Int64 value, KeyTime keyTime, KeySpline keySpline) : this() { if (keySpline == null) { throw new ArgumentNullException("keySpline"); } Value = value; KeyTime = keyTime; KeySpline = keySpline; } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new SplineInt64KeyFrame(); } #endregion #region Int64KeyFrame ////// Implemented to linearly interpolate between the baseValue and the /// Value of this KeyFrame using the keyFrameProgress. /// protected override Int64 InterpolateValueCore(Int64 baseValue, double keyFrameProgress) { if (keyFrameProgress == 0.0) { return baseValue; } else if (keyFrameProgress == 1.0) { return Value; } else { double splineProgress = KeySpline.GetSplineProgress(keyFrameProgress); return AnimatedTypeHelpers.InterpolateInt64(baseValue, Value, splineProgress); } } #endregion #region Public Properties ////// KeySpline Property /// public static readonly DependencyProperty KeySplineProperty = DependencyProperty.Register( "KeySpline", typeof(KeySpline), typeof(SplineInt64KeyFrame), new PropertyMetadata(new KeySpline())); ////// The KeySpline defines the way that progress will be altered for this /// key frame. /// public KeySpline KeySpline { get { return (KeySpline)GetValue(KeySplineProperty); } set { if (value == null) { throw new ArgumentNullException("value"); } SetValue(KeySplineProperty, value); } } #endregion } ////// This class is used as part of a PointKeyFrameCollection in /// conjunction with a KeyFramePointAnimation to animate a /// Point property value along a set of key frames. /// /// This PointKeyFrame interpolates between the Point Value of /// the previous key frame and its own Value to produce its output value. /// public partial class SplinePointKeyFrame : PointKeyFrame { #region Constructors ////// Creates a new SplinePointKeyFrame. /// public SplinePointKeyFrame() : base() { } ////// Creates a new SplinePointKeyFrame. /// public SplinePointKeyFrame(Point value) : this() { Value = value; } ////// Creates a new SplinePointKeyFrame. /// public SplinePointKeyFrame(Point value, KeyTime keyTime) : this() { Value = value; KeyTime = keyTime; } ////// Creates a new SplinePointKeyFrame. /// public SplinePointKeyFrame(Point value, KeyTime keyTime, KeySpline keySpline) : this() { if (keySpline == null) { throw new ArgumentNullException("keySpline"); } Value = value; KeyTime = keyTime; KeySpline = keySpline; } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new SplinePointKeyFrame(); } #endregion #region PointKeyFrame ////// Implemented to linearly interpolate between the baseValue and the /// Value of this KeyFrame using the keyFrameProgress. /// protected override Point InterpolateValueCore(Point baseValue, double keyFrameProgress) { if (keyFrameProgress == 0.0) { return baseValue; } else if (keyFrameProgress == 1.0) { return Value; } else { double splineProgress = KeySpline.GetSplineProgress(keyFrameProgress); return AnimatedTypeHelpers.InterpolatePoint(baseValue, Value, splineProgress); } } #endregion #region Public Properties ////// KeySpline Property /// public static readonly DependencyProperty KeySplineProperty = DependencyProperty.Register( "KeySpline", typeof(KeySpline), typeof(SplinePointKeyFrame), new PropertyMetadata(new KeySpline())); ////// The KeySpline defines the way that progress will be altered for this /// key frame. /// public KeySpline KeySpline { get { return (KeySpline)GetValue(KeySplineProperty); } set { if (value == null) { throw new ArgumentNullException("value"); } SetValue(KeySplineProperty, value); } } #endregion } ////// This class is used as part of a Point3DKeyFrameCollection in /// conjunction with a KeyFramePoint3DAnimation to animate a /// Point3D property value along a set of key frames. /// /// This Point3DKeyFrame interpolates between the Point3D Value of /// the previous key frame and its own Value to produce its output value. /// public partial class SplinePoint3DKeyFrame : Point3DKeyFrame { #region Constructors ////// Creates a new SplinePoint3DKeyFrame. /// public SplinePoint3DKeyFrame() : base() { } ////// Creates a new SplinePoint3DKeyFrame. /// public SplinePoint3DKeyFrame(Point3D value) : this() { Value = value; } ////// Creates a new SplinePoint3DKeyFrame. /// public SplinePoint3DKeyFrame(Point3D value, KeyTime keyTime) : this() { Value = value; KeyTime = keyTime; } ////// Creates a new SplinePoint3DKeyFrame. /// public SplinePoint3DKeyFrame(Point3D value, KeyTime keyTime, KeySpline keySpline) : this() { if (keySpline == null) { throw new ArgumentNullException("keySpline"); } Value = value; KeyTime = keyTime; KeySpline = keySpline; } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new SplinePoint3DKeyFrame(); } #endregion #region Point3DKeyFrame ////// Implemented to linearly interpolate between the baseValue and the /// Value of this KeyFrame using the keyFrameProgress. /// protected override Point3D InterpolateValueCore(Point3D baseValue, double keyFrameProgress) { if (keyFrameProgress == 0.0) { return baseValue; } else if (keyFrameProgress == 1.0) { return Value; } else { double splineProgress = KeySpline.GetSplineProgress(keyFrameProgress); return AnimatedTypeHelpers.InterpolatePoint3D(baseValue, Value, splineProgress); } } #endregion #region Public Properties ////// KeySpline Property /// public static readonly DependencyProperty KeySplineProperty = DependencyProperty.Register( "KeySpline", typeof(KeySpline), typeof(SplinePoint3DKeyFrame), new PropertyMetadata(new KeySpline())); ////// The KeySpline defines the way that progress will be altered for this /// key frame. /// public KeySpline KeySpline { get { return (KeySpline)GetValue(KeySplineProperty); } set { if (value == null) { throw new ArgumentNullException("value"); } SetValue(KeySplineProperty, value); } } #endregion } ////// This class is used as part of a QuaternionKeyFrameCollection in /// conjunction with a KeyFrameQuaternionAnimation to animate a /// Quaternion property value along a set of key frames. /// /// This QuaternionKeyFrame interpolates between the Quaternion Value of /// the previous key frame and its own Value to produce its output value. /// public partial class SplineQuaternionKeyFrame : QuaternionKeyFrame { #region Constructors ////// Creates a new SplineQuaternionKeyFrame. /// public SplineQuaternionKeyFrame() : base() { } ////// Creates a new SplineQuaternionKeyFrame. /// public SplineQuaternionKeyFrame(Quaternion value) : this() { Value = value; } ////// Creates a new SplineQuaternionKeyFrame. /// public SplineQuaternionKeyFrame(Quaternion value, KeyTime keyTime) : this() { Value = value; KeyTime = keyTime; } ////// Creates a new SplineQuaternionKeyFrame. /// public SplineQuaternionKeyFrame(Quaternion value, KeyTime keyTime, KeySpline keySpline) : this() { if (keySpline == null) { throw new ArgumentNullException("keySpline"); } Value = value; KeyTime = keyTime; KeySpline = keySpline; } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new SplineQuaternionKeyFrame(); } #endregion #region QuaternionKeyFrame ////// Implemented to linearly interpolate between the baseValue and the /// Value of this KeyFrame using the keyFrameProgress. /// protected override Quaternion InterpolateValueCore(Quaternion baseValue, double keyFrameProgress) { if (keyFrameProgress == 0.0) { return baseValue; } else if (keyFrameProgress == 1.0) { return Value; } else { double splineProgress = KeySpline.GetSplineProgress(keyFrameProgress); return AnimatedTypeHelpers.InterpolateQuaternion(baseValue, Value, splineProgress, UseShortestPath); } } #endregion #region Public Properties ////// KeySpline Property /// public static readonly DependencyProperty KeySplineProperty = DependencyProperty.Register( "KeySpline", typeof(KeySpline), typeof(SplineQuaternionKeyFrame), new PropertyMetadata(new KeySpline())); ////// The KeySpline defines the way that progress will be altered for this /// key frame. /// public KeySpline KeySpline { get { return (KeySpline)GetValue(KeySplineProperty); } set { if (value == null) { throw new ArgumentNullException("value"); } SetValue(KeySplineProperty, value); } } #endregion } ////// This class is used as part of a Rotation3DKeyFrameCollection in /// conjunction with a KeyFrameRotation3DAnimation to animate a /// Rotation3D property value along a set of key frames. /// /// This Rotation3DKeyFrame interpolates between the Rotation3D Value of /// the previous key frame and its own Value to produce its output value. /// public partial class SplineRotation3DKeyFrame : Rotation3DKeyFrame { #region Constructors ////// Creates a new SplineRotation3DKeyFrame. /// public SplineRotation3DKeyFrame() : base() { } ////// Creates a new SplineRotation3DKeyFrame. /// public SplineRotation3DKeyFrame(Rotation3D value) : this() { Value = value; } ////// Creates a new SplineRotation3DKeyFrame. /// public SplineRotation3DKeyFrame(Rotation3D value, KeyTime keyTime) : this() { Value = value; KeyTime = keyTime; } ////// Creates a new SplineRotation3DKeyFrame. /// public SplineRotation3DKeyFrame(Rotation3D value, KeyTime keyTime, KeySpline keySpline) : this() { if (keySpline == null) { throw new ArgumentNullException("keySpline"); } Value = value; KeyTime = keyTime; KeySpline = keySpline; } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new SplineRotation3DKeyFrame(); } #endregion #region Rotation3DKeyFrame ////// Implemented to linearly interpolate between the baseValue and the /// Value of this KeyFrame using the keyFrameProgress. /// protected override Rotation3D InterpolateValueCore(Rotation3D baseValue, double keyFrameProgress) { if (keyFrameProgress == 0.0) { return baseValue; } else if (keyFrameProgress == 1.0) { return Value; } else { double splineProgress = KeySpline.GetSplineProgress(keyFrameProgress); return AnimatedTypeHelpers.InterpolateRotation3D(baseValue, Value, splineProgress); } } #endregion #region Public Properties ////// KeySpline Property /// public static readonly DependencyProperty KeySplineProperty = DependencyProperty.Register( "KeySpline", typeof(KeySpline), typeof(SplineRotation3DKeyFrame), new PropertyMetadata(new KeySpline())); ////// The KeySpline defines the way that progress will be altered for this /// key frame. /// public KeySpline KeySpline { get { return (KeySpline)GetValue(KeySplineProperty); } set { if (value == null) { throw new ArgumentNullException("value"); } SetValue(KeySplineProperty, value); } } #endregion } ////// This class is used as part of a RectKeyFrameCollection in /// conjunction with a KeyFrameRectAnimation to animate a /// Rect property value along a set of key frames. /// /// This RectKeyFrame interpolates between the Rect Value of /// the previous key frame and its own Value to produce its output value. /// public partial class SplineRectKeyFrame : RectKeyFrame { #region Constructors ////// Creates a new SplineRectKeyFrame. /// public SplineRectKeyFrame() : base() { } ////// Creates a new SplineRectKeyFrame. /// public SplineRectKeyFrame(Rect value) : this() { Value = value; } ////// Creates a new SplineRectKeyFrame. /// public SplineRectKeyFrame(Rect value, KeyTime keyTime) : this() { Value = value; KeyTime = keyTime; } ////// Creates a new SplineRectKeyFrame. /// public SplineRectKeyFrame(Rect value, KeyTime keyTime, KeySpline keySpline) : this() { if (keySpline == null) { throw new ArgumentNullException("keySpline"); } Value = value; KeyTime = keyTime; KeySpline = keySpline; } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new SplineRectKeyFrame(); } #endregion #region RectKeyFrame ////// Implemented to linearly interpolate between the baseValue and the /// Value of this KeyFrame using the keyFrameProgress. /// protected override Rect InterpolateValueCore(Rect baseValue, double keyFrameProgress) { if (keyFrameProgress == 0.0) { return baseValue; } else if (keyFrameProgress == 1.0) { return Value; } else { double splineProgress = KeySpline.GetSplineProgress(keyFrameProgress); return AnimatedTypeHelpers.InterpolateRect(baseValue, Value, splineProgress); } } #endregion #region Public Properties ////// KeySpline Property /// public static readonly DependencyProperty KeySplineProperty = DependencyProperty.Register( "KeySpline", typeof(KeySpline), typeof(SplineRectKeyFrame), new PropertyMetadata(new KeySpline())); ////// The KeySpline defines the way that progress will be altered for this /// key frame. /// public KeySpline KeySpline { get { return (KeySpline)GetValue(KeySplineProperty); } set { if (value == null) { throw new ArgumentNullException("value"); } SetValue(KeySplineProperty, value); } } #endregion } ////// This class is used as part of a SingleKeyFrameCollection in /// conjunction with a KeyFrameSingleAnimation to animate a /// Single property value along a set of key frames. /// /// This SingleKeyFrame interpolates between the Single Value of /// the previous key frame and its own Value to produce its output value. /// public partial class SplineSingleKeyFrame : SingleKeyFrame { #region Constructors ////// Creates a new SplineSingleKeyFrame. /// public SplineSingleKeyFrame() : base() { } ////// Creates a new SplineSingleKeyFrame. /// public SplineSingleKeyFrame(Single value) : this() { Value = value; } ////// Creates a new SplineSingleKeyFrame. /// public SplineSingleKeyFrame(Single value, KeyTime keyTime) : this() { Value = value; KeyTime = keyTime; } ////// Creates a new SplineSingleKeyFrame. /// public SplineSingleKeyFrame(Single value, KeyTime keyTime, KeySpline keySpline) : this() { if (keySpline == null) { throw new ArgumentNullException("keySpline"); } Value = value; KeyTime = keyTime; KeySpline = keySpline; } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new SplineSingleKeyFrame(); } #endregion #region SingleKeyFrame ////// Implemented to linearly interpolate between the baseValue and the /// Value of this KeyFrame using the keyFrameProgress. /// protected override Single InterpolateValueCore(Single baseValue, double keyFrameProgress) { if (keyFrameProgress == 0.0) { return baseValue; } else if (keyFrameProgress == 1.0) { return Value; } else { double splineProgress = KeySpline.GetSplineProgress(keyFrameProgress); return AnimatedTypeHelpers.InterpolateSingle(baseValue, Value, splineProgress); } } #endregion #region Public Properties ////// KeySpline Property /// public static readonly DependencyProperty KeySplineProperty = DependencyProperty.Register( "KeySpline", typeof(KeySpline), typeof(SplineSingleKeyFrame), new PropertyMetadata(new KeySpline())); ////// The KeySpline defines the way that progress will be altered for this /// key frame. /// public KeySpline KeySpline { get { return (KeySpline)GetValue(KeySplineProperty); } set { if (value == null) { throw new ArgumentNullException("value"); } SetValue(KeySplineProperty, value); } } #endregion } ////// This class is used as part of a SizeKeyFrameCollection in /// conjunction with a KeyFrameSizeAnimation to animate a /// Size property value along a set of key frames. /// /// This SizeKeyFrame interpolates between the Size Value of /// the previous key frame and its own Value to produce its output value. /// public partial class SplineSizeKeyFrame : SizeKeyFrame { #region Constructors ////// Creates a new SplineSizeKeyFrame. /// public SplineSizeKeyFrame() : base() { } ////// Creates a new SplineSizeKeyFrame. /// public SplineSizeKeyFrame(Size value) : this() { Value = value; } ////// Creates a new SplineSizeKeyFrame. /// public SplineSizeKeyFrame(Size value, KeyTime keyTime) : this() { Value = value; KeyTime = keyTime; } ////// Creates a new SplineSizeKeyFrame. /// public SplineSizeKeyFrame(Size value, KeyTime keyTime, KeySpline keySpline) : this() { if (keySpline == null) { throw new ArgumentNullException("keySpline"); } Value = value; KeyTime = keyTime; KeySpline = keySpline; } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new SplineSizeKeyFrame(); } #endregion #region SizeKeyFrame ////// Implemented to linearly interpolate between the baseValue and the /// Value of this KeyFrame using the keyFrameProgress. /// protected override Size InterpolateValueCore(Size baseValue, double keyFrameProgress) { if (keyFrameProgress == 0.0) { return baseValue; } else if (keyFrameProgress == 1.0) { return Value; } else { double splineProgress = KeySpline.GetSplineProgress(keyFrameProgress); return AnimatedTypeHelpers.InterpolateSize(baseValue, Value, splineProgress); } } #endregion #region Public Properties ////// KeySpline Property /// public static readonly DependencyProperty KeySplineProperty = DependencyProperty.Register( "KeySpline", typeof(KeySpline), typeof(SplineSizeKeyFrame), new PropertyMetadata(new KeySpline())); ////// The KeySpline defines the way that progress will be altered for this /// key frame. /// public KeySpline KeySpline { get { return (KeySpline)GetValue(KeySplineProperty); } set { if (value == null) { throw new ArgumentNullException("value"); } SetValue(KeySplineProperty, value); } } #endregion } ////// This class is used as part of a VectorKeyFrameCollection in /// conjunction with a KeyFrameVectorAnimation to animate a /// Vector property value along a set of key frames. /// /// This VectorKeyFrame interpolates between the Vector Value of /// the previous key frame and its own Value to produce its output value. /// public partial class SplineVectorKeyFrame : VectorKeyFrame { #region Constructors ////// Creates a new SplineVectorKeyFrame. /// public SplineVectorKeyFrame() : base() { } ////// Creates a new SplineVectorKeyFrame. /// public SplineVectorKeyFrame(Vector value) : this() { Value = value; } ////// Creates a new SplineVectorKeyFrame. /// public SplineVectorKeyFrame(Vector value, KeyTime keyTime) : this() { Value = value; KeyTime = keyTime; } ////// Creates a new SplineVectorKeyFrame. /// public SplineVectorKeyFrame(Vector value, KeyTime keyTime, KeySpline keySpline) : this() { if (keySpline == null) { throw new ArgumentNullException("keySpline"); } Value = value; KeyTime = keyTime; KeySpline = keySpline; } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new SplineVectorKeyFrame(); } #endregion #region VectorKeyFrame ////// Implemented to linearly interpolate between the baseValue and the /// Value of this KeyFrame using the keyFrameProgress. /// protected override Vector InterpolateValueCore(Vector baseValue, double keyFrameProgress) { if (keyFrameProgress == 0.0) { return baseValue; } else if (keyFrameProgress == 1.0) { return Value; } else { double splineProgress = KeySpline.GetSplineProgress(keyFrameProgress); return AnimatedTypeHelpers.InterpolateVector(baseValue, Value, splineProgress); } } #endregion #region Public Properties ////// KeySpline Property /// public static readonly DependencyProperty KeySplineProperty = DependencyProperty.Register( "KeySpline", typeof(KeySpline), typeof(SplineVectorKeyFrame), new PropertyMetadata(new KeySpline())); ////// The KeySpline defines the way that progress will be altered for this /// key frame. /// public KeySpline KeySpline { get { return (KeySpline)GetValue(KeySplineProperty); } set { if (value == null) { throw new ArgumentNullException("value"); } SetValue(KeySplineProperty, value); } } #endregion } ////// This class is used as part of a Vector3DKeyFrameCollection in /// conjunction with a KeyFrameVector3DAnimation to animate a /// Vector3D property value along a set of key frames. /// /// This Vector3DKeyFrame interpolates between the Vector3D Value of /// the previous key frame and its own Value to produce its output value. /// public partial class SplineVector3DKeyFrame : Vector3DKeyFrame { #region Constructors ////// Creates a new SplineVector3DKeyFrame. /// public SplineVector3DKeyFrame() : base() { } ////// Creates a new SplineVector3DKeyFrame. /// public SplineVector3DKeyFrame(Vector3D value) : this() { Value = value; } ////// Creates a new SplineVector3DKeyFrame. /// public SplineVector3DKeyFrame(Vector3D value, KeyTime keyTime) : this() { Value = value; KeyTime = keyTime; } ////// Creates a new SplineVector3DKeyFrame. /// public SplineVector3DKeyFrame(Vector3D value, KeyTime keyTime, KeySpline keySpline) : this() { if (keySpline == null) { throw new ArgumentNullException("keySpline"); } Value = value; KeyTime = keyTime; KeySpline = keySpline; } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new SplineVector3DKeyFrame(); } #endregion #region Vector3DKeyFrame ////// Implemented to linearly interpolate between the baseValue and the /// Value of this KeyFrame using the keyFrameProgress. /// protected override Vector3D InterpolateValueCore(Vector3D baseValue, double keyFrameProgress) { if (keyFrameProgress == 0.0) { return baseValue; } else if (keyFrameProgress == 1.0) { return Value; } else { double splineProgress = KeySpline.GetSplineProgress(keyFrameProgress); return AnimatedTypeHelpers.InterpolateVector3D(baseValue, Value, splineProgress); } } #endregion #region Public Properties ////// KeySpline Property /// public static readonly DependencyProperty KeySplineProperty = DependencyProperty.Register( "KeySpline", typeof(KeySpline), typeof(SplineVector3DKeyFrame), new PropertyMetadata(new KeySpline())); ////// The KeySpline defines the way that progress will be altered for this /// key frame. /// public KeySpline KeySpline { get { return (KeySpline)GetValue(KeySplineProperty); } set { if (value == null) { throw new ArgumentNullException("value"); } SetValue(KeySplineProperty, value); } } #endregion } } // File provided for Reference Use Only by Microsoft Corporation (c) 2007. // Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- DbProviderFactoriesConfigurationHandler.cs
- ListControlBoundActionList.cs
- HiddenFieldPageStatePersister.cs
- StringExpressionSet.cs
- RewritingSimplifier.cs
- CornerRadiusConverter.cs
- NativeMethodsCLR.cs
- FixedTextSelectionProcessor.cs
- HttpRawResponse.cs
- WinOEToolBoxItem.cs
- GlyphInfoList.cs
- Panel.cs
- ResourceProviderFactory.cs
- Button.cs
- NavigationFailedEventArgs.cs
- CellTreeNodeVisitors.cs
- StringComparer.cs
- X509CertificateRecipientServiceCredential.cs
- DocumentPageView.cs
- Hash.cs
- DataReaderContainer.cs
- ExpressionEditorAttribute.cs
- URIFormatException.cs
- NoneExcludedImageIndexConverter.cs
- ToolStripPanelRow.cs
- Trace.cs
- XmlNotation.cs
- EqualityComparer.cs
- ToolBar.cs
- ObjectItemCollection.cs
- TypeLibConverter.cs
- MetafileHeader.cs
- LinqDataSourceDisposeEventArgs.cs
- FaultImportOptions.cs
- CurrentChangedEventManager.cs
- SamlAuthenticationStatement.cs
- Matrix.cs
- ObjectQueryState.cs
- DrawingState.cs
- TreeNode.cs
- RegexCompilationInfo.cs
- HttpContextWrapper.cs
- WsdlInspector.cs
- DataPagerField.cs
- ConfigurationValidatorBase.cs
- ToolStripSettings.cs
- ObjectStateEntryDbDataRecord.cs
- HtmlCalendarAdapter.cs
- DataSourceProvider.cs
- ITextView.cs
- TextChange.cs
- SelectionEditingBehavior.cs
- WebPartZoneCollection.cs
- JournalEntryStack.cs
- StatusBarPanel.cs
- remotingproxy.cs
- ThicknessAnimation.cs
- RegexCompilationInfo.cs
- DbExpressionVisitor.cs
- SystemFonts.cs
- SettingsSavedEventArgs.cs
- DataTableCollection.cs
- XamlToRtfParser.cs
- BooleanFunctions.cs
- SchemaMerger.cs
- ImageFormat.cs
- httpapplicationstate.cs
- ConfigPathUtility.cs
- SerializableAttribute.cs
- ControlIdConverter.cs
- DelayedRegex.cs
- FreezableDefaultValueFactory.cs
- ByteStack.cs
- Paragraph.cs
- ObjectContextServiceProvider.cs
- VarRemapper.cs
- ServiceManager.cs
- ThreadWorkerController.cs
- XmlNotation.cs
- Light.cs
- SqlServices.cs
- PersonalizableTypeEntry.cs
- DateTimeEditor.cs
- SearchForVirtualItemEventArgs.cs
- RequestCache.cs
- XmlBindingWorker.cs
- MethodToken.cs
- StylusPlugin.cs
- SamlAction.cs
- SafeRegistryKey.cs
- MessageSecurityVersion.cs
- Accessible.cs
- TextBoxDesigner.cs
- DependencyPropertyKind.cs
- KeyTime.cs
- PrintPreviewGraphics.cs
- DBParameter.cs
- TextEffect.cs
- UrlSyndicationContent.cs
- ColumnMapProcessor.cs