Code:
/ Net / Net / 3.5.50727.3053 / DEVDIV / depot / DevDiv / releases / Orcas / SP / wpf / src / Core / CSharp / System / Windows / Media / Animation / Generated / LinearKeyFrames.cs / 1 / LinearKeyFrames.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 the between the Byte Value of /// the previous key frame and its own Value linearly to produce its output value. /// public partial class LinearByteKeyFrame : ByteKeyFrame { #region Constructors ////// Creates a new LinearByteKeyFrame. /// public LinearByteKeyFrame() : base() { } ////// Creates a new LinearByteKeyFrame. /// public LinearByteKeyFrame(Byte value) : base(value) { } ////// Creates a new LinearByteKeyFrame. /// public LinearByteKeyFrame(Byte value, KeyTime keyTime) : base(value, keyTime) { } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new LinearByteKeyFrame(); } #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 { return AnimatedTypeHelpers.InterpolateByte(baseValue, Value, keyFrameProgress); } } #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 the between the Color Value of /// the previous key frame and its own Value linearly to produce its output value. /// public partial class LinearColorKeyFrame : ColorKeyFrame { #region Constructors ////// Creates a new LinearColorKeyFrame. /// public LinearColorKeyFrame() : base() { } ////// Creates a new LinearColorKeyFrame. /// public LinearColorKeyFrame(Color value) : base(value) { } ////// Creates a new LinearColorKeyFrame. /// public LinearColorKeyFrame(Color value, KeyTime keyTime) : base(value, keyTime) { } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new LinearColorKeyFrame(); } #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 { return AnimatedTypeHelpers.InterpolateColor(baseValue, Value, keyFrameProgress); } } #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 the between the Decimal Value of /// the previous key frame and its own Value linearly to produce its output value. /// public partial class LinearDecimalKeyFrame : DecimalKeyFrame { #region Constructors ////// Creates a new LinearDecimalKeyFrame. /// public LinearDecimalKeyFrame() : base() { } ////// Creates a new LinearDecimalKeyFrame. /// public LinearDecimalKeyFrame(Decimal value) : base(value) { } ////// Creates a new LinearDecimalKeyFrame. /// public LinearDecimalKeyFrame(Decimal value, KeyTime keyTime) : base(value, keyTime) { } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new LinearDecimalKeyFrame(); } #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 { return AnimatedTypeHelpers.InterpolateDecimal(baseValue, Value, keyFrameProgress); } } #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 the between the Double Value of /// the previous key frame and its own Value linearly to produce its output value. /// public partial class LinearDoubleKeyFrame : DoubleKeyFrame { #region Constructors ////// Creates a new LinearDoubleKeyFrame. /// public LinearDoubleKeyFrame() : base() { } ////// Creates a new LinearDoubleKeyFrame. /// public LinearDoubleKeyFrame(Double value) : base(value) { } ////// Creates a new LinearDoubleKeyFrame. /// public LinearDoubleKeyFrame(Double value, KeyTime keyTime) : base(value, keyTime) { } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new LinearDoubleKeyFrame(); } #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 { return AnimatedTypeHelpers.InterpolateDouble(baseValue, Value, keyFrameProgress); } } #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 the between the Int16 Value of /// the previous key frame and its own Value linearly to produce its output value. /// public partial class LinearInt16KeyFrame : Int16KeyFrame { #region Constructors ////// Creates a new LinearInt16KeyFrame. /// public LinearInt16KeyFrame() : base() { } ////// Creates a new LinearInt16KeyFrame. /// public LinearInt16KeyFrame(Int16 value) : base(value) { } ////// Creates a new LinearInt16KeyFrame. /// public LinearInt16KeyFrame(Int16 value, KeyTime keyTime) : base(value, keyTime) { } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new LinearInt16KeyFrame(); } #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 { return AnimatedTypeHelpers.InterpolateInt16(baseValue, Value, keyFrameProgress); } } #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 the between the Int32 Value of /// the previous key frame and its own Value linearly to produce its output value. /// public partial class LinearInt32KeyFrame : Int32KeyFrame { #region Constructors ////// Creates a new LinearInt32KeyFrame. /// public LinearInt32KeyFrame() : base() { } ////// Creates a new LinearInt32KeyFrame. /// public LinearInt32KeyFrame(Int32 value) : base(value) { } ////// Creates a new LinearInt32KeyFrame. /// public LinearInt32KeyFrame(Int32 value, KeyTime keyTime) : base(value, keyTime) { } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new LinearInt32KeyFrame(); } #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 { return AnimatedTypeHelpers.InterpolateInt32(baseValue, Value, keyFrameProgress); } } #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 the between the Int64 Value of /// the previous key frame and its own Value linearly to produce its output value. /// public partial class LinearInt64KeyFrame : Int64KeyFrame { #region Constructors ////// Creates a new LinearInt64KeyFrame. /// public LinearInt64KeyFrame() : base() { } ////// Creates a new LinearInt64KeyFrame. /// public LinearInt64KeyFrame(Int64 value) : base(value) { } ////// Creates a new LinearInt64KeyFrame. /// public LinearInt64KeyFrame(Int64 value, KeyTime keyTime) : base(value, keyTime) { } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new LinearInt64KeyFrame(); } #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 { return AnimatedTypeHelpers.InterpolateInt64(baseValue, Value, keyFrameProgress); } } #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 the between the Point Value of /// the previous key frame and its own Value linearly to produce its output value. /// public partial class LinearPointKeyFrame : PointKeyFrame { #region Constructors ////// Creates a new LinearPointKeyFrame. /// public LinearPointKeyFrame() : base() { } ////// Creates a new LinearPointKeyFrame. /// public LinearPointKeyFrame(Point value) : base(value) { } ////// Creates a new LinearPointKeyFrame. /// public LinearPointKeyFrame(Point value, KeyTime keyTime) : base(value, keyTime) { } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new LinearPointKeyFrame(); } #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 { return AnimatedTypeHelpers.InterpolatePoint(baseValue, Value, keyFrameProgress); } } #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 the between the Point3D Value of /// the previous key frame and its own Value linearly to produce its output value. /// public partial class LinearPoint3DKeyFrame : Point3DKeyFrame { #region Constructors ////// Creates a new LinearPoint3DKeyFrame. /// public LinearPoint3DKeyFrame() : base() { } ////// Creates a new LinearPoint3DKeyFrame. /// public LinearPoint3DKeyFrame(Point3D value) : base(value) { } ////// Creates a new LinearPoint3DKeyFrame. /// public LinearPoint3DKeyFrame(Point3D value, KeyTime keyTime) : base(value, keyTime) { } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new LinearPoint3DKeyFrame(); } #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 { return AnimatedTypeHelpers.InterpolatePoint3D(baseValue, Value, keyFrameProgress); } } #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 the between the Quaternion Value of /// the previous key frame and its own Value linearly to produce its output value. /// public partial class LinearQuaternionKeyFrame : QuaternionKeyFrame { #region Constructors ////// Creates a new LinearQuaternionKeyFrame. /// public LinearQuaternionKeyFrame() : base() { } ////// Creates a new LinearQuaternionKeyFrame. /// public LinearQuaternionKeyFrame(Quaternion value) : base(value) { } ////// Creates a new LinearQuaternionKeyFrame. /// public LinearQuaternionKeyFrame(Quaternion value, KeyTime keyTime) : base(value, keyTime) { } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new LinearQuaternionKeyFrame(); } #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 { return AnimatedTypeHelpers.InterpolateQuaternion(baseValue, Value, keyFrameProgress, UseShortestPath); } } #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 the between the Rotation3D Value of /// the previous key frame and its own Value linearly to produce its output value. /// public partial class LinearRotation3DKeyFrame : Rotation3DKeyFrame { #region Constructors ////// Creates a new LinearRotation3DKeyFrame. /// public LinearRotation3DKeyFrame() : base() { } ////// Creates a new LinearRotation3DKeyFrame. /// public LinearRotation3DKeyFrame(Rotation3D value) : base(value) { } ////// Creates a new LinearRotation3DKeyFrame. /// public LinearRotation3DKeyFrame(Rotation3D value, KeyTime keyTime) : base(value, keyTime) { } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new LinearRotation3DKeyFrame(); } #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 { return AnimatedTypeHelpers.InterpolateRotation3D(baseValue, Value, keyFrameProgress); } } #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 the between the Rect Value of /// the previous key frame and its own Value linearly to produce its output value. /// public partial class LinearRectKeyFrame : RectKeyFrame { #region Constructors ////// Creates a new LinearRectKeyFrame. /// public LinearRectKeyFrame() : base() { } ////// Creates a new LinearRectKeyFrame. /// public LinearRectKeyFrame(Rect value) : base(value) { } ////// Creates a new LinearRectKeyFrame. /// public LinearRectKeyFrame(Rect value, KeyTime keyTime) : base(value, keyTime) { } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new LinearRectKeyFrame(); } #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 { return AnimatedTypeHelpers.InterpolateRect(baseValue, Value, keyFrameProgress); } } #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 the between the Single Value of /// the previous key frame and its own Value linearly to produce its output value. /// public partial class LinearSingleKeyFrame : SingleKeyFrame { #region Constructors ////// Creates a new LinearSingleKeyFrame. /// public LinearSingleKeyFrame() : base() { } ////// Creates a new LinearSingleKeyFrame. /// public LinearSingleKeyFrame(Single value) : base(value) { } ////// Creates a new LinearSingleKeyFrame. /// public LinearSingleKeyFrame(Single value, KeyTime keyTime) : base(value, keyTime) { } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new LinearSingleKeyFrame(); } #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 { return AnimatedTypeHelpers.InterpolateSingle(baseValue, Value, keyFrameProgress); } } #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 the between the Size Value of /// the previous key frame and its own Value linearly to produce its output value. /// public partial class LinearSizeKeyFrame : SizeKeyFrame { #region Constructors ////// Creates a new LinearSizeKeyFrame. /// public LinearSizeKeyFrame() : base() { } ////// Creates a new LinearSizeKeyFrame. /// public LinearSizeKeyFrame(Size value) : base(value) { } ////// Creates a new LinearSizeKeyFrame. /// public LinearSizeKeyFrame(Size value, KeyTime keyTime) : base(value, keyTime) { } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new LinearSizeKeyFrame(); } #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 { return AnimatedTypeHelpers.InterpolateSize(baseValue, Value, keyFrameProgress); } } #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 the between the Vector Value of /// the previous key frame and its own Value linearly to produce its output value. /// public partial class LinearVectorKeyFrame : VectorKeyFrame { #region Constructors ////// Creates a new LinearVectorKeyFrame. /// public LinearVectorKeyFrame() : base() { } ////// Creates a new LinearVectorKeyFrame. /// public LinearVectorKeyFrame(Vector value) : base(value) { } ////// Creates a new LinearVectorKeyFrame. /// public LinearVectorKeyFrame(Vector value, KeyTime keyTime) : base(value, keyTime) { } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new LinearVectorKeyFrame(); } #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 { return AnimatedTypeHelpers.InterpolateVector(baseValue, Value, keyFrameProgress); } } #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 the between the Vector3D Value of /// the previous key frame and its own Value linearly to produce its output value. /// public partial class LinearVector3DKeyFrame : Vector3DKeyFrame { #region Constructors ////// Creates a new LinearVector3DKeyFrame. /// public LinearVector3DKeyFrame() : base() { } ////// Creates a new LinearVector3DKeyFrame. /// public LinearVector3DKeyFrame(Vector3D value) : base(value) { } ////// Creates a new LinearVector3DKeyFrame. /// public LinearVector3DKeyFrame(Vector3D value, KeyTime keyTime) : base(value, keyTime) { } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new LinearVector3DKeyFrame(); } #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 { return AnimatedTypeHelpers.InterpolateVector3D(baseValue, Value, keyFrameProgress); } } #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 the between the Byte Value of /// the previous key frame and its own Value linearly to produce its output value. /// public partial class LinearByteKeyFrame : ByteKeyFrame { #region Constructors ////// Creates a new LinearByteKeyFrame. /// public LinearByteKeyFrame() : base() { } ////// Creates a new LinearByteKeyFrame. /// public LinearByteKeyFrame(Byte value) : base(value) { } ////// Creates a new LinearByteKeyFrame. /// public LinearByteKeyFrame(Byte value, KeyTime keyTime) : base(value, keyTime) { } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new LinearByteKeyFrame(); } #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 { return AnimatedTypeHelpers.InterpolateByte(baseValue, Value, keyFrameProgress); } } #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 the between the Color Value of /// the previous key frame and its own Value linearly to produce its output value. /// public partial class LinearColorKeyFrame : ColorKeyFrame { #region Constructors ////// Creates a new LinearColorKeyFrame. /// public LinearColorKeyFrame() : base() { } ////// Creates a new LinearColorKeyFrame. /// public LinearColorKeyFrame(Color value) : base(value) { } ////// Creates a new LinearColorKeyFrame. /// public LinearColorKeyFrame(Color value, KeyTime keyTime) : base(value, keyTime) { } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new LinearColorKeyFrame(); } #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 { return AnimatedTypeHelpers.InterpolateColor(baseValue, Value, keyFrameProgress); } } #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 the between the Decimal Value of /// the previous key frame and its own Value linearly to produce its output value. /// public partial class LinearDecimalKeyFrame : DecimalKeyFrame { #region Constructors ////// Creates a new LinearDecimalKeyFrame. /// public LinearDecimalKeyFrame() : base() { } ////// Creates a new LinearDecimalKeyFrame. /// public LinearDecimalKeyFrame(Decimal value) : base(value) { } ////// Creates a new LinearDecimalKeyFrame. /// public LinearDecimalKeyFrame(Decimal value, KeyTime keyTime) : base(value, keyTime) { } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new LinearDecimalKeyFrame(); } #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 { return AnimatedTypeHelpers.InterpolateDecimal(baseValue, Value, keyFrameProgress); } } #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 the between the Double Value of /// the previous key frame and its own Value linearly to produce its output value. /// public partial class LinearDoubleKeyFrame : DoubleKeyFrame { #region Constructors ////// Creates a new LinearDoubleKeyFrame. /// public LinearDoubleKeyFrame() : base() { } ////// Creates a new LinearDoubleKeyFrame. /// public LinearDoubleKeyFrame(Double value) : base(value) { } ////// Creates a new LinearDoubleKeyFrame. /// public LinearDoubleKeyFrame(Double value, KeyTime keyTime) : base(value, keyTime) { } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new LinearDoubleKeyFrame(); } #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 { return AnimatedTypeHelpers.InterpolateDouble(baseValue, Value, keyFrameProgress); } } #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 the between the Int16 Value of /// the previous key frame and its own Value linearly to produce its output value. /// public partial class LinearInt16KeyFrame : Int16KeyFrame { #region Constructors ////// Creates a new LinearInt16KeyFrame. /// public LinearInt16KeyFrame() : base() { } ////// Creates a new LinearInt16KeyFrame. /// public LinearInt16KeyFrame(Int16 value) : base(value) { } ////// Creates a new LinearInt16KeyFrame. /// public LinearInt16KeyFrame(Int16 value, KeyTime keyTime) : base(value, keyTime) { } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new LinearInt16KeyFrame(); } #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 { return AnimatedTypeHelpers.InterpolateInt16(baseValue, Value, keyFrameProgress); } } #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 the between the Int32 Value of /// the previous key frame and its own Value linearly to produce its output value. /// public partial class LinearInt32KeyFrame : Int32KeyFrame { #region Constructors ////// Creates a new LinearInt32KeyFrame. /// public LinearInt32KeyFrame() : base() { } ////// Creates a new LinearInt32KeyFrame. /// public LinearInt32KeyFrame(Int32 value) : base(value) { } ////// Creates a new LinearInt32KeyFrame. /// public LinearInt32KeyFrame(Int32 value, KeyTime keyTime) : base(value, keyTime) { } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new LinearInt32KeyFrame(); } #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 { return AnimatedTypeHelpers.InterpolateInt32(baseValue, Value, keyFrameProgress); } } #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 the between the Int64 Value of /// the previous key frame and its own Value linearly to produce its output value. /// public partial class LinearInt64KeyFrame : Int64KeyFrame { #region Constructors ////// Creates a new LinearInt64KeyFrame. /// public LinearInt64KeyFrame() : base() { } ////// Creates a new LinearInt64KeyFrame. /// public LinearInt64KeyFrame(Int64 value) : base(value) { } ////// Creates a new LinearInt64KeyFrame. /// public LinearInt64KeyFrame(Int64 value, KeyTime keyTime) : base(value, keyTime) { } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new LinearInt64KeyFrame(); } #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 { return AnimatedTypeHelpers.InterpolateInt64(baseValue, Value, keyFrameProgress); } } #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 the between the Point Value of /// the previous key frame and its own Value linearly to produce its output value. /// public partial class LinearPointKeyFrame : PointKeyFrame { #region Constructors ////// Creates a new LinearPointKeyFrame. /// public LinearPointKeyFrame() : base() { } ////// Creates a new LinearPointKeyFrame. /// public LinearPointKeyFrame(Point value) : base(value) { } ////// Creates a new LinearPointKeyFrame. /// public LinearPointKeyFrame(Point value, KeyTime keyTime) : base(value, keyTime) { } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new LinearPointKeyFrame(); } #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 { return AnimatedTypeHelpers.InterpolatePoint(baseValue, Value, keyFrameProgress); } } #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 the between the Point3D Value of /// the previous key frame and its own Value linearly to produce its output value. /// public partial class LinearPoint3DKeyFrame : Point3DKeyFrame { #region Constructors ////// Creates a new LinearPoint3DKeyFrame. /// public LinearPoint3DKeyFrame() : base() { } ////// Creates a new LinearPoint3DKeyFrame. /// public LinearPoint3DKeyFrame(Point3D value) : base(value) { } ////// Creates a new LinearPoint3DKeyFrame. /// public LinearPoint3DKeyFrame(Point3D value, KeyTime keyTime) : base(value, keyTime) { } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new LinearPoint3DKeyFrame(); } #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 { return AnimatedTypeHelpers.InterpolatePoint3D(baseValue, Value, keyFrameProgress); } } #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 the between the Quaternion Value of /// the previous key frame and its own Value linearly to produce its output value. /// public partial class LinearQuaternionKeyFrame : QuaternionKeyFrame { #region Constructors ////// Creates a new LinearQuaternionKeyFrame. /// public LinearQuaternionKeyFrame() : base() { } ////// Creates a new LinearQuaternionKeyFrame. /// public LinearQuaternionKeyFrame(Quaternion value) : base(value) { } ////// Creates a new LinearQuaternionKeyFrame. /// public LinearQuaternionKeyFrame(Quaternion value, KeyTime keyTime) : base(value, keyTime) { } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new LinearQuaternionKeyFrame(); } #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 { return AnimatedTypeHelpers.InterpolateQuaternion(baseValue, Value, keyFrameProgress, UseShortestPath); } } #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 the between the Rotation3D Value of /// the previous key frame and its own Value linearly to produce its output value. /// public partial class LinearRotation3DKeyFrame : Rotation3DKeyFrame { #region Constructors ////// Creates a new LinearRotation3DKeyFrame. /// public LinearRotation3DKeyFrame() : base() { } ////// Creates a new LinearRotation3DKeyFrame. /// public LinearRotation3DKeyFrame(Rotation3D value) : base(value) { } ////// Creates a new LinearRotation3DKeyFrame. /// public LinearRotation3DKeyFrame(Rotation3D value, KeyTime keyTime) : base(value, keyTime) { } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new LinearRotation3DKeyFrame(); } #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 { return AnimatedTypeHelpers.InterpolateRotation3D(baseValue, Value, keyFrameProgress); } } #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 the between the Rect Value of /// the previous key frame and its own Value linearly to produce its output value. /// public partial class LinearRectKeyFrame : RectKeyFrame { #region Constructors ////// Creates a new LinearRectKeyFrame. /// public LinearRectKeyFrame() : base() { } ////// Creates a new LinearRectKeyFrame. /// public LinearRectKeyFrame(Rect value) : base(value) { } ////// Creates a new LinearRectKeyFrame. /// public LinearRectKeyFrame(Rect value, KeyTime keyTime) : base(value, keyTime) { } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new LinearRectKeyFrame(); } #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 { return AnimatedTypeHelpers.InterpolateRect(baseValue, Value, keyFrameProgress); } } #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 the between the Single Value of /// the previous key frame and its own Value linearly to produce its output value. /// public partial class LinearSingleKeyFrame : SingleKeyFrame { #region Constructors ////// Creates a new LinearSingleKeyFrame. /// public LinearSingleKeyFrame() : base() { } ////// Creates a new LinearSingleKeyFrame. /// public LinearSingleKeyFrame(Single value) : base(value) { } ////// Creates a new LinearSingleKeyFrame. /// public LinearSingleKeyFrame(Single value, KeyTime keyTime) : base(value, keyTime) { } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new LinearSingleKeyFrame(); } #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 { return AnimatedTypeHelpers.InterpolateSingle(baseValue, Value, keyFrameProgress); } } #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 the between the Size Value of /// the previous key frame and its own Value linearly to produce its output value. /// public partial class LinearSizeKeyFrame : SizeKeyFrame { #region Constructors ////// Creates a new LinearSizeKeyFrame. /// public LinearSizeKeyFrame() : base() { } ////// Creates a new LinearSizeKeyFrame. /// public LinearSizeKeyFrame(Size value) : base(value) { } ////// Creates a new LinearSizeKeyFrame. /// public LinearSizeKeyFrame(Size value, KeyTime keyTime) : base(value, keyTime) { } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new LinearSizeKeyFrame(); } #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 { return AnimatedTypeHelpers.InterpolateSize(baseValue, Value, keyFrameProgress); } } #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 the between the Vector Value of /// the previous key frame and its own Value linearly to produce its output value. /// public partial class LinearVectorKeyFrame : VectorKeyFrame { #region Constructors ////// Creates a new LinearVectorKeyFrame. /// public LinearVectorKeyFrame() : base() { } ////// Creates a new LinearVectorKeyFrame. /// public LinearVectorKeyFrame(Vector value) : base(value) { } ////// Creates a new LinearVectorKeyFrame. /// public LinearVectorKeyFrame(Vector value, KeyTime keyTime) : base(value, keyTime) { } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new LinearVectorKeyFrame(); } #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 { return AnimatedTypeHelpers.InterpolateVector(baseValue, Value, keyFrameProgress); } } #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 the between the Vector3D Value of /// the previous key frame and its own Value linearly to produce its output value. /// public partial class LinearVector3DKeyFrame : Vector3DKeyFrame { #region Constructors ////// Creates a new LinearVector3DKeyFrame. /// public LinearVector3DKeyFrame() : base() { } ////// Creates a new LinearVector3DKeyFrame. /// public LinearVector3DKeyFrame(Vector3D value) : base(value) { } ////// Creates a new LinearVector3DKeyFrame. /// public LinearVector3DKeyFrame(Vector3D value, KeyTime keyTime) : base(value, keyTime) { } #endregion #region Freezable ////// Implementation of ///Freezable.CreateInstanceCore . ///The new Freezable. protected override Freezable CreateInstanceCore() { return new LinearVector3DKeyFrame(); } #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 { return AnimatedTypeHelpers.InterpolateVector3D(baseValue, Value, keyFrameProgress); } } #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
- TextChangedEventArgs.cs
- ModelTreeManager.cs
- MobileControlDesigner.cs
- ListenerPerfCounters.cs
- VsPropertyGrid.cs
- DataServiceRequest.cs
- ContentType.cs
- DesignerTransaction.cs
- TextInfo.cs
- XDeferredAxisSource.cs
- SecureStringHasher.cs
- XmlChildEnumerator.cs
- ZipIOLocalFileDataDescriptor.cs
- RoutingExtension.cs
- SecuritySessionServerSettings.cs
- DataGridViewIntLinkedList.cs
- TableLayoutStyleCollection.cs
- XmlWrappingReader.cs
- AxisAngleRotation3D.cs
- FillBehavior.cs
- Point3DCollection.cs
- XmlSchemaAnnotated.cs
- RuntimeWrappedException.cs
- Expressions.cs
- ParsedAttributeCollection.cs
- Attributes.cs
- Part.cs
- SymmetricAlgorithm.cs
- FormDesigner.cs
- ADMembershipUser.cs
- InternalPermissions.cs
- OrderedEnumerableRowCollection.cs
- WebServiceTypeData.cs
- ClientFormsAuthenticationMembershipProvider.cs
- ConstraintConverter.cs
- InstanceData.cs
- Choices.cs
- QilSortKey.cs
- MemberDomainMap.cs
- HelpInfo.cs
- FrameworkPropertyMetadata.cs
- Completion.cs
- SwitchExpression.cs
- WebHttpBindingElement.cs
- Repeater.cs
- AsyncOperation.cs
- HttpFileCollectionWrapper.cs
- SiteMapSection.cs
- StorageEntityTypeMapping.cs
- BamlRecordHelper.cs
- Accessors.cs
- SynchronizedInputProviderWrapper.cs
- ToolStripGrip.cs
- XmlSchemaObjectCollection.cs
- TextRunProperties.cs
- GeneralTransform.cs
- RegisteredArrayDeclaration.cs
- DictionaryManager.cs
- SymmetricKeyWrap.cs
- SecurityListenerSettingsLifetimeManager.cs
- Nullable.cs
- TopClause.cs
- FontStyles.cs
- ToolStripContentPanelRenderEventArgs.cs
- QuotedStringFormatReader.cs
- PageSettings.cs
- XmlReflectionMember.cs
- HttpBindingExtension.cs
- XmlSerializerSection.cs
- Transform3DCollection.cs
- TextSelectionHighlightLayer.cs
- PostBackOptions.cs
- WebPartDescription.cs
- SafeFileMappingHandle.cs
- TemplateControlCodeDomTreeGenerator.cs
- CqlIdentifiers.cs
- KeyNotFoundException.cs
- ListBoxItem.cs
- Task.cs
- OrderedHashRepartitionEnumerator.cs
- ToolboxItem.cs
- DocComment.cs
- ColorDialog.cs
- DisplayMemberTemplateSelector.cs
- SafeFindHandle.cs
- TrackingQuery.cs
- ThicknessAnimation.cs
- RegexRunner.cs
- InvalidWMPVersionException.cs
- SelectionManager.cs
- RectAnimation.cs
- BitmapEffectGeneralTransform.cs
- EntityDataSourceDataSelection.cs
- MeshGeometry3D.cs
- InkCanvasFeedbackAdorner.cs
- DiscoveryMessageProperty.cs
- SpecialNameAttribute.cs
- CodeEventReferenceExpression.cs
- DbParameterHelper.cs
- CustomLineCap.cs