Code:
/ Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / Orcas / NetFXw7 / 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
- ThemeDirectoryCompiler.cs
- TdsParserStateObject.cs
- WeakHashtable.cs
- ScriptResourceAttribute.cs
- JpegBitmapDecoder.cs
- SqlTypesSchemaImporter.cs
- TreeViewItemAutomationPeer.cs
- EntityDataSourceState.cs
- SID.cs
- DtdParser.cs
- Internal.cs
- TreeView.cs
- IdentityReference.cs
- PersonalizationAdministration.cs
- ApplicationGesture.cs
- userdatakeys.cs
- FolderBrowserDialog.cs
- ReferentialConstraint.cs
- MatrixCamera.cs
- LinkArea.cs
- XmlBaseReader.cs
- ForceCopyBuildProvider.cs
- OdbcRowUpdatingEvent.cs
- UDPClient.cs
- EntityClassGenerator.cs
- Viewport3DAutomationPeer.cs
- AttributeTableBuilder.cs
- InlinedAggregationOperatorEnumerator.cs
- HtmlInputButton.cs
- PageContent.cs
- BinaryCommonClasses.cs
- HMACSHA1.cs
- precedingsibling.cs
- Object.cs
- SHA512Managed.cs
- MetadataArtifactLoaderCompositeResource.cs
- GorillaCodec.cs
- DodSequenceMerge.cs
- WindowsUpDown.cs
- ReadOnlyDataSource.cs
- XpsDocumentEvent.cs
- IgnorePropertiesAttribute.cs
- DbModificationClause.cs
- BitmapEffect.cs
- ScanQueryOperator.cs
- HttpHandlerAction.cs
- MenuItemStyleCollection.cs
- XmlAttributeHolder.cs
- OutputCacheProfileCollection.cs
- HashHelpers.cs
- ColumnMapVisitor.cs
- RowTypePropertyElement.cs
- ResourceReferenceKeyNotFoundException.cs
- RegexMatch.cs
- ToggleButton.cs
- DrawingGroup.cs
- DocumentXPathNavigator.cs
- SearchForVirtualItemEventArgs.cs
- ThemeInfoAttribute.cs
- DBNull.cs
- StringWriter.cs
- ReflectionServiceProvider.cs
- ConfigurationLocation.cs
- VSWCFServiceContractGenerator.cs
- AutoGeneratedFieldProperties.cs
- ToolBarTray.cs
- CodeTypeOfExpression.cs
- InfoCardClaim.cs
- RuleConditionDialog.cs
- StrokeCollectionConverter.cs
- DesignerLoader.cs
- DataBindEngine.cs
- Crc32Helper.cs
- LayoutDump.cs
- DataServiceContext.cs
- TableLayoutStyle.cs
- TableStyle.cs
- FormatterServicesNoSerializableCheck.cs
- ConsoleEntryPoint.cs
- TraceInternal.cs
- UserControlParser.cs
- Endpoint.cs
- MessagePropertyVariants.cs
- Timer.cs
- ChtmlMobileTextWriter.cs
- GCHandleCookieTable.cs
- FlowDocumentReader.cs
- ServerReliableChannelBinder.cs
- SvcMapFileSerializer.cs
- HttpCapabilitiesBase.cs
- VerticalAlignConverter.cs
- ContentType.cs
- ObjectHandle.cs
- SqlPersonalizationProvider.cs
- NativeWindow.cs
- HelloOperationCD1AsyncResult.cs
- FormsAuthentication.cs
- TextDecorationCollectionConverter.cs
- InstanceKeyCompleteException.cs
- FileSystemEventArgs.cs