/// <summary> /// Creates a new EasingThicknessKeyFrame. /// </summary> public EasingThicknessKeyFrame(Thickness value, KeyTime keyTime, IEasingFunction easingFunction) : this() { Value = value; KeyTime = keyTime; EasingFunction = easingFunction; }
/// <summary> /// Creates a new EasingByteKeyFrame. /// </summary> public EasingByteKeyFrame(Byte value, KeyTime keyTime, IEasingFunction easingFunction) : this() { Value = value; KeyTime = keyTime; EasingFunction = easingFunction; }
/// <summary> /// Creates a new SplineByteKeyFrame. /// </summary> public SplineByteKeyFrame(Byte value, KeyTime keyTime, KeySpline keySpline) : this() { if (keySpline == null) { throw new ArgumentNullException("keySpline"); } Value = value; KeyTime = keyTime; KeySpline = keySpline; }
public SplineByteKeyFrame(byte value, KeyTime keyTime, KeySpline keySpline) { this.value = value; this.keyTime = keyTime; KeySpline = keySpline; }
/// <summary> /// Creates a new DiscretePoint3DKeyFrame. /// </summary> public DiscretePoint3DKeyFrame(Point3D value, KeyTime keyTime) : base(value, keyTime) { }
public DiscreteColorKeyFrame (Color value, KeyTime keyTime) { this.value = value; this.keyTime = keyTime; }
public DiscreteCharKeyFrame(char value, KeyTime keyTime) { this.value = value; this.keyTime = keyTime; }
public SplinePointKeyFrame(System.Windows.Point value, KeyTime keyTime, KeySpline keySpline) { }
public SplineRectKeyFrame(System.Windows.Rect value, KeyTime keyTime, KeySpline keySpline) { }
/// <summary>Initializes a new instance of the <see cref="T:System.Windows.Media.Animation.ThicknessKeyFrame" /> class that has the specified target <see cref="P:System.Windows.Media.Animation.ThicknessKeyFrame.Value" /> and <see cref="P:System.Windows.Media.Animation.ThicknessKeyFrame.KeyTime" />. </summary> /// <param name="value">The <see cref="P:System.Windows.Media.Animation.ThicknessKeyFrame.Value" /> of the new <see cref="T:System.Windows.Media.Animation.ThicknessKeyFrame" /> instance.</param> /// <param name="keyTime">The <see cref="P:System.Windows.Media.Animation.ThicknessKeyFrame.KeyTime" /> of the new <see cref="T:System.Windows.Media.Animation.ThicknessKeyFrame" /> instance.</param> // Token: 0x06001719 RID: 5913 RVA: 0x00071BF0 File Offset: 0x0006FDF0 protected ThicknessKeyFrame(Thickness value, KeyTime keyTime) : this() { this.Value = value; this.KeyTime = keyTime; }
protected BooleanKeyFrame (bool value, KeyTime keyTime) { }
public DiscreteThicknessKeyFrame(System.Windows.Thickness value, KeyTime keyTime) { }
/// <summary>Initializes a new instance of the <see cref="T:System.Windows.Media.Animation.LinearThicknessKeyFrame" /> class with the specified ending value and key time.</summary> /// <param name="value">Ending value (also known as "target value") for the key frame.</param> /// <param name="keyTime">Key time for the key frame. The key time determines when the target value is reached which is also when the key frame ends.</param> // Token: 0x06001725 RID: 5925 RVA: 0x00071BBA File Offset: 0x0006FDBA public LinearThicknessKeyFrame(Thickness value, KeyTime keyTime) : base(value, keyTime) { }
protected DoubleKeyFrame(double value, KeyTime keyTime) { }
public EasingInt16KeyFrame(short value, KeyTime keyTime, IEasingFunction easingFunction) { }
public EasingInt16KeyFrame(short value, KeyTime keyTime) { }
protected DoubleKeyFrame(double value, KeyTime keyTime) { }
protected ThicknessKeyFrame(System.Windows.Thickness value, KeyTime keyTime) { }
public DiscreteObjectKeyFrame(Object value, KeyTime keyTime) { }
public LinearInt64KeyFrame(long value, KeyTime keyTime) { }
public bool Equals(KeyTime value) { return this == value; }
protected Int64KeyFrame(long value, KeyTime keyTime) { }
/// <summary> /// Creates a new DiscreteThicknessKeyFrame. /// </summary> public DiscreteThicknessKeyFrame(Thickness value, KeyTime keyTime) : base(value, keyTime) { }
public DiscreteInt64KeyFrame(long value, KeyTime keyTime) { }
public LinearByteKeyFrame(byte value, KeyTime keyTime) { }
public LinearColorKeyFrame(Color value, KeyTime keyTime) { this.value = value; this.keyTime = keyTime; }
public DiscretePoint3DKeyFrame(System.Windows.Media.Media3D.Point3D value, KeyTime keyTime) { }
// Token: 0x06001775 RID: 6005 RVA: 0x00072B80 File Offset: 0x00070D80 private void ResolveKeyTimes() { int num = 0; if (this._keyFrames != null) { num = this._keyFrames.Count; } if (num == 0) { this._sortedResolvedKeyFrames = null; this._areKeyTimesValid = true; return; } this._sortedResolvedKeyFrames = new ResolvedKeyFrameEntry[num]; int i; for (i = 0; i < num; i++) { this._sortedResolvedKeyFrames[i]._originalKeyFrameIndex = i; } TimeSpan resolvedKeyTime = TimeSpan.Zero; Duration duration = base.Duration; if (duration.HasTimeSpan) { resolvedKeyTime = duration.TimeSpan; } else { resolvedKeyTime = this.LargestTimeSpanKeyTime; } int num2 = num - 1; ArrayList arrayList = new ArrayList(); bool flag = false; i = 0; while (i < num) { KeyTime keyTime = this._keyFrames[i].KeyTime; switch (keyTime.Type) { case KeyTimeType.Uniform: case KeyTimeType.Paced: if (i == num2) { this._sortedResolvedKeyFrames[i]._resolvedKeyTime = resolvedKeyTime; i++; } else if (i == 0 && keyTime.Type == KeyTimeType.Paced) { this._sortedResolvedKeyFrames[i]._resolvedKeyTime = TimeSpan.Zero; i++; } else { if (keyTime.Type == KeyTimeType.Paced) { flag = true; } ThicknessAnimationUsingKeyFrames.KeyTimeBlock keyTimeBlock = default(ThicknessAnimationUsingKeyFrames.KeyTimeBlock); keyTimeBlock.BeginIndex = i; while (++i < num2) { KeyTimeType type = this._keyFrames[i].KeyTime.Type; if (type == KeyTimeType.Percent || type == KeyTimeType.TimeSpan) { break; } if (type == KeyTimeType.Paced) { flag = true; } } keyTimeBlock.EndIndex = i; arrayList.Add(keyTimeBlock); } break; case KeyTimeType.Percent: this._sortedResolvedKeyFrames[i]._resolvedKeyTime = TimeSpan.FromMilliseconds(keyTime.Percent * resolvedKeyTime.TotalMilliseconds); i++; break; case KeyTimeType.TimeSpan: this._sortedResolvedKeyFrames[i]._resolvedKeyTime = keyTime.TimeSpan; i++; break; } } for (int j = 0; j < arrayList.Count; j++) { ThicknessAnimationUsingKeyFrames.KeyTimeBlock keyTimeBlock2 = (ThicknessAnimationUsingKeyFrames.KeyTimeBlock)arrayList[j]; TimeSpan timeSpan = TimeSpan.Zero; if (keyTimeBlock2.BeginIndex > 0) { timeSpan = this._sortedResolvedKeyFrames[keyTimeBlock2.BeginIndex - 1]._resolvedKeyTime; } long num3 = (long)(keyTimeBlock2.EndIndex - keyTimeBlock2.BeginIndex + 1); TimeSpan t = TimeSpan.FromTicks((this._sortedResolvedKeyFrames[keyTimeBlock2.EndIndex]._resolvedKeyTime - timeSpan).Ticks / num3); i = keyTimeBlock2.BeginIndex; TimeSpan timeSpan2 = timeSpan + t; while (i < keyTimeBlock2.EndIndex) { this._sortedResolvedKeyFrames[i]._resolvedKeyTime = timeSpan2; timeSpan2 += t; i++; } } if (flag) { this.ResolvePacedKeyTimes(); } Array.Sort <ResolvedKeyFrameEntry>(this._sortedResolvedKeyFrames); this._areKeyTimesValid = true; }
protected Rotation3DKeyFrame(System.Windows.Media.Media3D.Rotation3D value, KeyTime keyTime) { }
public DiscretePointKeyFrame(System.Windows.Point value, KeyTime keyTime) { }
protected BooleanKeyFrame(bool value, KeyTime keyTime) { }
public EasingDecimalKeyFrame(Decimal value, KeyTime keyTime, IEasingFunction easingFunction) { }
/// <summary> /// Creates a new DiscreteMatrixKeyFrame. /// </summary> public DiscreteMatrixKeyFrame(Matrix value, KeyTime keyTime) : base(value, keyTime) { }
public EasingDecimalKeyFrame(Decimal value, KeyTime keyTime) { }
public SplineVectorKeyFrame(System.Windows.Vector value, KeyTime keyTime, KeySpline keySpline) { }
protected CharKeyFrame(char value, KeyTime keyTime) { }
protected SingleKeyFrame(float value, KeyTime keyTime) { }
public DiscreteRectKeyFrame(System.Windows.Rect value, KeyTime keyTime) { }
public SplineColorKeyFrame(System.Windows.Media.Color value, KeyTime keyTime, KeySpline keySpline) { }
public SplineSingleKeyFrame(float value, KeyTime keyTime, KeySpline keySpline) { }
public static bool Equals (KeyTime keyTime1, KeyTime keyTime2) { return keyTime1 == keyTime2; }
public LinearSizeKeyFrame(System.Windows.Size value, KeyTime keyTime) { }
public LinearVectorKeyFrame(System.Windows.Vector value, KeyTime keyTime) { }
protected ColorKeyFrame(System.Windows.Media.Color value, KeyTime keyTime) { }
public DiscreteVectorKeyFrame(System.Windows.Vector value, KeyTime keyTime) { }
public EasingRotation3DKeyFrame(System.Windows.Media.Media3D.Rotation3D value, KeyTime keyTime, IEasingFunction easingFunction) { }
protected PointKeyFrame (Point value, KeyTime keyTime) { }
private void ResolveKeyTimes() { Debug.Assert(!_areKeyTimesValid, "KeyFrameCharAnimaton.ResolveKeyTimes() shouldn't be called if the key times are already valid."); int keyFrameCount = 0; if (_keyFrames != null) { keyFrameCount = _keyFrames.Count; } if (keyFrameCount == 0) { _sortedResolvedKeyFrames = null; _areKeyTimesValid = true; return; } _sortedResolvedKeyFrames = new ResolvedKeyFrameEntry[keyFrameCount]; int index = 0; // Initialize the _originalKeyFrameIndex. for ( ; index < keyFrameCount; index++) { _sortedResolvedKeyFrames[index]._originalKeyFrameIndex = index; } // calculationDuration represents the time span we will use to resolve // percent key times. This is defined as the value in the following // precedence order: // 1. The animation's duration, but only if it is a time span, not auto or forever. // 2. The largest time span specified key time of all the key frames. // 3. 1 second, to match the From/To/By animations. TimeSpan calculationDuration = TimeSpan.Zero; Duration duration = Duration; if (duration.HasTimeSpan) { calculationDuration = duration.TimeSpan; } else { calculationDuration = LargestTimeSpanKeyTime; } int maxKeyFrameIndex = keyFrameCount - 1; ArrayList unspecifiedBlocks = new ArrayList(); bool hasPacedKeyTimes = false; // // Pass 1: Resolve Percent and Time key times. // index = 0; while (index < keyFrameCount) { KeyTime keyTime = _keyFrames[index].KeyTime; switch (keyTime.Type) { case KeyTimeType.Percent: _sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.FromMilliseconds( keyTime.Percent * calculationDuration.TotalMilliseconds); index++; break; case KeyTimeType.TimeSpan: _sortedResolvedKeyFrames[index]._resolvedKeyTime = keyTime.TimeSpan; index++; break; case KeyTimeType.Paced: case KeyTimeType.Uniform: if (index == maxKeyFrameIndex) { // If the last key frame doesn't have a specific time // associated with it its resolved key time will be // set to the calculationDuration, which is the // defined in the comments above where it is set. // Reason: We only want extra time at the end of the // key frames if the user specifically states that // the last key frame ends before the animation ends. _sortedResolvedKeyFrames[index]._resolvedKeyTime = calculationDuration; index++; } else if (index == 0 && keyTime.Type == KeyTimeType.Paced) { // Note: It's important that this block come after // the previous if block because of rule precendence. // If the first key frame in a multi-frame key frame // collection is paced, we set its resolved key time // to 0.0 for performance reasons. If we didn't, the // resolved key time list would be dependent on the // base value which can change every animation frame // in many cases. _sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.Zero; index++; } else { if (keyTime.Type == KeyTimeType.Paced) { hasPacedKeyTimes = true; } KeyTimeBlock block = new KeyTimeBlock(); block.BeginIndex = index; // NOTE: We don't want to go all the way up to the // last frame because if it is Uniform or Paced its // resolved key time will be set to the calculation // duration using the logic above. // // This is why the logic is: // ((++index) < maxKeyFrameIndex) // instead of: // ((++index) < keyFrameCount) while ((++index) < maxKeyFrameIndex) { KeyTimeType type = _keyFrames[index].KeyTime.Type; if (type == KeyTimeType.Percent || type == KeyTimeType.TimeSpan) { break; } else if (type == KeyTimeType.Paced) { hasPacedKeyTimes = true; } } Debug.Assert(index < keyFrameCount, "The end index for a block of unspecified key frames is out of bounds."); block.EndIndex = index; unspecifiedBlocks.Add(block); } break; } } // // Pass 2: Resolve Uniform key times. // for (int j = 0; j < unspecifiedBlocks.Count; j++) { KeyTimeBlock block = (KeyTimeBlock)unspecifiedBlocks[j]; TimeSpan blockBeginTime = TimeSpan.Zero; if (block.BeginIndex > 0) { blockBeginTime = _sortedResolvedKeyFrames[block.BeginIndex - 1]._resolvedKeyTime; } // The number of segments is equal to the number of key // frames we're working on plus 1. Think about the case // where we're working on a single key frame. There's a // segment before it and a segment after it. // // Time known Uniform Time known // ^ ^ ^ // | | | // | (segment 1) | (segment 2) | Int64 segmentCount = (block.EndIndex - block.BeginIndex) + 1; TimeSpan uniformTimeStep = TimeSpan.FromTicks((_sortedResolvedKeyFrames[block.EndIndex]._resolvedKeyTime - blockBeginTime).Ticks / segmentCount); index = block.BeginIndex; TimeSpan resolvedTime = blockBeginTime + uniformTimeStep; while (index < block.EndIndex) { _sortedResolvedKeyFrames[index]._resolvedKeyTime = resolvedTime; resolvedTime += uniformTimeStep; index++; } } // // Pass 3: Resolve Paced key times. // if (hasPacedKeyTimes) { ResolvePacedKeyTimes(); } // // Sort resolved key frame entries. // Array.Sort(_sortedResolvedKeyFrames); _areKeyTimesValid = true; return; }
public LinearInt16KeyFrame (short value, KeyTime keyTime) { this.value = value; this.keyTime = keyTime; }
public LinearVectorKeyFrame(Vector value, KeyTime keyTime) { this.value = value; this.keyTime = keyTime; }
protected Int64KeyFrame (long value, KeyTime keyTime) { }
/// <summary> /// Creates a new SplineThicknessKeyFrame. /// </summary> public SplineThicknessKeyFrame(Thickness value, KeyTime keyTime) : this() { Value = value; KeyTime = keyTime; }
public SplineRectKeyFrame (Rect value, KeyTime keyTime, KeySpline keySpline) { this.value = value; this.keyTime = keyTime; KeySpline = keySpline; }
public SplineDoubleKeyFrame(double value, KeyTime keyTime, KeySpline keySpline) { }
public SplineInt64KeyFrame(long value, KeyTime keyTime, KeySpline keySpline) { }
public DiscreteBooleanKeyFrame(bool value, KeyTime keyTime) { this.value = value; this.keyTime = keyTime; }
public DiscreteStringKeyFrame (String value, KeyTime keyTime) { this.value = value; this.keyTime = keyTime; }
public DiscreteInt32KeyFrame(int value, KeyTime keyTime) { this.value = value; this.keyTime = keyTime; }
protected Int16KeyFrame(short value, KeyTime keyTime) { }
public SplineInt16KeyFrame(short value, KeyTime keyTime, KeySpline keySpline) { }