Code:
/ Dotnetfx_Vista_SP2 / Dotnetfx_Vista_SP2 / 8.0.50727.4016 / DEVDIV / depot / DevDiv / releases / Orcas / QFE / wpf / src / Core / CSharp / System / Windows / Media / Animation / Clock.cs / 1 / Clock.cs
//------------------------------------------------------------------------------
// Microsoft Windows Client Platform
// Copyright (c) Microsoft Corporation, 2003
//
// File: Clock.cs
//-----------------------------------------------------------------------------
#if DEBUG
#define TRACE
#endif // DEBUG
using MS.Internal;
using MS.Utility;
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Windows;
using System.Windows.Media.Composition;
using System.Windows.Markup;
using System.Windows.Threading;
using SR=MS.Internal.PresentationCore.SR;
using SRID=MS.Internal.PresentationCore.SRID;
namespace System.Windows.Media.Animation
{
///
/// Maintains run-time timing state for timed objects.
///
///
/// A Clock object maintains the run-time state for a timed object
/// according to the description specified in a Timeline object. It also
/// provides methods for timing control, such as event scheduling and
/// VCR-like functionality. Clock objects are arranged in trees
/// that match the structure of the Timeline objects they are created from.
///
public class Clock : DispatcherObject
{
//
// Constructors
//
#region Constructors
///
/// Creates a Clock object.
///
///
/// The Timeline to use as a template.
///
///
/// The returned Clock doesn't have any children.
///
protected internal Clock(Timeline timeline)
{
#if DEBUG
lock (_debugLockObject)
{
_debugIdentity = ++_nextIdentity;
WeakReference weakRef = new WeakReference(this);
_objectTable[_debugIdentity] = weakRef;
}
#endif // DEBUG
Debug.Assert(timeline != null);
//
// Store a frozen copy of the timeline
//
_timeline = (Timeline)timeline.GetCurrentValueAsFrozen();
// GetCurrentValueAsFrozen will make a clone of the Timeline if it's
// not frozen and will return the Timeline if it is frozen.
// The clone will never have event handlers, while the
// frozen original may. This means we need to copy
// the event handlers from the original timeline onto the clock
// to be consistent.
//
// Copy the event handlers from the original timeline into the clock
//
_eventHandlersStore = timeline.InternalEventHandlersStore;
//
// FXCop fix. Do not call overridables in constructors
// UpdateNeedsTicksWhenActive();
// Set the NeedsTicksWhenActive only if we have someone listening
// to an event.
SetFlag(ClockFlags.NeedsTicksWhenActive, _eventHandlersStore != null);
//
// Cache values that won't change as the clock ticks
//
// Non-root clocks have an unchanging begin time specified by their timelines.
// A root clock will update _beginTime as necessary.
_beginTime = _timeline.BeginTime;
// Cache duration, getting Timeline.Duration and recalculating duration
// each Tick was eating perf, resolve the duration if possible.
_resolvedDuration = _timeline.Duration;
if (_resolvedDuration == Duration.Automatic)
{
// Forever is the default for an automatic duration. We can't
// try to resolve the duration yet because the tree
// may not be fully built, in which case ClockGroups won't
// have their children yet.
_resolvedDuration = Duration.Forever;
}
else
{
HasResolvedDuration = true;
}
_currentDuration = _resolvedDuration;
// Cache speed ratio, for roots this value may be updated if the interactive
// speed ratio changes, but for non-roots this value will remain constant
// throughout the lifetime of the clock.
_appliedSpeedRatio = _timeline.SpeedRatio;
//
// Initialize current state
//
_currentClockState = ClockState.Stopped;
if (_beginTime.HasValue)
{
// We need a tick to bring our state up to date
_nextTickNeededTime = TimeSpan.Zero;
}
// All other data members initialized to zero by default
}
#endregion // Constructors
//
// Public Properties
//
#region Public Properties
internal bool CanGrow
{
get
{
return GetFlag(ClockFlags.CanGrow);
}
}
internal bool CanSlip
{
get
{
return GetFlag(ClockFlags.CanSlip);
}
}
///
/// Returns an ClockController which can be used to perform interactive
/// operations on this Clock. If interactive operations are not allowed,
/// this property returns null; this is the case for Clocks that
/// aren't children of the root Clock.
///
public ClockController Controller
{
get
{
Debug.Assert(!IsTimeManager);
// Unless our parent is the root clock and we're controllable,
// return null
if (IsRoot && HasControllableRoot)
{
return new ClockController(this);
}
else
{
return null;
}
}
}
///
/// The current repeat iteration. The first period has a value of one.
///
///
/// If the clock is not active, the value of this property is only valid if
/// the fill attribute specifies that the timing attributes should be
/// extended. Otherwise, the property returns -1.
///
public Int32? CurrentIteration
{
get
{
// VerifyAccess();
Debug.Assert(!IsTimeManager);
return _currentIteration;
}
}
///
/// Gets the current rate at which time is progressing in the clock,
/// compared to the real-world wall clock. If the clock is stopped,
/// this method returns null.
///
///
/// The current progress of time for this clock.
///
///
/// If the clock is active, the progress is always a value between 0 and 1,
/// inclusive. Otherwise, the progress depends on the value of the
///
public double? CurrentProgress
{
get
{
// VerifyAccess();
Debug.Assert(!IsTimeManager);
return _currentProgress;
}
}
///
/// Gets a value indicating whether the Clock’s current time is inside the Active period
/// (meaning properties may change frame to frame), inside the Fill period, or Stopped.
///
///
/// You can tell whether you’re in FillBegin or FillEnd by the value of CurrentProgress
/// (0 for FillBegin, 1 for FillEnd).
///
public ClockState CurrentState
{
get
{
// VerifyAccess();
return _currentClockState;
}
}
///
/// The current position of the clock, relative to the starting time. Setting
/// this property to a new value has the effect of seeking the clock to a
/// new point in time. Both forward and backward seeks are allowed. Setting this
/// property has no effect if the clock is not active. However, seeking while the
/// clock is paused works as expected.
///
public TimeSpan? CurrentTime
{
get
{
// VerifyAccess();
Debug.Assert(!IsTimeManager);
return _currentTime;
}
}
///
///
///
public bool HasControllableRoot
{
get
{
Debug.Assert(!IsTimeManager);
return GetFlag(ClockFlags.HasControllableRoot);
}
}
///
/// True if the timeline is currently paused, false otherwise.
///
///
/// This property returns true either if this timeline has been paused, or if an
/// ancestor of this timeline has been paused.
///
public bool IsPaused
{
get
{
// VerifyAccess();
Debug.Assert(!IsTimeManager);
return IsInteractivelyPaused;
}
}
///
/// Returns the natural duration of this Clock, which is defined
/// by the Timeline from which it is created.
///
///
/// The Clock that sets the parent time for this Clock.
///
public Clock Parent
{
get
{
// VerifyAccess();
Debug.Assert(!IsTimeManager);
// If our parent is the root clock, force a return value of null
if (IsRoot)
{
return null;
}
else
{
return _parent;
}
}
}
///
/// Gets the Timeline object that holds the description controlling the
/// behavior of this clock.
///
///
/// The Timeline object that holds the description controlling the
/// behavior of this clock.
///
public Timeline Timeline
{
get
{
// VerifyAccess();
Debug.Assert(!IsTimeManager);
return _timeline;
}
}
#endregion // Public Properties
//
// Public Events
//
#region Public Events
///
/// Raised by the timeline when it has completed.
///
public event EventHandler Completed
{
add
{
AddEventHandler(Timeline.CompletedKey, value);
}
remove
{
RemoveEventHandler(Timeline.CompletedKey, value);
}
}
///
/// Raised by the Clock whenever its current speed changes.
/// This event mirrors the CurrentGlobalSpeedInvalidated event on Timeline
///
public event EventHandler CurrentGlobalSpeedInvalidated
{
add
{
// VerifyAccess();
AddEventHandler(Timeline.CurrentGlobalSpeedInvalidatedKey, value);
}
remove
{
// VerifyAccess();
RemoveEventHandler(Timeline.CurrentGlobalSpeedInvalidatedKey, value);
}
}
///
/// Raised by the Clock whenever its current state changes.
/// This event mirrors the CurrentStateInvalidated event on Timeline
///
public event EventHandler CurrentStateInvalidated
{
add
{
// VerifyAccess();
AddEventHandler(Timeline.CurrentStateInvalidatedKey, value);
}
remove
{
// VerifyAccess();
RemoveEventHandler(Timeline.CurrentStateInvalidatedKey, value);
}
}
///
/// Raised by the Clock whenever its current time changes.
/// This event mirrors the CurrentTimeInvalidated event on Timeline
///
public event EventHandler CurrentTimeInvalidated
{
add
{
// VerifyAccess();
AddEventHandler(Timeline.CurrentTimeInvalidatedKey, value);
}
remove
{
// VerifyAccess();
RemoveEventHandler(Timeline.CurrentTimeInvalidatedKey, value);
}
}
///
/// Raised by the timeline when its removal has been requested by the user.
///
public event EventHandler RemoveRequested
{
add
{
AddEventHandler(Timeline.RemoveRequestedKey, value);
}
remove
{
RemoveEventHandler(Timeline.RemoveRequestedKey, value);
}
}
#endregion // Public Events
//
// Protected Methods
//
#region Protected Methods
///
/// Notify a clock that we've moved in a discontinuous way
///
protected virtual void DiscontinuousTimeMovement()
{
// Base class does nothing
}
///
/// Returns true if the Clock has its own external source for time, which may
/// require synchronization with the timing system. Media is one example of this.
///
protected virtual bool GetCanSlip()
{
return false;
}
///
///
///
protected virtual TimeSpan GetCurrentTimeCore()
{
Debug.Assert(!IsTimeManager);
return _currentTime.HasValue ? _currentTime.Value : TimeSpan.Zero;
}
///
/// Notify a clock that we've changed the speed
///
protected virtual void SpeedChanged()
{
// Base class does nothing
}
///
/// Notify a clock that we've stopped
///
protected virtual void Stopped()
{
// Base class does nothing
}
#endregion // Protected Methods
//
// Protected Properties
//
#region Protected Properties
///
/// The current global time in TimeSpan units, established by the time manager.
///
protected TimeSpan CurrentGlobalTime
{
get
{
if (_timeManager == null)
{
return TimeSpan.Zero;
}
else if (IsTimeManager)
{
return _timeManager.InternalCurrentGlobalTime;
}
else
{
Clock current = this;
while (!current.IsRoot) // Traverse up the tree to the root node
{
current = current._parent;
}
if (current.HasDesiredFrameRate)
{
return current._rootData.CurrentAdjustedGlobalTime;
}
else
{
return _timeManager.InternalCurrentGlobalTime;
}
}
}
}
#endregion // Protected Properties
//
// Internal Methods
//
#region Internal Methods
internal virtual void AddNullPointToCurrentIntervals()
{
}
internal static Clock AllocateClock(
Timeline timeline,
bool hasControllableRoot)
{
Clock clock = timeline.AllocateClock();
// Assert that we weren't given an existing clock
Debug.Assert(!clock.IsTimeManager);
ClockGroup clockGroup = clock as ClockGroup;
if ( clock._parent != null
|| ( clockGroup != null
&& clockGroup.InternalChildren != null ))
{
// The derived class is trying to fool us -- we require a new,
// fresh, unassociated clock here
throw new InvalidOperationException(
SR.Get(
SRID.Timing_CreateClockMustReturnNewClock,
timeline.GetType().Name));
}
clock.SetFlag(ClockFlags.HasControllableRoot, hasControllableRoot);
return clock;
}
internal virtual void BuildClockSubTreeFromTimeline(
Timeline timeline,
bool hasControllableRoot)
{
SetFlag(ClockFlags.CanSlip, GetCanSlip()); // Set the CanSlip flag
// Here we preview the clock's own slip-ability, hence ClockGroups should return false
// at this stage, because their children are not yet added by the time of this call.
if (CanSlip && (IsRoot || _timeline.BeginTime.HasValue))
{
ResolveDuration();
// A [....] clock with duration of zero or no begin time has no effect, so do skip it
if (!_resolvedDuration.HasTimeSpan || _resolvedDuration.TimeSpan > TimeSpan.Zero)
{
// Verify that we only use SlipBehavior in supported scenarios
if ((_timeline.AutoReverse == true) ||
(_timeline.AccelerationRatio > 0) ||
(_timeline.DecelerationRatio > 0))
{
throw new NotSupportedException(SR.Get(SRID.Timing_CanSlipOnlyOnSimpleTimelines));
}
_syncData = new SyncData(this); // CanSlip clocks keep themselves synced
HasDescendantsWithUnresolvedDuration = !HasResolvedDuration; // Keep track of when our duration is resolved
Clock current = _parent; // Traverse up the parent chain and verify that no unsupported behavior is specified
while (current != null)
{
Debug.Assert(!current.IsTimeManager); // We should not yet be connected to the TimeManager
if (current._timeline.AutoReverse || current._timeline.AccelerationRatio > 0
|| current._timeline.DecelerationRatio > 0)
{
throw new System.InvalidOperationException(SR.Get(SRID.Timing_SlipBehavior_SyncOnlyWithSimpleParents));
}
current.SetFlag(ClockFlags.CanGrow, true); // Propagate the slippage tracking up the tree
if (!HasResolvedDuration) // Let the parents know that we have not yet unresolved duration
{
current.HasDescendantsWithUnresolvedDuration = true;
}
current._currentIterationBeginTime = current._beginTime;
current = current._parent;
}
}
}
}
internal static Clock BuildClockTreeFromTimeline(
Timeline rootTimeline,
bool hasControllableRoot)
{
Clock rootClock = AllocateClock(rootTimeline, hasControllableRoot);
// Set this flag so that the subsequent method can rely on it.
rootClock.IsRoot = true;
rootClock._rootData = new RootData(); // Create a RootData to hold root specific information.
// The root clock was given a reference to a frozen copy of the
// timing tree. We pass this copy down BuildClockSubTreeFromTimeline
// so that each child clock will use that tree rather
// than create a new one.
rootClock.BuildClockSubTreeFromTimeline(rootClock.Timeline, hasControllableRoot);
rootClock.AddToTimeManager();
return rootClock;
}
internal virtual void ClearCurrentIntervalsToNull()
{
}
// Perform Stage 1 of clipping next tick time: clip by parent
internal void ClipNextTickByParent()
{
// Clip by parent's NTNT if needed. We don't want to clip
// if the parent is the TimeManager's root clock.
if (!IsTimeManager && !_parent.IsTimeManager &&
(!InternalNextTickNeededTime.HasValue ||
(_parent.InternalNextTickNeededTime.HasValue && _parent.InternalNextTickNeededTime.Value < InternalNextTickNeededTime.Value)))
{
InternalNextTickNeededTime = _parent.InternalNextTickNeededTime;
}
}
internal virtual void ComputeCurrentIntervals(TimeIntervalCollection parentIntervalCollection,
TimeSpan beginTime, TimeSpan? endTime,
Duration fillDuration, Duration period,
double appliedSpeedRatio, double accelRatio, double decelRatio,
bool isAutoReversed)
{
}
internal virtual void ComputeCurrentFillInterval(TimeIntervalCollection parentIntervalCollection,
TimeSpan beginTime, TimeSpan endTime, Duration period,
double appliedSpeedRatio, double accelRatio, double decelRatio,
bool isAutoReversed)
{
}
internal void ComputeLocalState()
{
Debug.Assert(!IsTimeManager);
// Cache previous state values
ClockState lastClockState = _currentClockState;
TimeSpan? lastCurrentTime = _currentTime;
double? lastCurrentGlobalSpeed = _currentGlobalSpeed;
double? lastCurrentProgress = _currentProgress;
Int32? lastCurrentIteration = _currentIteration;
// Reset the PauseStateChangedDuringTick for this tick
PauseStateChangedDuringTick = false;
ComputeLocalStateHelper(true, false); // Perform the local state calculations with early bail out
if (lastClockState != _currentClockState)
{
// It can happen that we change state without detecting it when
// a parent is auto-reversing and we are ticking exactly at the
// reverse point, so raise the events.
RaiseCurrentStateInvalidated();
RaiseCurrentGlobalSpeedInvalidated();
RaiseCurrentTimeInvalidated();
}
//
if (_currentGlobalSpeed != lastCurrentGlobalSpeed)
{
RaiseCurrentGlobalSpeedInvalidated();
}
if (HasDiscontinuousTimeMovementOccured)
{
DiscontinuousTimeMovement();
HasDiscontinuousTimeMovementOccured = false;
}
}
///
/// Return the current duration from a specific clock
///
///
/// A Duration quantity representing the current iteration's estimated duration.
///
internal virtual Duration CurrentDuration
{
get { return Duration.Automatic; }
}
///
/// Internal helper. Schedules an interactive begin at the next tick.
/// An interactive begin is literally a seek to 0. It is completely distinct
/// from the BeginTime specified on a timeline, which is managed by
/// _pendingBeginOffset
///
internal void InternalBegin()
{
InternalSeek(TimeSpan.Zero);
}
///
/// Internal helper for moving to new API. Gets the speed multiplier for the Clock's speed.
///
internal double InternalGetSpeedRatio()
{
return _rootData.InteractiveSpeedRatio;
}
///
/// Internal helper for moving to new API. Pauses the timeline for this timeline and its children.
///
internal void InternalPause()
{
// VerifyAccess();
Debug.Assert(!IsTimeManager);
// INVARIANT: we enforce 4 possible valid states:
// 1) !Paused (running)
// 2) !Paused, Pause pending
// 3) Paused
// 4) Paused, Resume pending
Debug.Assert(!(IsInteractivelyPaused && PendingInteractivePause));
Debug.Assert(!(!IsInteractivelyPaused && PendingInteractiveResume));
if (PendingInteractiveResume) // Cancel existing resume request if made
{
PendingInteractiveResume = false;
}
else if (!IsInteractivelyPaused)
// If we don't have a pending resume AND we aren't paused already, schedule a pause
// This is an ELSE clause because if we had a Resume pending, we MUST already be paused
{
PendingInteractivePause = true;
}
NotifyNewEarliestFutureActivity();
}
///
/// Schedules a Remove operation to happen at the next tick.
///
///
/// This method schedules the Clock and its subtree to be stopped and the RemoveRequested
/// event to be fired on the subtree at the next tick.
///
internal void InternalRemove()
{
PendingInteractiveRemove = true;
InternalStop();
}
///
/// Internal helper for moving to new API. Allows a timeline's timeline to progress again after a call to Pause.
///
internal void InternalResume()
{
// VerifyAccess();
Debug.Assert(!IsTimeManager);
// INVARIANT: we enforce 4 possible valid states:
// 1) !Paused (running)
// 2) !Paused, Pause pending
// 3) Paused
// 4) Paused, sd Resume pending
Debug.Assert( !(IsInteractivelyPaused && PendingInteractivePause));
Debug.Assert( !(!IsInteractivelyPaused && PendingInteractiveResume));
if (PendingInteractivePause) // Cancel existing pause request if made
{
PendingInteractivePause = false;
}
else if (IsInteractivelyPaused)
// If we don't have a pending pause AND we are currently paused, schedule a resume
// This is an ELSE clause because if we had a Pause pending, we MUST already be unpaused
{
PendingInteractiveResume = true;
}
NotifyNewEarliestFutureActivity();
}
///
/// Internal helper for moving to new API. Seeks a timeline's timeline to a new position.
///
///
/// The destination to seek to, relative to the clock's BeginTime. If this is past the
/// active period execute the FillBehavior.
///
internal void InternalSeek(TimeSpan destination)
{
// VerifyAccess();
Debug.Assert(IsRoot);
IsInteractivelyStopped = false;
PendingInteractiveStop = false; // Cancel preceding stop;
ResetNodesWithSlip(); // Reset [....] tracking
_rootData.PendingSeekDestination = destination;
RootBeginPending = false; // cancel a previous begin call
NotifyNewEarliestFutureActivity();
}
///
/// The only things that can change for this are the begin time of this
/// timeline
///
///
/// The destination to seek to, relative to the clock's BeginTime. If this is past the
/// active perioed execute the FillBehavior.
///
internal void InternalSeekAlignedToLastTick(TimeSpan destination)
{
Debug.Assert(IsRoot);
// This is a no-op with a null TimeManager or when all durations have not yet been resolved
if (_timeManager == null || HasDescendantsWithUnresolvedDuration)
{
return;
}
// Adjust _beginTime such that our current time equals the Seek position
// that was requested
_beginTime = CurrentGlobalTime - DivideTimeSpan(destination, _appliedSpeedRatio);
if (CanGrow)
{
_currentIteration = null; // This node is not visited by ResetSlipOnSubtree
_currentIterationBeginTime = _beginTime;
ResetSlipOnSubtree();
UpdateSyncBeginTime();
}
IsInteractivelyStopped = false; // We have unset disabled status
PendingInteractiveStop = false;
RootBeginPending = false; // Cancel a pending begin
ResetNodesWithSlip(); // Reset [....] tracking
_timeManager.InternalCurrentIntervals = TimeIntervalCollection.Empty;
PrefixSubtreeEnumerator subtree = new PrefixSubtreeEnumerator(this, true);
while (subtree.MoveNext())
{
// We are processing a Seek immediately. We don't need a TIC yet
// since we are not computing events, and we don't want to
// process pending stuff either.
subtree.Current.ComputeLocalStateHelper(false, true); // Compute the state of the node
if (HasDiscontinuousTimeMovementOccured)
{
DiscontinuousTimeMovement();
HasDiscontinuousTimeMovementOccured = false;
}
subtree.Current.ClipNextTickByParent(); // Perform NextTick clipping, stage 1
// Make a note to visit for stage 2, only for ClockGroups
subtree.Current.NeedsPostfixTraversal = (subtree.Current is ClockGroup);
}
_parent.ComputeTreeStateRoot(); // Re-clip the next tick estimates by children
// Fire the events indicating that we've invalidated this whole subtree
subtree.Reset();
while (subtree.MoveNext())
{
// CurrentTimeInvalidated should be fired first to give AnimationStorage a chance
// to update the value. We directly set the flags, then fire RaiseAccumulatedEvents
// to avoid involving the TimeManager for this local subtree operation.
subtree.Current.CurrentTimeInvalidatedEventRaised = true;
subtree.Current.CurrentStateInvalidatedEventRaised = true;
subtree.Current.CurrentGlobalSpeedInvalidatedEventRaised = true;
subtree.Current.RaiseAccumulatedEvents();
}
}
///
/// Internal helper for moving to new API. Sets a speed multiplier for the Clock's speed.
///
///
/// The ratio by which to multiply the Clock's speed.
///
internal void InternalSetSpeedRatio(double ratio)
{
Debug.Assert(IsRoot);
_rootData.PendingSpeedRatio = ratio;
}
///
/// Internal helper. Schedules an end for some specified time in the future.
///
internal void InternalSkipToFill()
{
Debug.Assert(IsRoot);
TimeSpan? effectiveDuration;
effectiveDuration = ComputeEffectiveDuration();
// Throw an exception if the active period extends forever.
if (effectiveDuration == null)
{
// Can't seek to the end if the simple duration is not resolved
throw new InvalidOperationException(SR.Get(SRID.Timing_SkipToFillDestinationIndefinite));
}
// Offset to the end; override preceding seek requests
IsInteractivelyStopped = false;
PendingInteractiveStop = false;
ResetNodesWithSlip(); // Reset [....] tracking
RootBeginPending = false;
_rootData.PendingSeekDestination = effectiveDuration.Value; // Seek to the end time
NotifyNewEarliestFutureActivity();
}
///
/// Internal helper for moving to new API. Removes a timeline from its active or fill period.
/// Timeline can be restarted with an interactive Begin call.
///
internal void InternalStop()
{
Debug.Assert(IsRoot);
PendingInteractiveStop = true;
// Cancel all non-persistent interactive requests
_rootData.PendingSeekDestination = null;
RootBeginPending = false;
ResetNodesWithSlip(); // Reset [....] tracking
NotifyNewEarliestFutureActivity();
}
///
/// Raises the events that occured since the last tick and reset their state.
///
internal void RaiseAccumulatedEvents()
{
try // We are calling user-defined delegates, if they throw we must ensure that we leave the Clock in a valid state
{
// CurrentTimeInvalidated should fire first. This is because AnimationStorage hooks itself
// up to this event in order to invalidate whichever DependencyProperty this clock may be
// animating. User code in any of these callbacks may query the value of that DP - if they
// do so before AnimationStorage has a chance to invalidate they will get the wrong value.
if (CurrentTimeInvalidatedEventRaised)
{
FireCurrentTimeInvalidatedEvent();
}
if (CurrentGlobalSpeedInvalidatedEventRaised)
{
FireCurrentGlobalSpeedInvalidatedEvent();
// Tell the Clocks that they have changed Speed
SpeedChanged();
}
if (CurrentStateInvalidatedEventRaised)
{
FireCurrentStateInvalidatedEvent();
// Since the state has been invalidated this means that
// we've got a discontinuous time movemement. Tell the clock
if (!CurrentGlobalSpeedInvalidatedEventRaised)
{
DiscontinuousTimeMovement();
}
}
if (CompletedEventRaised)
{
FireCompletedEvent();
}
if (RemoveRequestedEventRaised)
{
FireRemoveRequestedEvent();
}
}
finally // Reset the flags to make the state consistent, even if the user has thrown
{
CurrentTimeInvalidatedEventRaised = false;
CurrentGlobalSpeedInvalidatedEventRaised = false;
CurrentStateInvalidatedEventRaised = false;
CompletedEventRaised = false;
RemoveRequestedEventRaised = false;
IsInEventQueue = false;
}
}
///
/// Raises the Completed event.
///
///
/// We only need to raise this event once per tick. If we've already
/// raised it in this tick, do nothing.
///
internal void RaiseCompleted()
{
Debug.Assert(!IsTimeManager);
CompletedEventRaised = true;
if (!IsInEventQueue)
{
_timeManager.AddToEventQueue(this);
IsInEventQueue = true;
}
}
///
/// Raises the CurrentGlobalSpeedInvalidated event.
///
///
/// We only need to raise this event once per tick. If we've already
/// raised it in this tick, do nothing.
///
internal void RaiseCurrentGlobalSpeedInvalidated()
{
// ROOT Debug.Assert(!IsTimeManager);
CurrentGlobalSpeedInvalidatedEventRaised = true;
if (!IsInEventQueue)
{
_timeManager.AddToEventQueue(this);
IsInEventQueue = true;
}
}
///
/// Raises the CurrentStateInvalidated event.
///
internal void RaiseCurrentStateInvalidated()
{
Debug.Assert(!IsTimeManager);
if (_currentClockState == ClockState.Stopped) // If our state changed to stopped
{
Stopped();
}
CurrentStateInvalidatedEventRaised = true;
if (!IsInEventQueue)
{
_timeManager.AddToEventQueue(this);
IsInEventQueue = true;
}
}
///
/// Raises the CurrentTimeInvalidated event. This enqueues the event for later dispatch
/// if we are in a tick operation.
///
internal void RaiseCurrentTimeInvalidated()
{
Debug.Assert(!IsTimeManager);
CurrentTimeInvalidatedEventRaised = true;
if (!IsInEventQueue)
{
_timeManager.AddToEventQueue(this);
IsInEventQueue = true;
}
}
///
/// Raises the RemoveRequested event.
///
///
/// We only need to raise this event once per tick. If we've already
/// raised it in this tick, do nothing.
///
internal void RaiseRemoveRequested()
{
Debug.Assert(!IsTimeManager);
RemoveRequestedEventRaised = true;
if (!IsInEventQueue)
{
_timeManager.AddToEventQueue(this);
IsInEventQueue = true;
}
}
// Reset all currently cached state
internal void ResetCachedStateToStopped()
{
_currentGlobalSpeed = null;
_currentIteration = null;
IsBackwardsProgressingGlobal = false;
_currentProgress = null;
_currentTime = null;
_currentClockState = ClockState.Stopped;
}
// Reset IsInSyncPeriod for this node and all children if any (ClockGroup handles this).
// We do this whenever a discontinuous interactive action (seek/begin/stop) is performed.
internal virtual void ResetNodesWithSlip()
{
if (_syncData != null)
{
_syncData.IsInSyncPeriod = false; // Reset [....] tracking
}
}
///
/// Check if our descendants have resolved their duration, and resets the HasDescendantsWithUnresolvedDuration
/// flag from true to false once that happens.
///
/// Returns true when this node or one of its descendants have unresolved duration.
internal virtual void UpdateDescendantsWithUnresolvedDuration()
{
if (HasResolvedDuration)
{
HasDescendantsWithUnresolvedDuration = false;
}
}
#endregion // Internal Methods
//
// Internal Properties
//
#region Internal Properties
///
/// Specifies the depth of this timeline in the timing tree. If the timeline does not have
/// a parent, its depth value is zero.
///
internal int Depth
{
get
{
// ROOT Debug.Assert(!IsTimeManager);
return _depth;
}
}
///
/// Returns the last time this timeline will become non-active if it is not
/// clipped by the parent container first. Null represents infinity.
///
internal Duration EndOfActivePeriod
{
get
{
Debug.Assert(!IsTimeManager);
if (!HasResolvedDuration)
{
return Duration.Automatic;
}
// Computed expiration time with respect to repeat behavior and natural duration;
TimeSpan? expirationTime;
ComputeExpirationTime(out expirationTime);
//
if (expirationTime.HasValue)
{
return expirationTime.Value;
}
else
{
return Duration.Forever;
}
}
}
///
/// Gets the first child of this timeline.
///
///
/// Since a Clock doesn't have children we will always return null
///
internal virtual Clock FirstChild
{
get
{
return null;
}
}
///
/// Internal unverified access to the CurrentState
///
///
/// Only ClockGroup should set the value
///
internal ClockState InternalCurrentClockState
{
get
{
return _currentClockState;
}
set
{
_currentClockState = value;
}
}
///
/// Internal unverified access to the CurrentGlobalSpeed
///
///
/// Only ClockGroup should set the value
///
internal double? InternalCurrentGlobalSpeed
{
get
{
return _currentGlobalSpeed;
}
set
{
_currentGlobalSpeed = value;
}
}
///
/// Internal unverified access to the CurrentIteration
///
///
/// Only ClockGroup should set the value
///
internal Int32? InternalCurrentIteration
{
get
{
return _currentIteration;
}
set
{
_currentIteration = value;
}
}
///
/// Internal unverified access to the CurrentProgress
///
///
/// Only ClockGroup should set the value
///
internal double? InternalCurrentProgress
{
get
{
return _currentProgress;
}
set
{
_currentProgress = value;
}
}
///
/// The next GlobalTime that this clock may need a tick
///
internal TimeSpan? InternalNextTickNeededTime
{
get
{
return _nextTickNeededTime;
}
set
{
_nextTickNeededTime = value;
}
}
///
/// Unchecked internal access to the parent of this Clock.
///
internal ClockGroup InternalParent
{
get
{
Debug.Assert(!IsTimeManager);
return _parent;
}
}
///
/// Gets the current Duration for internal callers. This property will
/// never return Duration.Automatic. If the _resolvedDuration of the Clock
/// has not yet been resolved, this property will return Duration.Forever.
/// Therefore, it's possible that the value of this property will change
/// one time during the Clock's lifetime. It's not predictable when that
/// change will occur, it's up to the custom Clock author.
///
internal Duration ResolvedDuration
{
get
{
ResolveDuration();
Debug.Assert(_resolvedDuration != Duration.Automatic, "_resolvedDuration should never be set to Automatic.");
return _resolvedDuration;
}
}
///
/// Gets the right sibling of this timeline.
///
///
/// The right sibling of this timeline if it's not the last in its parent's
/// collection; otherwise, null.
///
internal Clock NextSibling
{
get
{
Debug.Assert(!IsTimeManager);
Debug.Assert(_parent != null && !_parent.IsTimeManager);
List parentChildren = _parent.InternalChildren;
if (_childIndex == parentChildren.Count - 1)
{
return null;
}
else
{
return parentChildren[_childIndex + 1];
}
}
}
///
/// Gets a cached weak reference to this clock.
///
internal WeakReference WeakReference
{
get
{
WeakReference reference = _weakReference;
if (reference == null)
{
reference = new WeakReference(this);
_weakReference = reference;
}
return reference;
}
}
///
/// Get the desired framerate of this clock
///
internal int? DesiredFrameRate
{
get
{
int? returnValue = null;
if (HasDesiredFrameRate)
{
returnValue = _rootData.DesiredFrameRate;
}
return returnValue;
}
}
//
// Internal access to some of the flags
//
#region Internal Flag Accessors
internal bool CompletedEventRaised
{
get
{
return GetFlag(ClockFlags.CompletedEventRaised);
}
set
{
SetFlag(ClockFlags.CompletedEventRaised, value);
}
}
internal bool CurrentGlobalSpeedInvalidatedEventRaised
{
get
{
return GetFlag(ClockFlags.CurrentGlobalSpeedInvalidatedEventRaised);
}
set
{
SetFlag(ClockFlags.CurrentGlobalSpeedInvalidatedEventRaised, value);
}
}
internal bool CurrentStateInvalidatedEventRaised
{
get
{
return GetFlag(ClockFlags.CurrentStateInvalidatedEventRaised);
}
set
{
SetFlag(ClockFlags.CurrentStateInvalidatedEventRaised, value);
}
}
internal bool CurrentTimeInvalidatedEventRaised
{
get
{
return GetFlag(ClockFlags.CurrentTimeInvalidatedEventRaised);
}
set
{
SetFlag(ClockFlags.CurrentTimeInvalidatedEventRaised, value);
}
}
private bool HasDesiredFrameRate
{
get
{
return GetFlag(ClockFlags.HasDesiredFrameRate);
}
set
{
SetFlag(ClockFlags.HasDesiredFrameRate, value);
}
}
internal bool HasResolvedDuration
{
get
{
return GetFlag(ClockFlags.HasResolvedDuration);
}
set
{
SetFlag(ClockFlags.HasResolvedDuration, value);
}
}
internal bool IsBackwardsProgressingGlobal
{
get
{
return GetFlag(ClockFlags.IsBackwardsProgressingGlobal);
}
set
{
SetFlag(ClockFlags.IsBackwardsProgressingGlobal, value);
}
}
internal bool IsInEventQueue
{
get
{
return GetFlag(ClockFlags.IsInEventQueue);
}
set
{
SetFlag(ClockFlags.IsInEventQueue, value);
}
}
///
/// Unchecked internal access to the paused state of the clock.
///
///
/// Returns true if the Clock traversed during the first tick pass.
///
///
/// Determine if we are active, filling, or off
/// parentTime is clamped if it is inside the postfill zone
/// We have to handle reversed parent differently because we have closed-open intervals in global time
///
/// Our computed expiration time, null if infinite.
/// Our parent time.
/// Our parent speed.
/// Whether we are called from within a tick.
///
/// GillesK: performTickOperations means that we process the pending events
///
private void ComputeLocalStateHelper(bool performTickOperations, bool seekedAlignedToLastTick)
{
Debug.Assert(!IsTimeManager);
TimeSpan? parentTime; // Computed parent-local time
TimeSpan? expirationTime; // Computed expiration time with respect to repeat behavior and resolved duration;
TimeSpan localProgress; // Computed time inside simple duration
TimeSpan parentTimeValue;
double? parentSpeed; // Parent's CurrentGlobalSpeed
TimeIntervalCollection parentIntervalCollection;
double localSpeed;
bool returnDelayed = false; //
// In this function, 'true' return values allow us to exit early
// We first compute parent parameters; with SlipBehavior, we may modify our parentIntervalCollection
if (ComputeParentParameters(out parentTime, out parentSpeed,
out parentIntervalCollection, seekedAlignedToLastTick))
{
returnDelayed = true;
}
// Now take potential SlipBehavior into account:
if (_syncData != null && _syncData.IsInSyncPeriod && _parent.CurrentState != ClockState.Stopped) // We are already in a slip zone
{
Debug.Assert(parentTime.HasValue); // If parent isn't stopped, it must have valid time and speed
Debug.Assert(parentSpeed.HasValue);
//
ComputeSyncSlip(ref parentIntervalCollection, parentTime.Value, parentSpeed.Value);
}
ResolveDuration();
// We only calculate the Interactive values when we are processing the pending events
if (performTickOperations && IsRoot)
{
// Special case for root-children, which may have interactivity
if (ComputeInteractiveValues())
{
returnDelayed = true;
}
}
// Check whether we are entering a [....] period. This includes cases when we have
// ticked before the beginning, then past the end of a [....] period; we still have to
// move back to the exact beginning of the tick period. We handle cases where
// we seek (HasSeekOccuredAfterLastTick) in a special way, by not synchronizing with the beginning.
// Also, if the parent has been paused prior to this tick, we cannot enter the [....] zone, so skip the call.
if (_syncData != null && !_syncData.IsInSyncPeriod && _parent.CurrentState != ClockState.Stopped &&
(!parentIntervalCollection.IsEmptyOfRealPoints || HasSeekOccuredAfterLastTick))
{
Debug.Assert(parentTime.HasValue); // Cannot be true unless parent is stopped
// We use the parent's TIC as a way of determining its earliest non-null time
ComputeSyncEnter(ref parentIntervalCollection, parentTime.Value);
}
if (ComputeExpirationTime(out expirationTime))
{
returnDelayed = true;
}
// Run the eventing logic here
if (performTickOperations)
{
ComputeEvents(expirationTime, parentIntervalCollection);
}
if (returnDelayed) // If we delayed returning until now, proceed to do so
{
return;
}
Debug.Assert(_beginTime.HasValue);
Debug.Assert(parentTime.HasValue);
parentTimeValue = parentTime.Value;
// Determines the next time we need to tick
if (ComputeNextTickNeededTime(expirationTime, parentTimeValue, parentSpeed.Value))
{
return;
}
// Determines if we are active, filling, or off
if (ComputeCurrentState(expirationTime, ref parentTimeValue, parentSpeed.Value, performTickOperations))
{
return;
}
// Determines the current iteration
if (ComputeCurrentIteration(parentTimeValue, parentSpeed.Value,
expirationTime, out localProgress))
{
return;
}
// Determines the current time and local speed with accel+decel
if (ComputeCurrentTime(localProgress, out localSpeed))
{
return;
}
// Determines the current speed
if (ComputeCurrentSpeed(localSpeed))
{
return;
}
}
//
// Determine the next needed tick time for approaching a StateInvalidated boundary
//
// Note that ComputeCurrentIteration and ComputeCurrentState also modify the
// NextTickNeededTime and consequently must run after this method.
//
private bool ComputeNextTickNeededTime(TimeSpan? expirationTime,
TimeSpan parentTime, double parentSpeed)
{
Debug.Assert(!IsTimeManager);
Debug.Assert(!IsInteractivelyStopped);
Debug.Assert(_parent._currentClockState != ClockState.Stopped);
Debug.Assert(_beginTime.HasValue);
if (parentSpeed == 0)
{
//
InternalNextTickNeededTime = IsInteractivelyPaused ? TimeSpan.Zero : (TimeSpan?)null;
}
else
{
double invertedParentSpeed = 1.0 / parentSpeed;
TimeSpan? timeUntilNextBoundary = null;
//
// Calculate the time in ms until begin or expiration time.
// They are positive if we're heading towards one of these periods, negative if heading away.
// This takes into account reversing clocks (so a clock heading back to begin will have
// a positive timeUntilBegin).
//
// timeUntilNextBoundary will be the first of these three boundaries that we hit.
// Negative values are obviously ignored.
//
TimeSpan timeUntilBegin = MultiplyTimeSpan(_beginTime.Value - parentTime, invertedParentSpeed);
//
// If the time until a boundary is 0 (i.e. we've ticked exactly on a boundary)
// we'll ask for another tick immediately.
// This is only relevant for reversing clocks, which, when on a boundary, are defined
// to have the 'previous' state, not the 'next' state. Thus they need one more
// tick for the state change to happen.
//
if (timeUntilBegin >= TimeSpan.Zero)
{
timeUntilNextBoundary = timeUntilBegin;
}
if (expirationTime.HasValue)
{
TimeSpan timeUntilExpiration = MultiplyTimeSpan(expirationTime.Value - parentTime, invertedParentSpeed);
if (timeUntilExpiration >= TimeSpan.Zero &&
(!timeUntilNextBoundary.HasValue || timeUntilExpiration < timeUntilNextBoundary.Value))
{
timeUntilNextBoundary = timeUntilExpiration;
}
}
//
// Set the next tick needed time depending on whether we're
// headed towards a boundary.
//
if (timeUntilNextBoundary.HasValue)
{
// We are moving towards some ClockState boundary either begin or expiration
InternalNextTickNeededTime = CurrentGlobalTime + timeUntilNextBoundary;
}
else
{
// We are not moving towards any boundary points
InternalNextTickNeededTime = null;
}
}
return false;
}
// Compute the parent's time; by the time we reach this method, we know that we
// have a non-root parent.
private bool ComputeParentParameters(out TimeSpan? parentTime, out double? parentSpeed,
out TimeIntervalCollection parentIntervalCollection,
bool seekedAlignedToLastTick)
{
Debug.Assert(!IsTimeManager);
Debug.Assert(!IsInteractivelyStopped || IsRoot);
if (IsRoot) // We are a root child, use time manager time
{
Debug.Assert(_rootData != null, "A root Clock must have the _rootData structure initialized.");
HasSeekOccuredAfterLastTick = seekedAlignedToLastTick || (_rootData.PendingSeekDestination != null); // We may have a seek request pending
// We don't have a TimeManager that is on, so we are off, nothing more to compute
if (_timeManager == null || _timeManager.InternalIsStopped)
{
ResetCachedStateToStopped();
parentTime = null; // Assign parentTime to avoid compiler error
parentSpeed = null;
InternalNextTickNeededTime = TimeSpan.Zero; // When TimeManager wakes up, we will need an update
parentIntervalCollection = TimeIntervalCollection.Empty;
return true;
}
else // We have a valid global time;
{
parentSpeed = 1.0; // TimeManager defines the rate at which time moves, e.g. it moves at 1X speed
parentIntervalCollection = _timeManager.InternalCurrentIntervals;
if (HasDesiredFrameRate)
{
// Change the parent's interval collection to include all time intervals since the last time
// we ticked this root node. Due to DFR, we may have skipped a number of "important" ticks.
parentTime = _rootData.CurrentAdjustedGlobalTime;
if (!parentIntervalCollection.IsEmptyOfRealPoints)
{
//
parentIntervalCollection = parentIntervalCollection.SetBeginningOfConnectedInterval(
_rootData.LastAdjustedGlobalTime);
}
}
else
{
parentTime = _timeManager.InternalCurrentGlobalTime;
}
return false;
}
}
else // We are a deeper node
{
HasSeekOccuredAfterLastTick = seekedAlignedToLastTick || _parent.HasSeekOccuredAfterLastTick; // We may have a seek request pending
parentTime = _parent._currentTime; // This is Null if parent is off; we still init the 'out' parameter
parentSpeed = _parent._currentGlobalSpeed;
parentIntervalCollection = _parent.CurrentIntervals;
// Find the parent's current time
if (_parent._currentClockState != ClockState.Stopped) // We have a parent that is active or filling
{
return false;
}
else // Else parent is off, so we are off, nothing more to compute
{
// Before setting our state to Stopped make sure that we
// fire the proper event if we change state.
if (_currentClockState != ClockState.Stopped)
{
RaiseCurrentStateInvalidated();
RaiseCurrentGlobalSpeedInvalidated();
RaiseCurrentTimeInvalidated();
}
ResetCachedStateToStopped();
InternalNextTickNeededTime = null;
return true;
}
}
}
// Abbreviations for variables expressing time units:
// PT: Parent time (e.g. our begin time is expressed in parent time coordinates)
// LT: Local time (e.g. our duration is expressed in local time coordinates)
// ST: [....] time -- this is the same as local time iff (_syncData.SyncClock == this) e.g. we are the [....] clock,
// otherwise it is our child's time coordinates (this happens when we are a container with SlipBehavior.Slip).
// SPT: The [....] clock's parent's time coordinates. When this IS the [....] clock, this is our parent coordinates.
// otherwise, it is our local coordinates.
private void ComputeSyncEnter(ref TimeIntervalCollection parentIntervalCollection,
TimeSpan currentParentTimePT)
{
Debug.Assert(!IsTimeManager);
Debug.Assert(_parent != null);
Debug.Assert(_parent.CurrentState != ClockState.Stopped);
// Parent is not stopped, so its TIC cannot be empty
Debug.Assert(HasSeekOccuredAfterLastTick ||
(!parentIntervalCollection.IsEmptyOfRealPoints && parentIntervalCollection.FirstNodeTime <= currentParentTimePT));
// SyncData points to our child if we have SlipBehavior, for CanSlip nodes it points to the node itself
Debug.Assert(_syncData.SyncClock == this || _syncData.SyncClock._parent == this);
Debug.Assert(CanSlip || _timeline is ParallelTimeline && ((ParallelTimeline)_timeline).SlipBehavior == SlipBehavior.Slip);
Debug.Assert(_syncData != null);
Debug.Assert(!_syncData.IsInSyncPeriod);
// Verify our limitations on slip functionality, but don't throw here for perf
Debug.Assert(_timeline.AutoReverse == false);
Debug.Assert(_timeline.AccelerationRatio == 0);
Debug.Assert(_timeline.DecelerationRatio == 0);
// With these limitations, we can easily preview our CurrentTime:
if (_beginTime.HasValue && currentParentTimePT >= _beginTime.Value)
{
TimeSpan relativeBeginTimePT = _currentIterationBeginTime.HasValue ? _currentIterationBeginTime.Value : _beginTime.Value;
TimeSpan previewCurrentOffsetPT = currentParentTimePT - relativeBeginTimePT; // This is our time offset (not yet scaled by speed)
TimeSpan previewCurrentTimeLT = MultiplyTimeSpan(previewCurrentOffsetPT, _appliedSpeedRatio); // This is what our time would be
// We can only enter [....] period if we are past the syncClock's begin time
if (_syncData.SyncClock == this || previewCurrentTimeLT >= _syncData.SyncClockBeginTime)
{
// We have two very different scenarios: seek and non-seek enter
if (HasSeekOccuredAfterLastTick) // We have seeked, see if we fell into a [....] period
{
// If we haven't returned yet, we are not past the end of the [....] period on the child
// Also, we are not Stopped prior to BeginTime.
TimeSpan? expirationTimePT;
ComputeExpirationTime(out expirationTimePT);
// This is to verify we did not seek past our active period duration
if (!expirationTimePT.HasValue || currentParentTimePT < expirationTimePT.Value)
{
TimeSpan ourSyncTimeST = (_syncData.SyncClock == this) ?
previewCurrentTimeLT :
MultiplyTimeSpan(previewCurrentTimeLT - _syncData.SyncClockBeginTime,
_syncData.SyncClockSpeedRatio);
TimeSpan? syncClockEffectiveDurationST = _syncData.SyncClockEffectiveDuration;
if (_syncData.SyncClock == this ||
!syncClockEffectiveDurationST.HasValue || ourSyncTimeST < syncClockEffectiveDurationST)
{
// If the [....] child has a specified duration
Duration syncClockDuration = _syncData.SyncClockResolvedDuration;
if (syncClockDuration.HasTimeSpan)
{
_syncData.PreviousSyncClockTime = TimeSpan.FromTicks(ourSyncTimeST.Ticks % syncClockDuration.TimeSpan.Ticks);
_syncData.PreviousRepeatTime = ourSyncTimeST - _syncData.PreviousSyncClockTime;
}
else if (syncClockDuration == Duration.Forever)
{
_syncData.PreviousSyncClockTime = ourSyncTimeST;
_syncData.PreviousRepeatTime = TimeSpan.Zero;
}
else
{
Debug.Assert(syncClockDuration == Duration.Automatic);
// If we seek into an Automatic syncChild's duration, we may overseek it, so throw an exception
throw new InvalidOperationException(SR.Get(SRID.Timing_SeekDestinationAmbiguousDueToSlip));
}
// This is the heart of the HasSeekOccuredAfterLastTick codepath; we don't adjust our
// time, but note to do so for the succeeding ticks.
_syncData.IsInSyncPeriod = true;
}
}
}
else // Non-seek, regular case
{
TimeSpan? previousSyncParentTimeSPT = (_syncData.SyncClock == this) ?
parentIntervalCollection.FirstNodeTime :
_currentTime;
if (!previousSyncParentTimeSPT.HasValue
|| _syncData.SyncClockDiscontinuousEvent
|| previousSyncParentTimeSPT.Value <= _syncData.SyncClockBeginTime)
// Not seeking this tick, different criteria for entering [....] period.
// We don't care if we overshot the beginTime, because we will seek backwards
// to match the child's beginTime exactly.
// NOTE: _currentTime is actually our time at last tick, since it wasn't yet updated.
{
// First, adjust our beginTime so that we match the syncClock's begin, accounting for SpeedRatio
TimeSpan timeIntoSyncPeriodPT = previewCurrentOffsetPT;
if (_syncData.SyncClock != this) // SyncClock is our child; account for SyncClock starting later than us
{
timeIntoSyncPeriodPT -= DivideTimeSpan(_syncData.SyncClockBeginTime, _appliedSpeedRatio);
}
// Offset our position to [....] with media begin
if (_currentIterationBeginTime.HasValue)
{
_currentIterationBeginTime += timeIntoSyncPeriodPT;
}
else
{
_beginTime += timeIntoSyncPeriodPT;
}
//
UpdateSyncBeginTime(); // This ensures that our _cutoffTime is correctly applied
// Now, update the parent TIC to compensate for our slip
parentIntervalCollection = parentIntervalCollection.SlipBeginningOfConnectedInterval(timeIntoSyncPeriodPT);
_syncData.IsInSyncPeriod = true;
_syncData.PreviousSyncClockTime = TimeSpan.Zero;
_syncData.PreviousRepeatTime = TimeSpan.Zero;
_syncData.SyncClockDiscontinuousEvent = false;
}
}
}
}
}
// Abbreviations for variables expressing time units:
// PT: Parent time (e.g. our begin time is expressed in parent time coordinates)
// LT: Local time (e.g. our duration is expressed in local time coordinates)
// ST: [....] time -- this is the same as local time iff (_syncData.SyncClock == this) e.g. we are the [....] clock,
// otherwise it is our child's time coordinates (this happens when we are a container with SlipBehavior.Slip).
// SPT: The [....] clock's parent's time coordinates. When this IS the [....] clock, this is our parent coordinates.
// otherwise, it is our local coordinates.
private void ComputeSyncSlip(ref TimeIntervalCollection parentIntervalCollection,
TimeSpan currentParentTimePT, double currentParentSpeed)
{
Debug.Assert(!IsTimeManager);
Debug.Assert(_parent != null);
Debug.Assert(_syncData != null);
Debug.Assert(_syncData.IsInSyncPeriod);
// SyncData points to our child if we have SlipBehavior, for CanSlip nodes it points to the node itself
Debug.Assert(_syncData.SyncClock == this || _syncData.SyncClock._parent == this);
// The overriding assumption for slip limitations is that the parent's intervals are
// "connected", e.g. not broken into multiple intervals. This is always true for roots.
Debug.Assert(!parentIntervalCollection.IsEmpty); // The parent isn't Stopped, so it must have a TIC
// From now on, we assume that the parent's TIC begins from the parent's CurrentTime at
// at the previous tick. Ensure that the parent is moving forward.
Debug.Assert(parentIntervalCollection.IsEmptyOfRealPoints || parentIntervalCollection.FirstNodeTime <= currentParentTimePT);
Debug.Assert(currentParentSpeed >= 0);
// We now extract this information from the TIC. If we are paused, we have an empty TIC and assume parent time has not changed.
TimeSpan previousParentTimePT = parentIntervalCollection.IsEmptyOfRealPoints ? currentParentTimePT
: parentIntervalCollection.FirstNodeTime;
TimeSpan parentElapsedTimePT = currentParentTimePT - previousParentTimePT;
// Our elapsed time is assumed to be a simple linear scale of the parent's time,
// as long as we are inside of the [....] period.
TimeSpan ourProjectedElapsedTimeLT = MultiplyTimeSpan(parentElapsedTimePT, _appliedSpeedRatio);
TimeSpan syncTimeST = _syncData.SyncClock.GetCurrentTimeCore();
TimeSpan syncElapsedTimeST = syncTimeST - _syncData.PreviousSyncClockTime; // Elapsed from last tick
if (syncElapsedTimeST > TimeSpan.Zero) // Only store the last value if it is greater than
// the old value. Note we can use either >= or > here.
{
// Check whether [....] has reached the end of our effective duration
TimeSpan? effectiveDurationST = _syncData.SyncClockEffectiveDuration;
Duration syncDuration = _syncData.SyncClockResolvedDuration;
if (effectiveDurationST.HasValue &&
(_syncData.PreviousRepeatTime + syncTimeST >= effectiveDurationST.Value))
{
_syncData.IsInSyncPeriod = false; // This is the last time we need to [....]
_syncData.PreviousRepeatTime = TimeSpan.Zero;
_syncData.SyncClockDiscontinuousEvent = false; // Make sure we don't reenter the [....] period
}
// Else check if we should wrap the simple duration due to repeats, and set previous times accordingly
else if (syncDuration.HasTimeSpan && syncTimeST >= syncDuration.TimeSpan)
{
// If we have a single repetition, then we would be done here;
// However, we may just have reached the end of an iteration on repeating media;
// In this case, we still [....] this particular moment, but we should reset the
// previous [....] clock time to zero, and increment the PreviousRepeatTime.
// This tick, media should pick up a corresponding DiscontinuousMovement caused
// by a repeat, and reset itself to zero as well.
_syncData.PreviousSyncClockTime = TimeSpan.Zero;
_syncData.PreviousRepeatTime += syncDuration.TimeSpan;
}
else // Don't need to wrap around
{
_syncData.PreviousSyncClockTime = syncTimeST;
}
}
else // If the [....] timeline went backwards, pretend it just didn't move.
{
syncElapsedTimeST = TimeSpan.Zero;
}
// Convert elapsed time to local coordinates, not necessarily same as [....] clock coordinates
TimeSpan syncElapsedTimeLT = (_syncData.SyncClock == this)
? syncElapsedTimeST
: DivideTimeSpan(syncElapsedTimeST, _syncData.SyncClockSpeedRatio);
// This is the actual slip formula: how much is the slipping clock lagging behind?
TimeSpan parentTimeSlipPT = parentElapsedTimePT - DivideTimeSpan(syncElapsedTimeLT, _appliedSpeedRatio);
// NOTE: The above line does the same as this:
// parentTimeSlip = syncSlip / _appliedSpeedRatio
// ...but it maintains greater accuracy and prevents a bug where parentTimeSlip ends up 1 tick greater
// that it should be, thus becoming larger than parentElapsedTimePT and causing us to suddenly fall out
// of our [....] period.
// Unless the media is exactly perfect, we will have non-zero slip time; we assume that it isn't
// perfect, and always adjust our time accordingly.
if (_currentIterationBeginTime.HasValue)
{
_currentIterationBeginTime += parentTimeSlipPT;
}
else
{
_beginTime += parentTimeSlipPT;
}
//
UpdateSyncBeginTime();
parentIntervalCollection = parentIntervalCollection.SlipBeginningOfConnectedInterval(parentTimeSlipPT);
return;
}
private void ResetSlipOnSubtree()
{
// Reset all children's slip time here; NOTE that this will change our effective duration,
// but this should not become important until the next tick, when it will be recomputed anyway.
PrefixSubtreeEnumerator subtree = new PrefixSubtreeEnumerator(this, false); // No iteration at this node
while (subtree.MoveNext())
{
Clock current = subtree.Current;
Debug.Assert(!current.IsRoot, "Root nodes never should reset their Slip amounts with ResetSlipOnSubtree(), even when seeking.");
if (current._syncData != null)
{
current._syncData.IsInSyncPeriod = false;
current._syncData.SyncClockDiscontinuousEvent = true;
}
if (current.CanSlip)
{
current._beginTime = current._timeline.BeginTime; // _beginTime could have slipped with media nodes
current._currentIteration = null;
current.UpdateSyncBeginTime();
current.HasDiscontinuousTimeMovementOccured = true;
}
else if (current.CanGrow) // If it's a repeating container with slippable descendants...
{
current._currentIterationBeginTime = current._beginTime; // ...reset its current iteration as well
current._currentDuration = current._resolvedDuration; // Revert currentDuration back to default size
}
else // Otherwise we know not to traverse any further
{
subtree.SkipSubtree();
}
}
}
#endregion // Local State Computation Helpers
#region Event Helpers
///
/// Adds a delegate to the list of event handlers on this object.
///
///
/// A unique identifier for the event handler. Since Clock events
/// mirror Timeline events the callers of this method will pass in
/// keys from Timeline
///
/// The delegate to add
private void AddEventHandler(EventPrivateKey key, Delegate handler)
{
Debug.Assert(!IsTimeManager);
if (_eventHandlersStore == null)
{
_eventHandlersStore = new EventHandlersStore();
}
_eventHandlersStore.Add(key, handler);
VerifyNeedsTicksWhenActive();
}
///
/// Immediately fire the Loaded Event
///
private void FireCompletedEvent()
{
FireEvent(Timeline.CompletedKey);
}
///
/// Immediately fire the GlobalSpeedInvalidated Event
///
private void FireCurrentGlobalSpeedInvalidatedEvent()
{
FireEvent(Timeline.CurrentGlobalSpeedInvalidatedKey);
}
///
/// Immediately fire the State Invalidated Event
///
private void FireCurrentStateInvalidatedEvent()
{
FireEvent(Timeline.CurrentStateInvalidatedKey);
}
///
/// Immediately fire the CurrentTimeInvalidated Event
///
private void FireCurrentTimeInvalidatedEvent()
{
FireEvent(Timeline.CurrentTimeInvalidatedKey);
}
///
/// Fires the given event
///
/// The unique key representing the event to fire
private void FireEvent(EventPrivateKey key)
{
if (_eventHandlersStore != null)
{
EventHandler handler = (EventHandler)_eventHandlersStore.Get(key);
if (handler != null)
{
handler(this, null);
}
}
}
///
/// Immediately fire the RemoveRequested Event
///
private void FireRemoveRequestedEvent()
{
FireEvent(Timeline.RemoveRequestedKey);
}
// Find the last closest time that falls on the boundary of the Desired Frame Rate
private TimeSpan GetCurrentDesiredFrameTime(TimeSpan time)
{
return GetDesiredFrameTime(time, +0);
}
// Find the closest time that falls on the boundary of the Desired Frame Rate, advancing [frameOffset] frames forward
private TimeSpan GetDesiredFrameTime(TimeSpan time, int frameOffset)
{
Debug.Assert(_rootData.DesiredFrameRate > 0);
Int64 desiredFrameRate = _rootData.DesiredFrameRate;
Int64 desiredFrameNumber = (time.Ticks * desiredFrameRate) / s_TimeSpanTicksPerSecond + frameOffset;
Int64 desiredFrameTick = (desiredFrameNumber * s_TimeSpanTicksPerSecond) / desiredFrameRate;
return TimeSpan.FromTicks(desiredFrameTick);
}
// Find the next closest time that falls on the boundary of the Desired Frame Rate
private TimeSpan GetNextDesiredFrameTime(TimeSpan time)
{
return GetDesiredFrameTime(time, +1);
}
///
/// Removes a delegate from the list of event handlers on this object.
///
///
/// A unique identifier for the event handler. Since Clock events
/// mirror Timeline events the callers of this method will pass in
/// keys from Timeline
///
/// The delegate to remove
private void RemoveEventHandler(EventPrivateKey key, Delegate handler)
{
Debug.Assert(!IsTimeManager);
if (_eventHandlersStore != null)
{
_eventHandlersStore.Remove(key, handler);
if (_eventHandlersStore.Count == 0)
{
_eventHandlersStore = null;
}
}
UpdateNeedsTicksWhenActive();
}
#endregion // Event Helpers
///
/// Adds this clock to the time manager.
///
private void AddToTimeManager()
{
Debug.Assert(!IsTimeManager);
Debug.Assert(_parent == null);
Debug.Assert(_timeManager == null);
TimeManager timeManager = MediaContext.From(Dispatcher).TimeManager;
if (timeManager == null)
{
// The time manager has not been created or has been released
// This occurs when we are shutting down. Simply return.
return;
}
_parent = timeManager.TimeManagerClock;
SetTimeManager(_parent._timeManager);
Int32? desiredFrameRate = Timeline.GetDesiredFrameRate(_timeline);
if (desiredFrameRate.HasValue)
{
HasDesiredFrameRate = true;
_rootData.DesiredFrameRate = desiredFrameRate.Value;
}
// Store this clock in the root clock's child collection
_parent.InternalRootChildren.Add(WeakReference);
// Create a finalizer object that will clean up after we are gone
_subtreeFinalizer = new SubtreeFinalizer(_timeManager);
// Fix up depth values
PrefixSubtreeEnumerator subtree = new PrefixSubtreeEnumerator(this, true);
while (subtree.MoveNext())
{
Clock current = subtree.Current;
current._depth = current._parent._depth + 1;
}
// Perform any necessary updates
if (IsInTimingTree)
{
// Mark the tree as dirty
_timeManager.SetDirty();
}
TimeIntervalCollection currentIntervals = TimeIntervalCollection.CreatePoint(_timeManager.InternalCurrentGlobalTime);
currentIntervals.AddNullPoint();
_timeManager.InternalCurrentIntervals = currentIntervals;
//
// Recompute the local state at this subtree
//
// Since _beginTime for a root clock takes the current time into account,
// it needs to be set during a tick. The call to ComputeLocalState
// here isn't on a tick boundary, so we don't want to begin the clock yet.
_beginTime = null;
_currentIterationBeginTime = null;
subtree.Reset();
while (subtree.MoveNext())
{
subtree.Current.ComputeLocalState(); // Compute the state of the node
subtree.Current.ClipNextTickByParent(); // Perform NextTick clipping, stage 1
// Make a note to visit for stage 2, only for ClockGroups
subtree.Current.NeedsPostfixTraversal = (subtree.Current is ClockGroup);
}
_parent.ComputeTreeStateRoot(); // Re-clip the next tick estimates by children
// Adding is an implicit begin, so do that here. This is done after
// ComputeLocalState so that the begin will be picked up on the
// next tick. Note that if _timeline.BeginTime == null we won't
// start the clock.
if (_timeline.BeginTime != null)
{
RootBeginPending = true;
}
NotifyNewEarliestFutureActivity(); // Make sure we get ticks
}
///
/// Helper for more elegant code dividing a TimeSpan by a double
///
private TimeSpan DivideTimeSpan(TimeSpan timeSpan, double factor)
{
Debug.Assert(factor != 0); // Divide by zero
return TimeSpan.FromTicks((long)(((double)timeSpan.Ticks) / factor + 0.5));
}
///
/// Gets the value of a flag specified by the ClockFlags enum
///
private bool GetFlag(ClockFlags flagMask)
{
return (_flags & flagMask) == flagMask;
}
///
/// Helper for more elegant code multiplying a TimeSpan by a double
///
private static TimeSpan MultiplyTimeSpan(TimeSpan timeSpan, double factor)
{
return TimeSpan.FromTicks((long)(factor * (double)timeSpan.Ticks + 0.5));
}
private void NotifyNewEarliestFutureActivity()
{
PrefixSubtreeEnumerator subtree = new PrefixSubtreeEnumerator(this, true); // First reset the children
while (subtree.MoveNext())
{
subtree.Current.InternalNextTickNeededTime = TimeSpan.Zero;
}
Clock current = _parent; // Propagate the fact that we will need an update sooner up the chain
while (current != null && current.InternalNextTickNeededTime != TimeSpan.Zero)
{
current.InternalNextTickNeededTime = TimeSpan.Zero;
if (current.IsTimeManager) // We went all the way up to the root node, notify TimeManager
{
_timeManager.NotifyNewEarliestFutureActivity();
break;
}
current = current._parent;
}
if (_timeManager != null)
{
// If we get here from within a Tick, this will force MediaContext to perform another subsequent Tick
// on the TimeManager. This will apply the requested interactive operations, so their results will
// immediately become visible.
_timeManager.SetDirty();
}
}
// State that must remain *constant* outside of the active period
private void ResetCachedStateToFilling()
{
_currentGlobalSpeed = 0;
IsBackwardsProgressingGlobal = false;
_currentClockState = ClockState.Filling;
}
///
/// Calls RaiseCompleted on this subtree when called on a root.
///
/// Whether we are in a tick.
private void RaiseCompletedForRoot(bool isInTick)
{
// Only perform this operation from root nodes. Also, to avoid constantly calling Completed after passing
// expirationTime, check that the state is invalidated, so we only raise the event as we are finishing.
if (IsRoot && (CurrentStateInvalidatedEventRaised || !isInTick))
{
// If we are a root node, notify the entire subtree
PrefixSubtreeEnumerator subtree = new PrefixSubtreeEnumerator(this, true);
while (subtree.MoveNext())
{
subtree.Current.RaiseCompleted();
}
}
}
private void RaiseRemoveRequestedForRoot()
{
Debug.Assert(IsRoot); // This should only be called on root-child clocks
// If we are a root node, notify the entire subtree
PrefixSubtreeEnumerator subtree = new PrefixSubtreeEnumerator(this, true);
while (subtree.MoveNext())
{
subtree.Current.RaiseRemoveRequested();
}
}
///
/// Sets a specified flag with the given value
///
private void SetFlag(ClockFlags flagMask, bool value)
{
if (value)
{
_flags |= flagMask;
}
else
{
_flags &= ~(flagMask);
}
}
///
/// Sets the time manager for the subtree rooted at this timeline.
///
///
/// The new time manager.
///
private void SetTimeManager(TimeManager timeManager)
{
Debug.Assert(!IsTimeManager);
// Optimize the no-op case away
if (this._timeManager != timeManager)
{
// Set the new time manager for the whole subtree
PrefixSubtreeEnumerator subtree = new PrefixSubtreeEnumerator(this, true);
while (subtree.MoveNext())
{
subtree.Current._timeManager = timeManager;
}
if (timeManager != null)
{
// If we are joining a new time manager, issue any deferred calls
subtree.Reset();
while (subtree.MoveNext())
{
Clock current = subtree.Current;
//
}
}
}
}
private void UpdateNeedsTicksWhenActive()
{
// Currently we'll set NeedsTicksWhenActive to true
// if any of the three events are set on this clock.
//
if (_eventHandlersStore == null)
{
NeedsTicksWhenActive = false;
}
else
{
NeedsTicksWhenActive = true;
}
}
// This wrapper is invoked anytime we invalidate the _beginTime
private void UpdateSyncBeginTime()
{
if (_syncData != null)
{
_syncData.UpdateClockBeginTime();
}
}
private void VerifyNeedsTicksWhenActive()
{
if (!NeedsTicksWhenActive) // We may need to update the tree to know that we need ticks
{
NeedsTicksWhenActive = true; // Use this as a hint for NeedsTicksWhenActive
NotifyNewEarliestFutureActivity();
}
}
#endregion // Private Methods
//
// Private Properties
//
#region Private Properties
///
/// True if we are in a running timing tree, false otherwise.
///
private bool IsInTimingTree
{
get
{
Debug.Assert(!IsTimeManager);
return (_timeManager != null) && (_timeManager.State != TimeState.Stopped);
}
}
///
/// This isn't an Interactive method: InternalBegin does
/// not make use of this flag. It is set in AddToRoot() to
/// notify a root clock that it must begin at the next tick.
/// Until this is set_beginTime for a root clock will be null;
/// AdjustBeginTime() sets _beginTime properly.
///
private bool RootBeginPending
{
get
{
return GetFlag(ClockFlags.RootBeginPending);
}
set
{
SetFlag(ClockFlags.RootBeginPending, value);
}
}
#endregion // Private Properties
//
// Nested Types
//
#region Nested Types
[Flags]
private enum ClockFlags : uint
{
IsTimeManager = 1 << 0,
IsRoot = 1 << 1,
IsBackwardsProgressingGlobal = 1 << 2,
IsInteractivelyPaused = 1 << 3,
IsInteractivelyStopped = 1 << 4,
PendingInteractivePause = 1 << 5,
PendingInteractiveResume = 1 << 6,
PendingInteractiveStop = 1 << 7,
PendingInteractiveRemove = 1 << 8,
CanGrow = 1 << 9,
CanSlip = 1 << 10,
CurrentStateInvalidatedEventRaised = 1 << 11,
CurrentTimeInvalidatedEventRaised = 1 << 12,
CurrentGlobalSpeedInvalidatedEventRaised = 1 << 13,
CompletedEventRaised = 1 << 14,
RemoveRequestedEventRaised = 1 << 15,
IsInEventQueue = 1 << 16,
NeedsTicksWhenActive = 1 << 17,
NeedsPostfixTraversal = 1 << 18,
PauseStateChangedDuringTick = 1 << 19,
RootBeginPending = 1 << 20,
HasControllableRoot = 1 << 21,
HasResolvedDuration = 1 << 22,
HasDesiredFrameRate = 1 << 23,
HasDiscontinuousTimeMovementOccured = 1 << 24,
HasDescendantsWithUnresolvedDuration = 1 << 25,
HasSeekOccuredAfterLastTick = 1 << 26,
}
///
/// The result of a ResolveTimes method call.
///
private enum ResolveCode
{
///
/// Nothing changed in resolving new times.
///
NoChanges,
///
/// Resolved times are different than before.
///
NewTimes,
///
/// The children of this timeline need a full reset time resolution. This flag
/// indicates that a partial resolution needs to be prunned at the current
/// timeline in favor of a full resolution for its children.
///
NeedNewChildResolve
}
///
/// Implements a finalizer for a clock subtree.
///
private class SubtreeFinalizer
{
///
/// Creates a finalizer for a clock subtree.
///
internal SubtreeFinalizer(TimeManager timeManager)
{
_timeManager = timeManager;
}
///
/// Finalizes a clock subtree.
///
~SubtreeFinalizer()
{
#pragma warning disable 1634, 1691
#pragma warning suppress 6525
_timeManager.ScheduleClockCleanup();
}
private TimeManager _timeManager;
}
///
/// Holds [....]-related data when it is applicable
///
internal class SyncData
{
internal SyncData(Clock syncClock)
{
Debug.Assert(syncClock != null);
Debug.Assert(syncClock.GetCanSlip());
Debug.Assert(syncClock.IsRoot || syncClock._timeline.BeginTime.HasValue); // Only roots may later validate their _beginTime
_syncClock = syncClock;
UpdateClockBeginTime(); // This will update the remaining dependencies
}
// This method should be invoked anytime we invalidate the SyncClock's _beginTime only
internal void UpdateClockBeginTime()
{
//
_syncClockBeginTime = _syncClock._beginTime;
_syncClockSpeedRatio = _syncClock._appliedSpeedRatio;
_syncClockResolvedDuration = SyncClockResolvedDuration; // This is to detect media finding its true duration
}
internal Clock SyncClock
{
get { return _syncClock; }
}
internal Duration SyncClockResolvedDuration
{
get
{
// Duration can only change its value while it is Automatic
if (!_syncClockResolvedDuration.HasTimeSpan)
{
_syncClockEffectiveDuration = _syncClock.ComputeEffectiveDuration(); // null == infinity
_syncClockResolvedDuration = _syncClock._resolvedDuration;
}
return _syncClockResolvedDuration;
}
}
internal bool SyncClockHasReachedEffectiveDuration
{
get
{
if (_syncClockEffectiveDuration.HasValue) // If the [....] clock has a finite duration
{
return (_previousRepeatTime + _syncClock.GetCurrentTimeCore() >= _syncClockEffectiveDuration.Value);
}
else
{
return false;
}
}
}
// NOTE: This value is in SyncNode coordinates, not its parent's coordinates
internal TimeSpan? SyncClockEffectiveDuration
{
get { return _syncClockEffectiveDuration; }
}
internal double SyncClockSpeedRatio
{
get { return _syncClockSpeedRatio; }
}
internal bool IsInSyncPeriod
{
get { return _isInSyncPeriod; }
set { _isInSyncPeriod = value; }
}
internal bool SyncClockDiscontinuousEvent
{
get { return _syncClockDiscontinuousEvent; }
set { _syncClockDiscontinuousEvent = value; }
}
internal TimeSpan PreviousSyncClockTime
{
get { return _previousSyncClockTime; }
set { _previousSyncClockTime = value; }
}
internal TimeSpan PreviousRepeatTime
{
get { return _previousRepeatTime; }
set { _previousRepeatTime = value; }
}
internal TimeSpan SyncClockBeginTime
{
get
{
Debug.Assert(_syncClockBeginTime.HasValue); // This should never be queried on a root without beginTime
return _syncClockBeginTime.Value;
}
}
private Clock _syncClock;
private double _syncClockSpeedRatio;
private bool _isInSyncPeriod, _syncClockDiscontinuousEvent;
private Duration _syncClockResolvedDuration = Duration.Automatic; // Duration -- *local* coordinates
private TimeSpan? _syncClockEffectiveDuration; // This reflects RepeatBehavior (local coordinates)
private TimeSpan? _syncClockBeginTime;
private TimeSpan _previousSyncClockTime;
private TimeSpan _previousRepeatTime; // How many complete iterations we already have done
}
///
/// Holds data specific to root clocks.
///
internal class RootData
{
internal RootData()
{
}
internal TimeSpan CurrentAdjustedGlobalTime
{
get { return _currentAdjustedGlobalTime; }
set { _currentAdjustedGlobalTime = value; }
}
internal Int32 DesiredFrameRate
{
get { return _desiredFrameRate; }
set { _desiredFrameRate = value; }
}
internal Double InteractiveSpeedRatio
{
get { return _interactiveSpeedRatio; }
set { _interactiveSpeedRatio = value; }
}
internal TimeSpan LastAdjustedGlobalTime
{
get { return _lastAdjustedGlobalTime; }
set { _lastAdjustedGlobalTime = value; }
}
///
/// The time to which we want to seek this timeline at the next tick
///
internal TimeSpan? PendingSeekDestination
{
get { return _pendingSeekDestination; }
set { _pendingSeekDestination = value; }
}
internal Double? PendingSpeedRatio
{
get { return _pendingSpeedRatio; }
set { _pendingSpeedRatio = value; }
}
private Int32 _desiredFrameRate;
private double _interactiveSpeedRatio = 1.0;
private double? _pendingSpeedRatio;
private TimeSpan _currentAdjustedGlobalTime;
private TimeSpan _lastAdjustedGlobalTime;
private TimeSpan? _pendingSeekDestination;
}
#endregion // Nested Types
//
// Debugging Instrumentation
//
#region Debugging instrumentation
///
/// Debug-only method to verify that the recomputed input time
/// is close to the original. See ComputeCurrentIteration
///
/// original input time
/// input time without rounding errors
[Conditional("DEBUG")]
private void Debug_VerifyOffsetFromBegin(long inputTime, long optimizedInputTime)
{
long error = (long)Math.Max(_appliedSpeedRatio, 1.0);
// Assert the computed inputTime is very close to the original.
// _appliedSpeedRatio is the upper bound of the error (in Ticks) caused by the
// calculation of inputTime. The reason is that we truncate (floor) during the
// computation of EffectiveDuration, losing up to 0.99999.... off the number.
// The computation of inputTime multiplies the truncated value by _appliedSpeedRatio,
// so _appliedSpeedRatio is guaranteed to be close to but higher than the actual error.
Debug.Assert(Math.Abs(optimizedInputTime - inputTime) <= error,
"This optimized inputTime does not match the original - did the calculation of inputTime change?");
}
#if DEBUG
///
/// Dumps the description of the subtree rooted at this clock.
///
internal void Dump()
{
System.Text.StringBuilder builder = new System.Text.StringBuilder();
builder.Capacity = 1024;
builder.Append("======================================================================\n");
builder.Append("Clocks rooted at Clock ");
builder.Append(_debugIdentity);
builder.Append('\n');
builder.Append("----------------------------------------------------------------------\n");
builder.Append("Flags LastBegin LastEnd NextBegin NextEnd Name\n");
builder.Append("----------------------------------------------------------------------\n");
if (IsTimeManager)
{
RootBuildInfoRecursive(builder);
}
else
{
BuildInfoRecursive(builder, 0);
}
builder.Append("----------------------------------------------------------------------\n");
Trace.Write(builder.ToString());
}
///
/// Dumps the description of all clocks in the known clock table.
///
internal static void DumpAll()
{
System.Text.StringBuilder builder = new System.Text.StringBuilder();
int clockCount = 0;
builder.Capacity = 1024;
builder.Append("======================================================================\n");
builder.Append("Clocks in the GC heap\n");
builder.Append("----------------------------------------------------------------------\n");
builder.Append("Flags LastBegin LastEnd NextBegin NextEnd Name\n");
builder.Append("----------------------------------------------------------------------\n");
lock (_debugLockObject)
{
if (_objectTable.Count > 0)
{
// Output the clocks sorted by ID
int[] idTable = new int[_objectTable.Count];
_objectTable.Keys.CopyTo(idTable, 0);
Array.Sort(idTable);
for (int index = 0; index < idTable.Length; index++)
{
WeakReference weakRef = (WeakReference)_objectTable[idTable[index]];
Clock clock = (Clock)weakRef.Target;
if (clock != null)
{
clock.BuildInfo(builder, 0, true);
clockCount++;
}
}
}
}
if (clockCount == 0)
{
builder.Append("There are no Clocks in the GC heap.\n");
}
builder.Append("----------------------------------------------------------------------\n");
Trace.Write(builder.ToString());
}
///
/// Dumps the description of the subtree rooted at this clock.
///
///
/// A StringBuilder that accumulates the description text.
///
///
/// The depth of recursion for this clock.
///
// Normally a virtual method would be implemented for the dervied class
// to handle the children property, but the asmmeta would be different
// since this is only availabe in a debug build. For this reason we're
// handling the children in the base class.
internal void BuildInfoRecursive(System.Text.StringBuilder builder, int depth)
{
// Add the info for this clock
BuildInfo(builder, depth, false);
// Recurse into the children
ClockGroup thisGroup = this as ClockGroup;
if (thisGroup != null)
{
depth++;
List children = thisGroup.InternalChildren;
if (children != null)
{
for (int childIndex = 0; childIndex < children.Count; childIndex++)
{
children[childIndex].BuildInfoRecursive(builder, depth);
}
}
}
}
///
/// Dumps the description of the subtree rooted at this root clock.
///
///
/// A StringBuilder that accumulates the description text.
///
internal void RootBuildInfoRecursive(System.Text.StringBuilder builder)
{
// Add the info for this clock
BuildInfo(builder, 0, false);
// Recurse into the children. Don't use the enumerator because
// that would remove dead references, which would be an undesirable
// side-effect for a debug output method.
List children = ((ClockGroup) this).InternalRootChildren;
for (int index = 0; index < children.Count; index++)
{
Clock child = (Clock)children[index].Target;
if (child != null)
{
child.BuildInfoRecursive(builder, 1);
}
}
}
///
/// Dumps the description of this clock.
///
///
/// A StringBuilder that accumulates the description text.
///
///
/// The depth of recursion for this clock.
///
///
/// True to dump the ID of the parent clock, false otherwise.
///
internal void BuildInfo(System.Text.StringBuilder builder, int depth, bool includeParentID)
{
builder.Append(depth);
builder.Append(GetType().Name);
builder.Append(' ');
builder.Append(_debugIdentity);
builder.Append(' ');
_timeline.BuildInfo(builder, 0, false);
}
///
/// Finds a previously registered object.
///
///
/// The ID of the object to look for
///
///
/// The object if found, null otherwise.
///
internal static Clock Find(int id)
{
Clock clock = null;
lock (_debugLockObject)
{
object handleReference = _objectTable[id];
if (handleReference != null)
{
WeakReference weakRef = (WeakReference)handleReference;
clock = (Clock)weakRef.Target;
if (clock == null)
{
// Object has been destroyed, so remove the weakRef.
_objectTable.Remove(id);
}
}
}
return clock;
}
///
/// Cleans up the known timeline clocks table by removing dead weak
/// references.
///
internal static void CleanKnownClocksTable()
{
lock (_debugLockObject)
{
Hashtable removeTable = new Hashtable();
// Identify dead references
foreach (DictionaryEntry e in _objectTable)
{
WeakReference weakRef = (WeakReference) e.Value;
if (weakRef.Target == null)
{
removeTable[e.Key] = weakRef;
}
}
// Remove dead references
foreach (DictionaryEntry e in removeTable)
{
_objectTable.Remove(e.Key);
}
}
}
#endif // DEBUG
#endregion // Debugging instrumentation
//
// Data
//
#region Data
private ClockFlags _flags;
private int? _currentIteration; // Precalculated current iteration
private double? _currentProgress; // Precalculated current progress value
private double? _currentGlobalSpeed; // Precalculated current global speed value
private TimeSpan? _currentTime; // Precalculated current global time
private ClockState _currentClockState; // Precalculated current clock state
private RootData _rootData = null; // Keeps track of root-related data for DesiredFrameRate
internal SyncData _syncData = null; // Keeps track of [....]-related data for SlipBehavior
// Stores the clock's begin time as an offset from the clock's
// parent's begin time (i.e. a begin time of 2 sec means begin
// 2 seconds afer the parent starts). For non-root clocks this
// is always the same as its timeline's begin time.
// For root clocks, the begin time is adjusted in response to seeks,
// pauses, etc (see AdjustBeginTime())
//
// This must be null when the clock is stopped.
internal TimeSpan? _beginTime;
// This is only used for repeating timelines which have CanSlip children/descendants;
// In this case, we use this variable instead of _beginTime to compute the current state
// of the clock (in conjunction with _currentIteration, so we know how many we have
// already completed.) This makes us agnostic to slip/growth in our past iterations.
private TimeSpan? _currentIterationBeginTime;
// How soon this Clock needs another tick
internal TimeSpan? _nextTickNeededTime = null;
private WeakReference _weakReference;
private SubtreeFinalizer _subtreeFinalizer;
private EventHandlersStore _eventHandlersStore;
///
/// Cache Duration for perf reasons and also to accommodate one time
/// only resolution of natural duration.
/// If Timeline.Duration is Duration.Automatic, we will at first treat
/// this as Duration.Forever, but will periodically ask what the resolved
/// duration is. Once we receive an answer, that will be the duration
/// used from then on, and we won't ask again.
/// Otherwise, this will be set to Timeline.Duration when the Clock is
/// created and won't change.
///
internal Duration _resolvedDuration;
///
/// This is a cached estimated duration of the current iteration of this clock.
/// For clocks which return false to CanGrow, this should always equal the
/// _resolvedDuration. However, for clocks with CanGrow, this may change from
/// tick to tick. Based on how far we are in the present iteration, and how
/// on track our slipping children are, we make estimates of when we will finish
/// the iteration, which are reflected by our estimated _currentDuration.
///
internal Duration _currentDuration;
///
/// For a root, this is the Timeline's speed ratio multiplied by the
/// interactive speed ratio. It's updated whenever the interactive speed
/// ratio is updated. If the interactive speed ratio is 0, we'll use the
/// Timeline's speed ratio, that is, treat interactive speed ratio as 1.
/// This is why this is "applied" speed ratio.
///
/// For a non-root, this is just a cache for the Timeline's speed ratio.
///
private Double _appliedSpeedRatio;
#region Linking data
internal Timeline _timeline;
internal TimeManager _timeManager;
internal ClockGroup _parent; // Parents can only be ClockGroups since
// they're the only ones having children
internal int _childIndex;
internal int _depth;
static Int64 s_TimeSpanTicksPerSecond = TimeSpan.FromSeconds(1).Ticks;
#endregion // Linking data
#region Debug data
#if DEBUG
internal int _debugIdentity;
internal static int _nextIdentity;
internal static Hashtable _objectTable = new Hashtable();
internal static object _debugLockObject = new object();
#endif // DEBUG
#endregion // Debug data
#endregion // Data
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------------------------
// Microsoft Windows Client Platform
// Copyright (c) Microsoft Corporation, 2003
//
// File: Clock.cs
//-----------------------------------------------------------------------------
#if DEBUG
#define TRACE
#endif // DEBUG
using MS.Internal;
using MS.Utility;
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Windows;
using System.Windows.Media.Composition;
using System.Windows.Markup;
using System.Windows.Threading;
using SR=MS.Internal.PresentationCore.SR;
using SRID=MS.Internal.PresentationCore.SRID;
namespace System.Windows.Media.Animation
{
///
/// Maintains run-time timing state for timed objects.
///
///
/// A Clock object maintains the run-time state for a timed object
/// according to the description specified in a Timeline object. It also
/// provides methods for timing control, such as event scheduling and
/// VCR-like functionality. Clock objects are arranged in trees
/// that match the structure of the Timeline objects they are created from.
///
public class Clock : DispatcherObject
{
//
// Constructors
//
#region Constructors
///
/// Creates a Clock object.
///
///
/// The Timeline to use as a template.
///
///
/// The returned Clock doesn't have any children.
///
protected internal Clock(Timeline timeline)
{
#if DEBUG
lock (_debugLockObject)
{
_debugIdentity = ++_nextIdentity;
WeakReference weakRef = new WeakReference(this);
_objectTable[_debugIdentity] = weakRef;
}
#endif // DEBUG
Debug.Assert(timeline != null);
//
// Store a frozen copy of the timeline
//
_timeline = (Timeline)timeline.GetCurrentValueAsFrozen();
// GetCurrentValueAsFrozen will make a clone of the Timeline if it's
// not frozen and will return the Timeline if it is frozen.
// The clone will never have event handlers, while the
// frozen original may. This means we need to copy
// the event handlers from the original timeline onto the clock
// to be consistent.
//
// Copy the event handlers from the original timeline into the clock
//
_eventHandlersStore = timeline.InternalEventHandlersStore;
//
// FXCop fix. Do not call overridables in constructors
// UpdateNeedsTicksWhenActive();
// Set the NeedsTicksWhenActive only if we have someone listening
// to an event.
SetFlag(ClockFlags.NeedsTicksWhenActive, _eventHandlersStore != null);
//
// Cache values that won't change as the clock ticks
//
// Non-root clocks have an unchanging begin time specified by their timelines.
// A root clock will update _beginTime as necessary.
_beginTime = _timeline.BeginTime;
// Cache duration, getting Timeline.Duration and recalculating duration
// each Tick was eating perf, resolve the duration if possible.
_resolvedDuration = _timeline.Duration;
if (_resolvedDuration == Duration.Automatic)
{
// Forever is the default for an automatic duration. We can't
// try to resolve the duration yet because the tree
// may not be fully built, in which case ClockGroups won't
// have their children yet.
_resolvedDuration = Duration.Forever;
}
else
{
HasResolvedDuration = true;
}
_currentDuration = _resolvedDuration;
// Cache speed ratio, for roots this value may be updated if the interactive
// speed ratio changes, but for non-roots this value will remain constant
// throughout the lifetime of the clock.
_appliedSpeedRatio = _timeline.SpeedRatio;
//
// Initialize current state
//
_currentClockState = ClockState.Stopped;
if (_beginTime.HasValue)
{
// We need a tick to bring our state up to date
_nextTickNeededTime = TimeSpan.Zero;
}
// All other data members initialized to zero by default
}
#endregion // Constructors
//
// Public Properties
//
#region Public Properties
internal bool CanGrow
{
get
{
return GetFlag(ClockFlags.CanGrow);
}
}
internal bool CanSlip
{
get
{
return GetFlag(ClockFlags.CanSlip);
}
}
///
/// Returns an ClockController which can be used to perform interactive
/// operations on this Clock. If interactive operations are not allowed,
/// this property returns null; this is the case for Clocks that
/// aren't children of the root Clock.
///
public ClockController Controller
{
get
{
Debug.Assert(!IsTimeManager);
// Unless our parent is the root clock and we're controllable,
// return null
if (IsRoot && HasControllableRoot)
{
return new ClockController(this);
}
else
{
return null;
}
}
}
///
/// The current repeat iteration. The first period has a value of one.
///
///
/// If the clock is not active, the value of this property is only valid if
/// the fill attribute specifies that the timing attributes should be
/// extended. Otherwise, the property returns -1.
///
public Int32? CurrentIteration
{
get
{
// VerifyAccess();
Debug.Assert(!IsTimeManager);
return _currentIteration;
}
}
///
/// Gets the current rate at which time is progressing in the clock,
/// compared to the real-world wall clock. If the clock is stopped,
/// this method returns null.
///
///
/// The current progress of time for this clock.
///
///
/// If the clock is active, the progress is always a value between 0 and 1,
/// inclusive. Otherwise, the progress depends on the value of the
///
public double? CurrentProgress
{
get
{
// VerifyAccess();
Debug.Assert(!IsTimeManager);
return _currentProgress;
}
}
///
/// Gets a value indicating whether the Clock’s current time is inside the Active period
/// (meaning properties may change frame to frame), inside the Fill period, or Stopped.
///
///
/// You can tell whether you’re in FillBegin or FillEnd by the value of CurrentProgress
/// (0 for FillBegin, 1 for FillEnd).
///
public ClockState CurrentState
{
get
{
// VerifyAccess();
return _currentClockState;
}
}
///
/// The current position of the clock, relative to the starting time. Setting
/// this property to a new value has the effect of seeking the clock to a
/// new point in time. Both forward and backward seeks are allowed. Setting this
/// property has no effect if the clock is not active. However, seeking while the
/// clock is paused works as expected.
///
public TimeSpan? CurrentTime
{
get
{
// VerifyAccess();
Debug.Assert(!IsTimeManager);
return _currentTime;
}
}
///
///
///
public bool HasControllableRoot
{
get
{
Debug.Assert(!IsTimeManager);
return GetFlag(ClockFlags.HasControllableRoot);
}
}
///
/// True if the timeline is currently paused, false otherwise.
///
///
/// This property returns true either if this timeline has been paused, or if an
/// ancestor of this timeline has been paused.
///
public bool IsPaused
{
get
{
// VerifyAccess();
Debug.Assert(!IsTimeManager);
return IsInteractivelyPaused;
}
}
///
/// Returns the natural duration of this Clock, which is defined
/// by the Timeline from which it is created.
///
///
/// The Clock that sets the parent time for this Clock.
///
public Clock Parent
{
get
{
// VerifyAccess();
Debug.Assert(!IsTimeManager);
// If our parent is the root clock, force a return value of null
if (IsRoot)
{
return null;
}
else
{
return _parent;
}
}
}
///
/// Gets the Timeline object that holds the description controlling the
/// behavior of this clock.
///
///
/// The Timeline object that holds the description controlling the
/// behavior of this clock.
///
public Timeline Timeline
{
get
{
// VerifyAccess();
Debug.Assert(!IsTimeManager);
return _timeline;
}
}
#endregion // Public Properties
//
// Public Events
//
#region Public Events
///
/// Raised by the timeline when it has completed.
///
public event EventHandler Completed
{
add
{
AddEventHandler(Timeline.CompletedKey, value);
}
remove
{
RemoveEventHandler(Timeline.CompletedKey, value);
}
}
///
/// Raised by the Clock whenever its current speed changes.
/// This event mirrors the CurrentGlobalSpeedInvalidated event on Timeline
///
public event EventHandler CurrentGlobalSpeedInvalidated
{
add
{
// VerifyAccess();
AddEventHandler(Timeline.CurrentGlobalSpeedInvalidatedKey, value);
}
remove
{
// VerifyAccess();
RemoveEventHandler(Timeline.CurrentGlobalSpeedInvalidatedKey, value);
}
}
///
/// Raised by the Clock whenever its current state changes.
/// This event mirrors the CurrentStateInvalidated event on Timeline
///
public event EventHandler CurrentStateInvalidated
{
add
{
// VerifyAccess();
AddEventHandler(Timeline.CurrentStateInvalidatedKey, value);
}
remove
{
// VerifyAccess();
RemoveEventHandler(Timeline.CurrentStateInvalidatedKey, value);
}
}
///
/// Raised by the Clock whenever its current time changes.
/// This event mirrors the CurrentTimeInvalidated event on Timeline
///
public event EventHandler CurrentTimeInvalidated
{
add
{
// VerifyAccess();
AddEventHandler(Timeline.CurrentTimeInvalidatedKey, value);
}
remove
{
// VerifyAccess();
RemoveEventHandler(Timeline.CurrentTimeInvalidatedKey, value);
}
}
///
/// Raised by the timeline when its removal has been requested by the user.
///
public event EventHandler RemoveRequested
{
add
{
AddEventHandler(Timeline.RemoveRequestedKey, value);
}
remove
{
RemoveEventHandler(Timeline.RemoveRequestedKey, value);
}
}
#endregion // Public Events
//
// Protected Methods
//
#region Protected Methods
///
/// Notify a clock that we've moved in a discontinuous way
///
protected virtual void DiscontinuousTimeMovement()
{
// Base class does nothing
}
///
/// Returns true if the Clock has its own external source for time, which may
/// require synchronization with the timing system. Media is one example of this.
///
protected virtual bool GetCanSlip()
{
return false;
}
///
///
///
protected virtual TimeSpan GetCurrentTimeCore()
{
Debug.Assert(!IsTimeManager);
return _currentTime.HasValue ? _currentTime.Value : TimeSpan.Zero;
}
///
/// Notify a clock that we've changed the speed
///
protected virtual void SpeedChanged()
{
// Base class does nothing
}
///
/// Notify a clock that we've stopped
///
protected virtual void Stopped()
{
// Base class does nothing
}
#endregion // Protected Methods
//
// Protected Properties
//
#region Protected Properties
///
/// The current global time in TimeSpan units, established by the time manager.
///
protected TimeSpan CurrentGlobalTime
{
get
{
if (_timeManager == null)
{
return TimeSpan.Zero;
}
else if (IsTimeManager)
{
return _timeManager.InternalCurrentGlobalTime;
}
else
{
Clock current = this;
while (!current.IsRoot) // Traverse up the tree to the root node
{
current = current._parent;
}
if (current.HasDesiredFrameRate)
{
return current._rootData.CurrentAdjustedGlobalTime;
}
else
{
return _timeManager.InternalCurrentGlobalTime;
}
}
}
}
#endregion // Protected Properties
//
// Internal Methods
//
#region Internal Methods
internal virtual void AddNullPointToCurrentIntervals()
{
}
internal static Clock AllocateClock(
Timeline timeline,
bool hasControllableRoot)
{
Clock clock = timeline.AllocateClock();
// Assert that we weren't given an existing clock
Debug.Assert(!clock.IsTimeManager);
ClockGroup clockGroup = clock as ClockGroup;
if ( clock._parent != null
|| ( clockGroup != null
&& clockGroup.InternalChildren != null ))
{
// The derived class is trying to fool us -- we require a new,
// fresh, unassociated clock here
throw new InvalidOperationException(
SR.Get(
SRID.Timing_CreateClockMustReturnNewClock,
timeline.GetType().Name));
}
clock.SetFlag(ClockFlags.HasControllableRoot, hasControllableRoot);
return clock;
}
internal virtual void BuildClockSubTreeFromTimeline(
Timeline timeline,
bool hasControllableRoot)
{
SetFlag(ClockFlags.CanSlip, GetCanSlip()); // Set the CanSlip flag
// Here we preview the clock's own slip-ability, hence ClockGroups should return false
// at this stage, because their children are not yet added by the time of this call.
if (CanSlip && (IsRoot || _timeline.BeginTime.HasValue))
{
ResolveDuration();
// A [....] clock with duration of zero or no begin time has no effect, so do skip it
if (!_resolvedDuration.HasTimeSpan || _resolvedDuration.TimeSpan > TimeSpan.Zero)
{
// Verify that we only use SlipBehavior in supported scenarios
if ((_timeline.AutoReverse == true) ||
(_timeline.AccelerationRatio > 0) ||
(_timeline.DecelerationRatio > 0))
{
throw new NotSupportedException(SR.Get(SRID.Timing_CanSlipOnlyOnSimpleTimelines));
}
_syncData = new SyncData(this); // CanSlip clocks keep themselves synced
HasDescendantsWithUnresolvedDuration = !HasResolvedDuration; // Keep track of when our duration is resolved
Clock current = _parent; // Traverse up the parent chain and verify that no unsupported behavior is specified
while (current != null)
{
Debug.Assert(!current.IsTimeManager); // We should not yet be connected to the TimeManager
if (current._timeline.AutoReverse || current._timeline.AccelerationRatio > 0
|| current._timeline.DecelerationRatio > 0)
{
throw new System.InvalidOperationException(SR.Get(SRID.Timing_SlipBehavior_SyncOnlyWithSimpleParents));
}
current.SetFlag(ClockFlags.CanGrow, true); // Propagate the slippage tracking up the tree
if (!HasResolvedDuration) // Let the parents know that we have not yet unresolved duration
{
current.HasDescendantsWithUnresolvedDuration = true;
}
current._currentIterationBeginTime = current._beginTime;
current = current._parent;
}
}
}
}
internal static Clock BuildClockTreeFromTimeline(
Timeline rootTimeline,
bool hasControllableRoot)
{
Clock rootClock = AllocateClock(rootTimeline, hasControllableRoot);
// Set this flag so that the subsequent method can rely on it.
rootClock.IsRoot = true;
rootClock._rootData = new RootData(); // Create a RootData to hold root specific information.
// The root clock was given a reference to a frozen copy of the
// timing tree. We pass this copy down BuildClockSubTreeFromTimeline
// so that each child clock will use that tree rather
// than create a new one.
rootClock.BuildClockSubTreeFromTimeline(rootClock.Timeline, hasControllableRoot);
rootClock.AddToTimeManager();
return rootClock;
}
internal virtual void ClearCurrentIntervalsToNull()
{
}
// Perform Stage 1 of clipping next tick time: clip by parent
internal void ClipNextTickByParent()
{
// Clip by parent's NTNT if needed. We don't want to clip
// if the parent is the TimeManager's root clock.
if (!IsTimeManager && !_parent.IsTimeManager &&
(!InternalNextTickNeededTime.HasValue ||
(_parent.InternalNextTickNeededTime.HasValue && _parent.InternalNextTickNeededTime.Value < InternalNextTickNeededTime.Value)))
{
InternalNextTickNeededTime = _parent.InternalNextTickNeededTime;
}
}
internal virtual void ComputeCurrentIntervals(TimeIntervalCollection parentIntervalCollection,
TimeSpan beginTime, TimeSpan? endTime,
Duration fillDuration, Duration period,
double appliedSpeedRatio, double accelRatio, double decelRatio,
bool isAutoReversed)
{
}
internal virtual void ComputeCurrentFillInterval(TimeIntervalCollection parentIntervalCollection,
TimeSpan beginTime, TimeSpan endTime, Duration period,
double appliedSpeedRatio, double accelRatio, double decelRatio,
bool isAutoReversed)
{
}
internal void ComputeLocalState()
{
Debug.Assert(!IsTimeManager);
// Cache previous state values
ClockState lastClockState = _currentClockState;
TimeSpan? lastCurrentTime = _currentTime;
double? lastCurrentGlobalSpeed = _currentGlobalSpeed;
double? lastCurrentProgress = _currentProgress;
Int32? lastCurrentIteration = _currentIteration;
// Reset the PauseStateChangedDuringTick for this tick
PauseStateChangedDuringTick = false;
ComputeLocalStateHelper(true, false); // Perform the local state calculations with early bail out
if (lastClockState != _currentClockState)
{
// It can happen that we change state without detecting it when
// a parent is auto-reversing and we are ticking exactly at the
// reverse point, so raise the events.
RaiseCurrentStateInvalidated();
RaiseCurrentGlobalSpeedInvalidated();
RaiseCurrentTimeInvalidated();
}
//
if (_currentGlobalSpeed != lastCurrentGlobalSpeed)
{
RaiseCurrentGlobalSpeedInvalidated();
}
if (HasDiscontinuousTimeMovementOccured)
{
DiscontinuousTimeMovement();
HasDiscontinuousTimeMovementOccured = false;
}
}
///
/// Return the current duration from a specific clock
///
///
/// A Duration quantity representing the current iteration's estimated duration.
///
internal virtual Duration CurrentDuration
{
get { return Duration.Automatic; }
}
///
/// Internal helper. Schedules an interactive begin at the next tick.
/// An interactive begin is literally a seek to 0. It is completely distinct
/// from the BeginTime specified on a timeline, which is managed by
/// _pendingBeginOffset
///
internal void InternalBegin()
{
InternalSeek(TimeSpan.Zero);
}
///
/// Internal helper for moving to new API. Gets the speed multiplier for the Clock's speed.
///
internal double InternalGetSpeedRatio()
{
return _rootData.InteractiveSpeedRatio;
}
///
/// Internal helper for moving to new API. Pauses the timeline for this timeline and its children.
///
internal void InternalPause()
{
// VerifyAccess();
Debug.Assert(!IsTimeManager);
// INVARIANT: we enforce 4 possible valid states:
// 1) !Paused (running)
// 2) !Paused, Pause pending
// 3) Paused
// 4) Paused, Resume pending
Debug.Assert(!(IsInteractivelyPaused && PendingInteractivePause));
Debug.Assert(!(!IsInteractivelyPaused && PendingInteractiveResume));
if (PendingInteractiveResume) // Cancel existing resume request if made
{
PendingInteractiveResume = false;
}
else if (!IsInteractivelyPaused)
// If we don't have a pending resume AND we aren't paused already, schedule a pause
// This is an ELSE clause because if we had a Resume pending, we MUST already be paused
{
PendingInteractivePause = true;
}
NotifyNewEarliestFutureActivity();
}
///
/// Schedules a Remove operation to happen at the next tick.
///
///
/// This method schedules the Clock and its subtree to be stopped and the RemoveRequested
/// event to be fired on the subtree at the next tick.
///
internal void InternalRemove()
{
PendingInteractiveRemove = true;
InternalStop();
}
///
/// Internal helper for moving to new API. Allows a timeline's timeline to progress again after a call to Pause.
///
internal void InternalResume()
{
// VerifyAccess();
Debug.Assert(!IsTimeManager);
// INVARIANT: we enforce 4 possible valid states:
// 1) !Paused (running)
// 2) !Paused, Pause pending
// 3) Paused
// 4) Paused, sd Resume pending
Debug.Assert( !(IsInteractivelyPaused && PendingInteractivePause));
Debug.Assert( !(!IsInteractivelyPaused && PendingInteractiveResume));
if (PendingInteractivePause) // Cancel existing pause request if made
{
PendingInteractivePause = false;
}
else if (IsInteractivelyPaused)
// If we don't have a pending pause AND we are currently paused, schedule a resume
// This is an ELSE clause because if we had a Pause pending, we MUST already be unpaused
{
PendingInteractiveResume = true;
}
NotifyNewEarliestFutureActivity();
}
///
/// Internal helper for moving to new API. Seeks a timeline's timeline to a new position.
///
///
/// The destination to seek to, relative to the clock's BeginTime. If this is past the
/// active period execute the FillBehavior.
///
internal void InternalSeek(TimeSpan destination)
{
// VerifyAccess();
Debug.Assert(IsRoot);
IsInteractivelyStopped = false;
PendingInteractiveStop = false; // Cancel preceding stop;
ResetNodesWithSlip(); // Reset [....] tracking
_rootData.PendingSeekDestination = destination;
RootBeginPending = false; // cancel a previous begin call
NotifyNewEarliestFutureActivity();
}
///
/// The only things that can change for this are the begin time of this
/// timeline
///
///
/// The destination to seek to, relative to the clock's BeginTime. If this is past the
/// active perioed execute the FillBehavior.
///
internal void InternalSeekAlignedToLastTick(TimeSpan destination)
{
Debug.Assert(IsRoot);
// This is a no-op with a null TimeManager or when all durations have not yet been resolved
if (_timeManager == null || HasDescendantsWithUnresolvedDuration)
{
return;
}
// Adjust _beginTime such that our current time equals the Seek position
// that was requested
_beginTime = CurrentGlobalTime - DivideTimeSpan(destination, _appliedSpeedRatio);
if (CanGrow)
{
_currentIteration = null; // This node is not visited by ResetSlipOnSubtree
_currentIterationBeginTime = _beginTime;
ResetSlipOnSubtree();
UpdateSyncBeginTime();
}
IsInteractivelyStopped = false; // We have unset disabled status
PendingInteractiveStop = false;
RootBeginPending = false; // Cancel a pending begin
ResetNodesWithSlip(); // Reset [....] tracking
_timeManager.InternalCurrentIntervals = TimeIntervalCollection.Empty;
PrefixSubtreeEnumerator subtree = new PrefixSubtreeEnumerator(this, true);
while (subtree.MoveNext())
{
// We are processing a Seek immediately. We don't need a TIC yet
// since we are not computing events, and we don't want to
// process pending stuff either.
subtree.Current.ComputeLocalStateHelper(false, true); // Compute the state of the node
if (HasDiscontinuousTimeMovementOccured)
{
DiscontinuousTimeMovement();
HasDiscontinuousTimeMovementOccured = false;
}
subtree.Current.ClipNextTickByParent(); // Perform NextTick clipping, stage 1
// Make a note to visit for stage 2, only for ClockGroups
subtree.Current.NeedsPostfixTraversal = (subtree.Current is ClockGroup);
}
_parent.ComputeTreeStateRoot(); // Re-clip the next tick estimates by children
// Fire the events indicating that we've invalidated this whole subtree
subtree.Reset();
while (subtree.MoveNext())
{
// CurrentTimeInvalidated should be fired first to give AnimationStorage a chance
// to update the value. We directly set the flags, then fire RaiseAccumulatedEvents
// to avoid involving the TimeManager for this local subtree operation.
subtree.Current.CurrentTimeInvalidatedEventRaised = true;
subtree.Current.CurrentStateInvalidatedEventRaised = true;
subtree.Current.CurrentGlobalSpeedInvalidatedEventRaised = true;
subtree.Current.RaiseAccumulatedEvents();
}
}
///
/// Internal helper for moving to new API. Sets a speed multiplier for the Clock's speed.
///
///
/// The ratio by which to multiply the Clock's speed.
///
internal void InternalSetSpeedRatio(double ratio)
{
Debug.Assert(IsRoot);
_rootData.PendingSpeedRatio = ratio;
}
///
/// Internal helper. Schedules an end for some specified time in the future.
///
internal void InternalSkipToFill()
{
Debug.Assert(IsRoot);
TimeSpan? effectiveDuration;
effectiveDuration = ComputeEffectiveDuration();
// Throw an exception if the active period extends forever.
if (effectiveDuration == null)
{
// Can't seek to the end if the simple duration is not resolved
throw new InvalidOperationException(SR.Get(SRID.Timing_SkipToFillDestinationIndefinite));
}
// Offset to the end; override preceding seek requests
IsInteractivelyStopped = false;
PendingInteractiveStop = false;
ResetNodesWithSlip(); // Reset [....] tracking
RootBeginPending = false;
_rootData.PendingSeekDestination = effectiveDuration.Value; // Seek to the end time
NotifyNewEarliestFutureActivity();
}
///
/// Internal helper for moving to new API. Removes a timeline from its active or fill period.
/// Timeline can be restarted with an interactive Begin call.
///
internal void InternalStop()
{
Debug.Assert(IsRoot);
PendingInteractiveStop = true;
// Cancel all non-persistent interactive requests
_rootData.PendingSeekDestination = null;
RootBeginPending = false;
ResetNodesWithSlip(); // Reset [....] tracking
NotifyNewEarliestFutureActivity();
}
///
/// Raises the events that occured since the last tick and reset their state.
///
internal void RaiseAccumulatedEvents()
{
try // We are calling user-defined delegates, if they throw we must ensure that we leave the Clock in a valid state
{
// CurrentTimeInvalidated should fire first. This is because AnimationStorage hooks itself
// up to this event in order to invalidate whichever DependencyProperty this clock may be
// animating. User code in any of these callbacks may query the value of that DP - if they
// do so before AnimationStorage has a chance to invalidate they will get the wrong value.
if (CurrentTimeInvalidatedEventRaised)
{
FireCurrentTimeInvalidatedEvent();
}
if (CurrentGlobalSpeedInvalidatedEventRaised)
{
FireCurrentGlobalSpeedInvalidatedEvent();
// Tell the Clocks that they have changed Speed
SpeedChanged();
}
if (CurrentStateInvalidatedEventRaised)
{
FireCurrentStateInvalidatedEvent();
// Since the state has been invalidated this means that
// we've got a discontinuous time movemement. Tell the clock
if (!CurrentGlobalSpeedInvalidatedEventRaised)
{
DiscontinuousTimeMovement();
}
}
if (CompletedEventRaised)
{
FireCompletedEvent();
}
if (RemoveRequestedEventRaised)
{
FireRemoveRequestedEvent();
}
}
finally // Reset the flags to make the state consistent, even if the user has thrown
{
CurrentTimeInvalidatedEventRaised = false;
CurrentGlobalSpeedInvalidatedEventRaised = false;
CurrentStateInvalidatedEventRaised = false;
CompletedEventRaised = false;
RemoveRequestedEventRaised = false;
IsInEventQueue = false;
}
}
///
/// Raises the Completed event.
///
///
/// We only need to raise this event once per tick. If we've already
/// raised it in this tick, do nothing.
///
internal void RaiseCompleted()
{
Debug.Assert(!IsTimeManager);
CompletedEventRaised = true;
if (!IsInEventQueue)
{
_timeManager.AddToEventQueue(this);
IsInEventQueue = true;
}
}
///
/// Raises the CurrentGlobalSpeedInvalidated event.
///
///
/// We only need to raise this event once per tick. If we've already
/// raised it in this tick, do nothing.
///
internal void RaiseCurrentGlobalSpeedInvalidated()
{
// ROOT Debug.Assert(!IsTimeManager);
CurrentGlobalSpeedInvalidatedEventRaised = true;
if (!IsInEventQueue)
{
_timeManager.AddToEventQueue(this);
IsInEventQueue = true;
}
}
///
/// Raises the CurrentStateInvalidated event.
///
internal void RaiseCurrentStateInvalidated()
{
Debug.Assert(!IsTimeManager);
if (_currentClockState == ClockState.Stopped) // If our state changed to stopped
{
Stopped();
}
CurrentStateInvalidatedEventRaised = true;
if (!IsInEventQueue)
{
_timeManager.AddToEventQueue(this);
IsInEventQueue = true;
}
}
///
/// Raises the CurrentTimeInvalidated event. This enqueues the event for later dispatch
/// if we are in a tick operation.
///
internal void RaiseCurrentTimeInvalidated()
{
Debug.Assert(!IsTimeManager);
CurrentTimeInvalidatedEventRaised = true;
if (!IsInEventQueue)
{
_timeManager.AddToEventQueue(this);
IsInEventQueue = true;
}
}
///
/// Raises the RemoveRequested event.
///
///
/// We only need to raise this event once per tick. If we've already
/// raised it in this tick, do nothing.
///
internal void RaiseRemoveRequested()
{
Debug.Assert(!IsTimeManager);
RemoveRequestedEventRaised = true;
if (!IsInEventQueue)
{
_timeManager.AddToEventQueue(this);
IsInEventQueue = true;
}
}
// Reset all currently cached state
internal void ResetCachedStateToStopped()
{
_currentGlobalSpeed = null;
_currentIteration = null;
IsBackwardsProgressingGlobal = false;
_currentProgress = null;
_currentTime = null;
_currentClockState = ClockState.Stopped;
}
// Reset IsInSyncPeriod for this node and all children if any (ClockGroup handles this).
// We do this whenever a discontinuous interactive action (seek/begin/stop) is performed.
internal virtual void ResetNodesWithSlip()
{
if (_syncData != null)
{
_syncData.IsInSyncPeriod = false; // Reset [....] tracking
}
}
///
/// Check if our descendants have resolved their duration, and resets the HasDescendantsWithUnresolvedDuration
/// flag from true to false once that happens.
///
/// Returns true when this node or one of its descendants have unresolved duration.
internal virtual void UpdateDescendantsWithUnresolvedDuration()
{
if (HasResolvedDuration)
{
HasDescendantsWithUnresolvedDuration = false;
}
}
#endregion // Internal Methods
//
// Internal Properties
//
#region Internal Properties
///
/// Specifies the depth of this timeline in the timing tree. If the timeline does not have
/// a parent, its depth value is zero.
///
internal int Depth
{
get
{
// ROOT Debug.Assert(!IsTimeManager);
return _depth;
}
}
///
/// Returns the last time this timeline will become non-active if it is not
/// clipped by the parent container first. Null represents infinity.
///
internal Duration EndOfActivePeriod
{
get
{
Debug.Assert(!IsTimeManager);
if (!HasResolvedDuration)
{
return Duration.Automatic;
}
// Computed expiration time with respect to repeat behavior and natural duration;
TimeSpan? expirationTime;
ComputeExpirationTime(out expirationTime);
//
if (expirationTime.HasValue)
{
return expirationTime.Value;
}
else
{
return Duration.Forever;
}
}
}
///
/// Gets the first child of this timeline.
///
///
/// Since a Clock doesn't have children we will always return null
///
internal virtual Clock FirstChild
{
get
{
return null;
}
}
///
/// Internal unverified access to the CurrentState
///
///
/// Only ClockGroup should set the value
///
internal ClockState InternalCurrentClockState
{
get
{
return _currentClockState;
}
set
{
_currentClockState = value;
}
}
///
/// Internal unverified access to the CurrentGlobalSpeed
///
///
/// Only ClockGroup should set the value
///
internal double? InternalCurrentGlobalSpeed
{
get
{
return _currentGlobalSpeed;
}
set
{
_currentGlobalSpeed = value;
}
}
///
/// Internal unverified access to the CurrentIteration
///
///
/// Only ClockGroup should set the value
///
internal Int32? InternalCurrentIteration
{
get
{
return _currentIteration;
}
set
{
_currentIteration = value;
}
}
///
/// Internal unverified access to the CurrentProgress
///
///
/// Only ClockGroup should set the value
///
internal double? InternalCurrentProgress
{
get
{
return _currentProgress;
}
set
{
_currentProgress = value;
}
}
///
/// The next GlobalTime that this clock may need a tick
///
internal TimeSpan? InternalNextTickNeededTime
{
get
{
return _nextTickNeededTime;
}
set
{
_nextTickNeededTime = value;
}
}
///
/// Unchecked internal access to the parent of this Clock.
///
internal ClockGroup InternalParent
{
get
{
Debug.Assert(!IsTimeManager);
return _parent;
}
}
///
/// Gets the current Duration for internal callers. This property will
/// never return Duration.Automatic. If the _resolvedDuration of the Clock
/// has not yet been resolved, this property will return Duration.Forever.
/// Therefore, it's possible that the value of this property will change
/// one time during the Clock's lifetime. It's not predictable when that
/// change will occur, it's up to the custom Clock author.
///
internal Duration ResolvedDuration
{
get
{
ResolveDuration();
Debug.Assert(_resolvedDuration != Duration.Automatic, "_resolvedDuration should never be set to Automatic.");
return _resolvedDuration;
}
}
///
/// Gets the right sibling of this timeline.
///
///
/// The right sibling of this timeline if it's not the last in its parent's
/// collection; otherwise, null.
///
internal Clock NextSibling
{
get
{
Debug.Assert(!IsTimeManager);
Debug.Assert(_parent != null && !_parent.IsTimeManager);
List parentChildren = _parent.InternalChildren;
if (_childIndex == parentChildren.Count - 1)
{
return null;
}
else
{
return parentChildren[_childIndex + 1];
}
}
}
///
/// Gets a cached weak reference to this clock.
///
internal WeakReference WeakReference
{
get
{
WeakReference reference = _weakReference;
if (reference == null)
{
reference = new WeakReference(this);
_weakReference = reference;
}
return reference;
}
}
///
/// Get the desired framerate of this clock
///
internal int? DesiredFrameRate
{
get
{
int? returnValue = null;
if (HasDesiredFrameRate)
{
returnValue = _rootData.DesiredFrameRate;
}
return returnValue;
}
}
//
// Internal access to some of the flags
//
#region Internal Flag Accessors
internal bool CompletedEventRaised
{
get
{
return GetFlag(ClockFlags.CompletedEventRaised);
}
set
{
SetFlag(ClockFlags.CompletedEventRaised, value);
}
}
internal bool CurrentGlobalSpeedInvalidatedEventRaised
{
get
{
return GetFlag(ClockFlags.CurrentGlobalSpeedInvalidatedEventRaised);
}
set
{
SetFlag(ClockFlags.CurrentGlobalSpeedInvalidatedEventRaised, value);
}
}
internal bool CurrentStateInvalidatedEventRaised
{
get
{
return GetFlag(ClockFlags.CurrentStateInvalidatedEventRaised);
}
set
{
SetFlag(ClockFlags.CurrentStateInvalidatedEventRaised, value);
}
}
internal bool CurrentTimeInvalidatedEventRaised
{
get
{
return GetFlag(ClockFlags.CurrentTimeInvalidatedEventRaised);
}
set
{
SetFlag(ClockFlags.CurrentTimeInvalidatedEventRaised, value);
}
}
private bool HasDesiredFrameRate
{
get
{
return GetFlag(ClockFlags.HasDesiredFrameRate);
}
set
{
SetFlag(ClockFlags.HasDesiredFrameRate, value);
}
}
internal bool HasResolvedDuration
{
get
{
return GetFlag(ClockFlags.HasResolvedDuration);
}
set
{
SetFlag(ClockFlags.HasResolvedDuration, value);
}
}
internal bool IsBackwardsProgressingGlobal
{
get
{
return GetFlag(ClockFlags.IsBackwardsProgressingGlobal);
}
set
{
SetFlag(ClockFlags.IsBackwardsProgressingGlobal, value);
}
}
internal bool IsInEventQueue
{
get
{
return GetFlag(ClockFlags.IsInEventQueue);
}
set
{
SetFlag(ClockFlags.IsInEventQueue, value);
}
}
///
/// Unchecked internal access to the paused state of the clock.
///
///
/// Returns true if the Clock traversed during the first tick pass.
///
///
/// Determine if we are active, filling, or off
/// parentTime is clamped if it is inside the postfill zone
/// We have to handle reversed parent differently because we have closed-open intervals in global time
///
/// Our computed expiration time, null if infinite.
/// Our parent time.
/// Our parent speed.
/// Whether we are called from within a tick.
///
/// GillesK: performTickOperations means that we process the pending events
///
private void ComputeLocalStateHelper(bool performTickOperations, bool seekedAlignedToLastTick)
{
Debug.Assert(!IsTimeManager);
TimeSpan? parentTime; // Computed parent-local time
TimeSpan? expirationTime; // Computed expiration time with respect to repeat behavior and resolved duration;
TimeSpan localProgress; // Computed time inside simple duration
TimeSpan parentTimeValue;
double? parentSpeed; // Parent's CurrentGlobalSpeed
TimeIntervalCollection parentIntervalCollection;
double localSpeed;
bool returnDelayed = false; //
// In this function, 'true' return values allow us to exit early
// We first compute parent parameters; with SlipBehavior, we may modify our parentIntervalCollection
if (ComputeParentParameters(out parentTime, out parentSpeed,
out parentIntervalCollection, seekedAlignedToLastTick))
{
returnDelayed = true;
}
// Now take potential SlipBehavior into account:
if (_syncData != null && _syncData.IsInSyncPeriod && _parent.CurrentState != ClockState.Stopped) // We are already in a slip zone
{
Debug.Assert(parentTime.HasValue); // If parent isn't stopped, it must have valid time and speed
Debug.Assert(parentSpeed.HasValue);
//
ComputeSyncSlip(ref parentIntervalCollection, parentTime.Value, parentSpeed.Value);
}
ResolveDuration();
// We only calculate the Interactive values when we are processing the pending events
if (performTickOperations && IsRoot)
{
// Special case for root-children, which may have interactivity
if (ComputeInteractiveValues())
{
returnDelayed = true;
}
}
// Check whether we are entering a [....] period. This includes cases when we have
// ticked before the beginning, then past the end of a [....] period; we still have to
// move back to the exact beginning of the tick period. We handle cases where
// we seek (HasSeekOccuredAfterLastTick) in a special way, by not synchronizing with the beginning.
// Also, if the parent has been paused prior to this tick, we cannot enter the [....] zone, so skip the call.
if (_syncData != null && !_syncData.IsInSyncPeriod && _parent.CurrentState != ClockState.Stopped &&
(!parentIntervalCollection.IsEmptyOfRealPoints || HasSeekOccuredAfterLastTick))
{
Debug.Assert(parentTime.HasValue); // Cannot be true unless parent is stopped
// We use the parent's TIC as a way of determining its earliest non-null time
ComputeSyncEnter(ref parentIntervalCollection, parentTime.Value);
}
if (ComputeExpirationTime(out expirationTime))
{
returnDelayed = true;
}
// Run the eventing logic here
if (performTickOperations)
{
ComputeEvents(expirationTime, parentIntervalCollection);
}
if (returnDelayed) // If we delayed returning until now, proceed to do so
{
return;
}
Debug.Assert(_beginTime.HasValue);
Debug.Assert(parentTime.HasValue);
parentTimeValue = parentTime.Value;
// Determines the next time we need to tick
if (ComputeNextTickNeededTime(expirationTime, parentTimeValue, parentSpeed.Value))
{
return;
}
// Determines if we are active, filling, or off
if (ComputeCurrentState(expirationTime, ref parentTimeValue, parentSpeed.Value, performTickOperations))
{
return;
}
// Determines the current iteration
if (ComputeCurrentIteration(parentTimeValue, parentSpeed.Value,
expirationTime, out localProgress))
{
return;
}
// Determines the current time and local speed with accel+decel
if (ComputeCurrentTime(localProgress, out localSpeed))
{
return;
}
// Determines the current speed
if (ComputeCurrentSpeed(localSpeed))
{
return;
}
}
//
// Determine the next needed tick time for approaching a StateInvalidated boundary
//
// Note that ComputeCurrentIteration and ComputeCurrentState also modify the
// NextTickNeededTime and consequently must run after this method.
//
private bool ComputeNextTickNeededTime(TimeSpan? expirationTime,
TimeSpan parentTime, double parentSpeed)
{
Debug.Assert(!IsTimeManager);
Debug.Assert(!IsInteractivelyStopped);
Debug.Assert(_parent._currentClockState != ClockState.Stopped);
Debug.Assert(_beginTime.HasValue);
if (parentSpeed == 0)
{
//
InternalNextTickNeededTime = IsInteractivelyPaused ? TimeSpan.Zero : (TimeSpan?)null;
}
else
{
double invertedParentSpeed = 1.0 / parentSpeed;
TimeSpan? timeUntilNextBoundary = null;
//
// Calculate the time in ms until begin or expiration time.
// They are positive if we're heading towards one of these periods, negative if heading away.
// This takes into account reversing clocks (so a clock heading back to begin will have
// a positive timeUntilBegin).
//
// timeUntilNextBoundary will be the first of these three boundaries that we hit.
// Negative values are obviously ignored.
//
TimeSpan timeUntilBegin = MultiplyTimeSpan(_beginTime.Value - parentTime, invertedParentSpeed);
//
// If the time until a boundary is 0 (i.e. we've ticked exactly on a boundary)
// we'll ask for another tick immediately.
// This is only relevant for reversing clocks, which, when on a boundary, are defined
// to have the 'previous' state, not the 'next' state. Thus they need one more
// tick for the state change to happen.
//
if (timeUntilBegin >= TimeSpan.Zero)
{
timeUntilNextBoundary = timeUntilBegin;
}
if (expirationTime.HasValue)
{
TimeSpan timeUntilExpiration = MultiplyTimeSpan(expirationTime.Value - parentTime, invertedParentSpeed);
if (timeUntilExpiration >= TimeSpan.Zero &&
(!timeUntilNextBoundary.HasValue || timeUntilExpiration < timeUntilNextBoundary.Value))
{
timeUntilNextBoundary = timeUntilExpiration;
}
}
//
// Set the next tick needed time depending on whether we're
// headed towards a boundary.
//
if (timeUntilNextBoundary.HasValue)
{
// We are moving towards some ClockState boundary either begin or expiration
InternalNextTickNeededTime = CurrentGlobalTime + timeUntilNextBoundary;
}
else
{
// We are not moving towards any boundary points
InternalNextTickNeededTime = null;
}
}
return false;
}
// Compute the parent's time; by the time we reach this method, we know that we
// have a non-root parent.
private bool ComputeParentParameters(out TimeSpan? parentTime, out double? parentSpeed,
out TimeIntervalCollection parentIntervalCollection,
bool seekedAlignedToLastTick)
{
Debug.Assert(!IsTimeManager);
Debug.Assert(!IsInteractivelyStopped || IsRoot);
if (IsRoot) // We are a root child, use time manager time
{
Debug.Assert(_rootData != null, "A root Clock must have the _rootData structure initialized.");
HasSeekOccuredAfterLastTick = seekedAlignedToLastTick || (_rootData.PendingSeekDestination != null); // We may have a seek request pending
// We don't have a TimeManager that is on, so we are off, nothing more to compute
if (_timeManager == null || _timeManager.InternalIsStopped)
{
ResetCachedStateToStopped();
parentTime = null; // Assign parentTime to avoid compiler error
parentSpeed = null;
InternalNextTickNeededTime = TimeSpan.Zero; // When TimeManager wakes up, we will need an update
parentIntervalCollection = TimeIntervalCollection.Empty;
return true;
}
else // We have a valid global time;
{
parentSpeed = 1.0; // TimeManager defines the rate at which time moves, e.g. it moves at 1X speed
parentIntervalCollection = _timeManager.InternalCurrentIntervals;
if (HasDesiredFrameRate)
{
// Change the parent's interval collection to include all time intervals since the last time
// we ticked this root node. Due to DFR, we may have skipped a number of "important" ticks.
parentTime = _rootData.CurrentAdjustedGlobalTime;
if (!parentIntervalCollection.IsEmptyOfRealPoints)
{
//
parentIntervalCollection = parentIntervalCollection.SetBeginningOfConnectedInterval(
_rootData.LastAdjustedGlobalTime);
}
}
else
{
parentTime = _timeManager.InternalCurrentGlobalTime;
}
return false;
}
}
else // We are a deeper node
{
HasSeekOccuredAfterLastTick = seekedAlignedToLastTick || _parent.HasSeekOccuredAfterLastTick; // We may have a seek request pending
parentTime = _parent._currentTime; // This is Null if parent is off; we still init the 'out' parameter
parentSpeed = _parent._currentGlobalSpeed;
parentIntervalCollection = _parent.CurrentIntervals;
// Find the parent's current time
if (_parent._currentClockState != ClockState.Stopped) // We have a parent that is active or filling
{
return false;
}
else // Else parent is off, so we are off, nothing more to compute
{
// Before setting our state to Stopped make sure that we
// fire the proper event if we change state.
if (_currentClockState != ClockState.Stopped)
{
RaiseCurrentStateInvalidated();
RaiseCurrentGlobalSpeedInvalidated();
RaiseCurrentTimeInvalidated();
}
ResetCachedStateToStopped();
InternalNextTickNeededTime = null;
return true;
}
}
}
// Abbreviations for variables expressing time units:
// PT: Parent time (e.g. our begin time is expressed in parent time coordinates)
// LT: Local time (e.g. our duration is expressed in local time coordinates)
// ST: [....] time -- this is the same as local time iff (_syncData.SyncClock == this) e.g. we are the [....] clock,
// otherwise it is our child's time coordinates (this happens when we are a container with SlipBehavior.Slip).
// SPT: The [....] clock's parent's time coordinates. When this IS the [....] clock, this is our parent coordinates.
// otherwise, it is our local coordinates.
private void ComputeSyncEnter(ref TimeIntervalCollection parentIntervalCollection,
TimeSpan currentParentTimePT)
{
Debug.Assert(!IsTimeManager);
Debug.Assert(_parent != null);
Debug.Assert(_parent.CurrentState != ClockState.Stopped);
// Parent is not stopped, so its TIC cannot be empty
Debug.Assert(HasSeekOccuredAfterLastTick ||
(!parentIntervalCollection.IsEmptyOfRealPoints && parentIntervalCollection.FirstNodeTime <= currentParentTimePT));
// SyncData points to our child if we have SlipBehavior, for CanSlip nodes it points to the node itself
Debug.Assert(_syncData.SyncClock == this || _syncData.SyncClock._parent == this);
Debug.Assert(CanSlip || _timeline is ParallelTimeline && ((ParallelTimeline)_timeline).SlipBehavior == SlipBehavior.Slip);
Debug.Assert(_syncData != null);
Debug.Assert(!_syncData.IsInSyncPeriod);
// Verify our limitations on slip functionality, but don't throw here for perf
Debug.Assert(_timeline.AutoReverse == false);
Debug.Assert(_timeline.AccelerationRatio == 0);
Debug.Assert(_timeline.DecelerationRatio == 0);
// With these limitations, we can easily preview our CurrentTime:
if (_beginTime.HasValue && currentParentTimePT >= _beginTime.Value)
{
TimeSpan relativeBeginTimePT = _currentIterationBeginTime.HasValue ? _currentIterationBeginTime.Value : _beginTime.Value;
TimeSpan previewCurrentOffsetPT = currentParentTimePT - relativeBeginTimePT; // This is our time offset (not yet scaled by speed)
TimeSpan previewCurrentTimeLT = MultiplyTimeSpan(previewCurrentOffsetPT, _appliedSpeedRatio); // This is what our time would be
// We can only enter [....] period if we are past the syncClock's begin time
if (_syncData.SyncClock == this || previewCurrentTimeLT >= _syncData.SyncClockBeginTime)
{
// We have two very different scenarios: seek and non-seek enter
if (HasSeekOccuredAfterLastTick) // We have seeked, see if we fell into a [....] period
{
// If we haven't returned yet, we are not past the end of the [....] period on the child
// Also, we are not Stopped prior to BeginTime.
TimeSpan? expirationTimePT;
ComputeExpirationTime(out expirationTimePT);
// This is to verify we did not seek past our active period duration
if (!expirationTimePT.HasValue || currentParentTimePT < expirationTimePT.Value)
{
TimeSpan ourSyncTimeST = (_syncData.SyncClock == this) ?
previewCurrentTimeLT :
MultiplyTimeSpan(previewCurrentTimeLT - _syncData.SyncClockBeginTime,
_syncData.SyncClockSpeedRatio);
TimeSpan? syncClockEffectiveDurationST = _syncData.SyncClockEffectiveDuration;
if (_syncData.SyncClock == this ||
!syncClockEffectiveDurationST.HasValue || ourSyncTimeST < syncClockEffectiveDurationST)
{
// If the [....] child has a specified duration
Duration syncClockDuration = _syncData.SyncClockResolvedDuration;
if (syncClockDuration.HasTimeSpan)
{
_syncData.PreviousSyncClockTime = TimeSpan.FromTicks(ourSyncTimeST.Ticks % syncClockDuration.TimeSpan.Ticks);
_syncData.PreviousRepeatTime = ourSyncTimeST - _syncData.PreviousSyncClockTime;
}
else if (syncClockDuration == Duration.Forever)
{
_syncData.PreviousSyncClockTime = ourSyncTimeST;
_syncData.PreviousRepeatTime = TimeSpan.Zero;
}
else
{
Debug.Assert(syncClockDuration == Duration.Automatic);
// If we seek into an Automatic syncChild's duration, we may overseek it, so throw an exception
throw new InvalidOperationException(SR.Get(SRID.Timing_SeekDestinationAmbiguousDueToSlip));
}
// This is the heart of the HasSeekOccuredAfterLastTick codepath; we don't adjust our
// time, but note to do so for the succeeding ticks.
_syncData.IsInSyncPeriod = true;
}
}
}
else // Non-seek, regular case
{
TimeSpan? previousSyncParentTimeSPT = (_syncData.SyncClock == this) ?
parentIntervalCollection.FirstNodeTime :
_currentTime;
if (!previousSyncParentTimeSPT.HasValue
|| _syncData.SyncClockDiscontinuousEvent
|| previousSyncParentTimeSPT.Value <= _syncData.SyncClockBeginTime)
// Not seeking this tick, different criteria for entering [....] period.
// We don't care if we overshot the beginTime, because we will seek backwards
// to match the child's beginTime exactly.
// NOTE: _currentTime is actually our time at last tick, since it wasn't yet updated.
{
// First, adjust our beginTime so that we match the syncClock's begin, accounting for SpeedRatio
TimeSpan timeIntoSyncPeriodPT = previewCurrentOffsetPT;
if (_syncData.SyncClock != this) // SyncClock is our child; account for SyncClock starting later than us
{
timeIntoSyncPeriodPT -= DivideTimeSpan(_syncData.SyncClockBeginTime, _appliedSpeedRatio);
}
// Offset our position to [....] with media begin
if (_currentIterationBeginTime.HasValue)
{
_currentIterationBeginTime += timeIntoSyncPeriodPT;
}
else
{
_beginTime += timeIntoSyncPeriodPT;
}
//
UpdateSyncBeginTime(); // This ensures that our _cutoffTime is correctly applied
// Now, update the parent TIC to compensate for our slip
parentIntervalCollection = parentIntervalCollection.SlipBeginningOfConnectedInterval(timeIntoSyncPeriodPT);
_syncData.IsInSyncPeriod = true;
_syncData.PreviousSyncClockTime = TimeSpan.Zero;
_syncData.PreviousRepeatTime = TimeSpan.Zero;
_syncData.SyncClockDiscontinuousEvent = false;
}
}
}
}
}
// Abbreviations for variables expressing time units:
// PT: Parent time (e.g. our begin time is expressed in parent time coordinates)
// LT: Local time (e.g. our duration is expressed in local time coordinates)
// ST: [....] time -- this is the same as local time iff (_syncData.SyncClock == this) e.g. we are the [....] clock,
// otherwise it is our child's time coordinates (this happens when we are a container with SlipBehavior.Slip).
// SPT: The [....] clock's parent's time coordinates. When this IS the [....] clock, this is our parent coordinates.
// otherwise, it is our local coordinates.
private void ComputeSyncSlip(ref TimeIntervalCollection parentIntervalCollection,
TimeSpan currentParentTimePT, double currentParentSpeed)
{
Debug.Assert(!IsTimeManager);
Debug.Assert(_parent != null);
Debug.Assert(_syncData != null);
Debug.Assert(_syncData.IsInSyncPeriod);
// SyncData points to our child if we have SlipBehavior, for CanSlip nodes it points to the node itself
Debug.Assert(_syncData.SyncClock == this || _syncData.SyncClock._parent == this);
// The overriding assumption for slip limitations is that the parent's intervals are
// "connected", e.g. not broken into multiple intervals. This is always true for roots.
Debug.Assert(!parentIntervalCollection.IsEmpty); // The parent isn't Stopped, so it must have a TIC
// From now on, we assume that the parent's TIC begins from the parent's CurrentTime at
// at the previous tick. Ensure that the parent is moving forward.
Debug.Assert(parentIntervalCollection.IsEmptyOfRealPoints || parentIntervalCollection.FirstNodeTime <= currentParentTimePT);
Debug.Assert(currentParentSpeed >= 0);
// We now extract this information from the TIC. If we are paused, we have an empty TIC and assume parent time has not changed.
TimeSpan previousParentTimePT = parentIntervalCollection.IsEmptyOfRealPoints ? currentParentTimePT
: parentIntervalCollection.FirstNodeTime;
TimeSpan parentElapsedTimePT = currentParentTimePT - previousParentTimePT;
// Our elapsed time is assumed to be a simple linear scale of the parent's time,
// as long as we are inside of the [....] period.
TimeSpan ourProjectedElapsedTimeLT = MultiplyTimeSpan(parentElapsedTimePT, _appliedSpeedRatio);
TimeSpan syncTimeST = _syncData.SyncClock.GetCurrentTimeCore();
TimeSpan syncElapsedTimeST = syncTimeST - _syncData.PreviousSyncClockTime; // Elapsed from last tick
if (syncElapsedTimeST > TimeSpan.Zero) // Only store the last value if it is greater than
// the old value. Note we can use either >= or > here.
{
// Check whether [....] has reached the end of our effective duration
TimeSpan? effectiveDurationST = _syncData.SyncClockEffectiveDuration;
Duration syncDuration = _syncData.SyncClockResolvedDuration;
if (effectiveDurationST.HasValue &&
(_syncData.PreviousRepeatTime + syncTimeST >= effectiveDurationST.Value))
{
_syncData.IsInSyncPeriod = false; // This is the last time we need to [....]
_syncData.PreviousRepeatTime = TimeSpan.Zero;
_syncData.SyncClockDiscontinuousEvent = false; // Make sure we don't reenter the [....] period
}
// Else check if we should wrap the simple duration due to repeats, and set previous times accordingly
else if (syncDuration.HasTimeSpan && syncTimeST >= syncDuration.TimeSpan)
{
// If we have a single repetition, then we would be done here;
// However, we may just have reached the end of an iteration on repeating media;
// In this case, we still [....] this particular moment, but we should reset the
// previous [....] clock time to zero, and increment the PreviousRepeatTime.
// This tick, media should pick up a corresponding DiscontinuousMovement caused
// by a repeat, and reset itself to zero as well.
_syncData.PreviousSyncClockTime = TimeSpan.Zero;
_syncData.PreviousRepeatTime += syncDuration.TimeSpan;
}
else // Don't need to wrap around
{
_syncData.PreviousSyncClockTime = syncTimeST;
}
}
else // If the [....] timeline went backwards, pretend it just didn't move.
{
syncElapsedTimeST = TimeSpan.Zero;
}
// Convert elapsed time to local coordinates, not necessarily same as [....] clock coordinates
TimeSpan syncElapsedTimeLT = (_syncData.SyncClock == this)
? syncElapsedTimeST
: DivideTimeSpan(syncElapsedTimeST, _syncData.SyncClockSpeedRatio);
// This is the actual slip formula: how much is the slipping clock lagging behind?
TimeSpan parentTimeSlipPT = parentElapsedTimePT - DivideTimeSpan(syncElapsedTimeLT, _appliedSpeedRatio);
// NOTE: The above line does the same as this:
// parentTimeSlip = syncSlip / _appliedSpeedRatio
// ...but it maintains greater accuracy and prevents a bug where parentTimeSlip ends up 1 tick greater
// that it should be, thus becoming larger than parentElapsedTimePT and causing us to suddenly fall out
// of our [....] period.
// Unless the media is exactly perfect, we will have non-zero slip time; we assume that it isn't
// perfect, and always adjust our time accordingly.
if (_currentIterationBeginTime.HasValue)
{
_currentIterationBeginTime += parentTimeSlipPT;
}
else
{
_beginTime += parentTimeSlipPT;
}
//
UpdateSyncBeginTime();
parentIntervalCollection = parentIntervalCollection.SlipBeginningOfConnectedInterval(parentTimeSlipPT);
return;
}
private void ResetSlipOnSubtree()
{
// Reset all children's slip time here; NOTE that this will change our effective duration,
// but this should not become important until the next tick, when it will be recomputed anyway.
PrefixSubtreeEnumerator subtree = new PrefixSubtreeEnumerator(this, false); // No iteration at this node
while (subtree.MoveNext())
{
Clock current = subtree.Current;
Debug.Assert(!current.IsRoot, "Root nodes never should reset their Slip amounts with ResetSlipOnSubtree(), even when seeking.");
if (current._syncData != null)
{
current._syncData.IsInSyncPeriod = false;
current._syncData.SyncClockDiscontinuousEvent = true;
}
if (current.CanSlip)
{
current._beginTime = current._timeline.BeginTime; // _beginTime could have slipped with media nodes
current._currentIteration = null;
current.UpdateSyncBeginTime();
current.HasDiscontinuousTimeMovementOccured = true;
}
else if (current.CanGrow) // If it's a repeating container with slippable descendants...
{
current._currentIterationBeginTime = current._beginTime; // ...reset its current iteration as well
current._currentDuration = current._resolvedDuration; // Revert currentDuration back to default size
}
else // Otherwise we know not to traverse any further
{
subtree.SkipSubtree();
}
}
}
#endregion // Local State Computation Helpers
#region Event Helpers
///
/// Adds a delegate to the list of event handlers on this object.
///
///
/// A unique identifier for the event handler. Since Clock events
/// mirror Timeline events the callers of this method will pass in
/// keys from Timeline
///
/// The delegate to add
private void AddEventHandler(EventPrivateKey key, Delegate handler)
{
Debug.Assert(!IsTimeManager);
if (_eventHandlersStore == null)
{
_eventHandlersStore = new EventHandlersStore();
}
_eventHandlersStore.Add(key, handler);
VerifyNeedsTicksWhenActive();
}
///
/// Immediately fire the Loaded Event
///
private void FireCompletedEvent()
{
FireEvent(Timeline.CompletedKey);
}
///
/// Immediately fire the GlobalSpeedInvalidated Event
///
private void FireCurrentGlobalSpeedInvalidatedEvent()
{
FireEvent(Timeline.CurrentGlobalSpeedInvalidatedKey);
}
///
/// Immediately fire the State Invalidated Event
///
private void FireCurrentStateInvalidatedEvent()
{
FireEvent(Timeline.CurrentStateInvalidatedKey);
}
///
/// Immediately fire the CurrentTimeInvalidated Event
///
private void FireCurrentTimeInvalidatedEvent()
{
FireEvent(Timeline.CurrentTimeInvalidatedKey);
}
///
/// Fires the given event
///
/// The unique key representing the event to fire
private void FireEvent(EventPrivateKey key)
{
if (_eventHandlersStore != null)
{
EventHandler handler = (EventHandler)_eventHandlersStore.Get(key);
if (handler != null)
{
handler(this, null);
}
}
}
///
/// Immediately fire the RemoveRequested Event
///
private void FireRemoveRequestedEvent()
{
FireEvent(Timeline.RemoveRequestedKey);
}
// Find the last closest time that falls on the boundary of the Desired Frame Rate
private TimeSpan GetCurrentDesiredFrameTime(TimeSpan time)
{
return GetDesiredFrameTime(time, +0);
}
// Find the closest time that falls on the boundary of the Desired Frame Rate, advancing [frameOffset] frames forward
private TimeSpan GetDesiredFrameTime(TimeSpan time, int frameOffset)
{
Debug.Assert(_rootData.DesiredFrameRate > 0);
Int64 desiredFrameRate = _rootData.DesiredFrameRate;
Int64 desiredFrameNumber = (time.Ticks * desiredFrameRate) / s_TimeSpanTicksPerSecond + frameOffset;
Int64 desiredFrameTick = (desiredFrameNumber * s_TimeSpanTicksPerSecond) / desiredFrameRate;
return TimeSpan.FromTicks(desiredFrameTick);
}
// Find the next closest time that falls on the boundary of the Desired Frame Rate
private TimeSpan GetNextDesiredFrameTime(TimeSpan time)
{
return GetDesiredFrameTime(time, +1);
}
///
/// Removes a delegate from the list of event handlers on this object.
///
///
/// A unique identifier for the event handler. Since Clock events
/// mirror Timeline events the callers of this method will pass in
/// keys from Timeline
///
/// The delegate to remove
private void RemoveEventHandler(EventPrivateKey key, Delegate handler)
{
Debug.Assert(!IsTimeManager);
if (_eventHandlersStore != null)
{
_eventHandlersStore.Remove(key, handler);
if (_eventHandlersStore.Count == 0)
{
_eventHandlersStore = null;
}
}
UpdateNeedsTicksWhenActive();
}
#endregion // Event Helpers
///
/// Adds this clock to the time manager.
///
private void AddToTimeManager()
{
Debug.Assert(!IsTimeManager);
Debug.Assert(_parent == null);
Debug.Assert(_timeManager == null);
TimeManager timeManager = MediaContext.From(Dispatcher).TimeManager;
if (timeManager == null)
{
// The time manager has not been created or has been released
// This occurs when we are shutting down. Simply return.
return;
}
_parent = timeManager.TimeManagerClock;
SetTimeManager(_parent._timeManager);
Int32? desiredFrameRate = Timeline.GetDesiredFrameRate(_timeline);
if (desiredFrameRate.HasValue)
{
HasDesiredFrameRate = true;
_rootData.DesiredFrameRate = desiredFrameRate.Value;
}
// Store this clock in the root clock's child collection
_parent.InternalRootChildren.Add(WeakReference);
// Create a finalizer object that will clean up after we are gone
_subtreeFinalizer = new SubtreeFinalizer(_timeManager);
// Fix up depth values
PrefixSubtreeEnumerator subtree = new PrefixSubtreeEnumerator(this, true);
while (subtree.MoveNext())
{
Clock current = subtree.Current;
current._depth = current._parent._depth + 1;
}
// Perform any necessary updates
if (IsInTimingTree)
{
// Mark the tree as dirty
_timeManager.SetDirty();
}
TimeIntervalCollection currentIntervals = TimeIntervalCollection.CreatePoint(_timeManager.InternalCurrentGlobalTime);
currentIntervals.AddNullPoint();
_timeManager.InternalCurrentIntervals = currentIntervals;
//
// Recompute the local state at this subtree
//
// Since _beginTime for a root clock takes the current time into account,
// it needs to be set during a tick. The call to ComputeLocalState
// here isn't on a tick boundary, so we don't want to begin the clock yet.
_beginTime = null;
_currentIterationBeginTime = null;
subtree.Reset();
while (subtree.MoveNext())
{
subtree.Current.ComputeLocalState(); // Compute the state of the node
subtree.Current.ClipNextTickByParent(); // Perform NextTick clipping, stage 1
// Make a note to visit for stage 2, only for ClockGroups
subtree.Current.NeedsPostfixTraversal = (subtree.Current is ClockGroup);
}
_parent.ComputeTreeStateRoot(); // Re-clip the next tick estimates by children
// Adding is an implicit begin, so do that here. This is done after
// ComputeLocalState so that the begin will be picked up on the
// next tick. Note that if _timeline.BeginTime == null we won't
// start the clock.
if (_timeline.BeginTime != null)
{
RootBeginPending = true;
}
NotifyNewEarliestFutureActivity(); // Make sure we get ticks
}
///
/// Helper for more elegant code dividing a TimeSpan by a double
///
private TimeSpan DivideTimeSpan(TimeSpan timeSpan, double factor)
{
Debug.Assert(factor != 0); // Divide by zero
return TimeSpan.FromTicks((long)(((double)timeSpan.Ticks) / factor + 0.5));
}
///
/// Gets the value of a flag specified by the ClockFlags enum
///
private bool GetFlag(ClockFlags flagMask)
{
return (_flags & flagMask) == flagMask;
}
///
/// Helper for more elegant code multiplying a TimeSpan by a double
///
private static TimeSpan MultiplyTimeSpan(TimeSpan timeSpan, double factor)
{
return TimeSpan.FromTicks((long)(factor * (double)timeSpan.Ticks + 0.5));
}
private void NotifyNewEarliestFutureActivity()
{
PrefixSubtreeEnumerator subtree = new PrefixSubtreeEnumerator(this, true); // First reset the children
while (subtree.MoveNext())
{
subtree.Current.InternalNextTickNeededTime = TimeSpan.Zero;
}
Clock current = _parent; // Propagate the fact that we will need an update sooner up the chain
while (current != null && current.InternalNextTickNeededTime != TimeSpan.Zero)
{
current.InternalNextTickNeededTime = TimeSpan.Zero;
if (current.IsTimeManager) // We went all the way up to the root node, notify TimeManager
{
_timeManager.NotifyNewEarliestFutureActivity();
break;
}
current = current._parent;
}
if (_timeManager != null)
{
// If we get here from within a Tick, this will force MediaContext to perform another subsequent Tick
// on the TimeManager. This will apply the requested interactive operations, so their results will
// immediately become visible.
_timeManager.SetDirty();
}
}
// State that must remain *constant* outside of the active period
private void ResetCachedStateToFilling()
{
_currentGlobalSpeed = 0;
IsBackwardsProgressingGlobal = false;
_currentClockState = ClockState.Filling;
}
///
/// Calls RaiseCompleted on this subtree when called on a root.
///
/// Whether we are in a tick.
private void RaiseCompletedForRoot(bool isInTick)
{
// Only perform this operation from root nodes. Also, to avoid constantly calling Completed after passing
// expirationTime, check that the state is invalidated, so we only raise the event as we are finishing.
if (IsRoot && (CurrentStateInvalidatedEventRaised || !isInTick))
{
// If we are a root node, notify the entire subtree
PrefixSubtreeEnumerator subtree = new PrefixSubtreeEnumerator(this, true);
while (subtree.MoveNext())
{
subtree.Current.RaiseCompleted();
}
}
}
private void RaiseRemoveRequestedForRoot()
{
Debug.Assert(IsRoot); // This should only be called on root-child clocks
// If we are a root node, notify the entire subtree
PrefixSubtreeEnumerator subtree = new PrefixSubtreeEnumerator(this, true);
while (subtree.MoveNext())
{
subtree.Current.RaiseRemoveRequested();
}
}
///
/// Sets a specified flag with the given value
///
private void SetFlag(ClockFlags flagMask, bool value)
{
if (value)
{
_flags |= flagMask;
}
else
{
_flags &= ~(flagMask);
}
}
///
/// Sets the time manager for the subtree rooted at this timeline.
///
///
/// The new time manager.
///
private void SetTimeManager(TimeManager timeManager)
{
Debug.Assert(!IsTimeManager);
// Optimize the no-op case away
if (this._timeManager != timeManager)
{
// Set the new time manager for the whole subtree
PrefixSubtreeEnumerator subtree = new PrefixSubtreeEnumerator(this, true);
while (subtree.MoveNext())
{
subtree.Current._timeManager = timeManager;
}
if (timeManager != null)
{
// If we are joining a new time manager, issue any deferred calls
subtree.Reset();
while (subtree.MoveNext())
{
Clock current = subtree.Current;
//
}
}
}
}
private void UpdateNeedsTicksWhenActive()
{
// Currently we'll set NeedsTicksWhenActive to true
// if any of the three events are set on this clock.
//
if (_eventHandlersStore == null)
{
NeedsTicksWhenActive = false;
}
else
{
NeedsTicksWhenActive = true;
}
}
// This wrapper is invoked anytime we invalidate the _beginTime
private void UpdateSyncBeginTime()
{
if (_syncData != null)
{
_syncData.UpdateClockBeginTime();
}
}
private void VerifyNeedsTicksWhenActive()
{
if (!NeedsTicksWhenActive) // We may need to update the tree to know that we need ticks
{
NeedsTicksWhenActive = true; // Use this as a hint for NeedsTicksWhenActive
NotifyNewEarliestFutureActivity();
}
}
#endregion // Private Methods
//
// Private Properties
//
#region Private Properties
///
/// True if we are in a running timing tree, false otherwise.
///
private bool IsInTimingTree
{
get
{
Debug.Assert(!IsTimeManager);
return (_timeManager != null) && (_timeManager.State != TimeState.Stopped);
}
}
///
/// This isn't an Interactive method: InternalBegin does
/// not make use of this flag. It is set in AddToRoot() to
/// notify a root clock that it must begin at the next tick.
/// Until this is set_beginTime for a root clock will be null;
/// AdjustBeginTime() sets _beginTime properly.
///
private bool RootBeginPending
{
get
{
return GetFlag(ClockFlags.RootBeginPending);
}
set
{
SetFlag(ClockFlags.RootBeginPending, value);
}
}
#endregion // Private Properties
//
// Nested Types
//
#region Nested Types
[Flags]
private enum ClockFlags : uint
{
IsTimeManager = 1 << 0,
IsRoot = 1 << 1,
IsBackwardsProgressingGlobal = 1 << 2,
IsInteractivelyPaused = 1 << 3,
IsInteractivelyStopped = 1 << 4,
PendingInteractivePause = 1 << 5,
PendingInteractiveResume = 1 << 6,
PendingInteractiveStop = 1 << 7,
PendingInteractiveRemove = 1 << 8,
CanGrow = 1 << 9,
CanSlip = 1 << 10,
CurrentStateInvalidatedEventRaised = 1 << 11,
CurrentTimeInvalidatedEventRaised = 1 << 12,
CurrentGlobalSpeedInvalidatedEventRaised = 1 << 13,
CompletedEventRaised = 1 << 14,
RemoveRequestedEventRaised = 1 << 15,
IsInEventQueue = 1 << 16,
NeedsTicksWhenActive = 1 << 17,
NeedsPostfixTraversal = 1 << 18,
PauseStateChangedDuringTick = 1 << 19,
RootBeginPending = 1 << 20,
HasControllableRoot = 1 << 21,
HasResolvedDuration = 1 << 22,
HasDesiredFrameRate = 1 << 23,
HasDiscontinuousTimeMovementOccured = 1 << 24,
HasDescendantsWithUnresolvedDuration = 1 << 25,
HasSeekOccuredAfterLastTick = 1 << 26,
}
///
/// The result of a ResolveTimes method call.
///
private enum ResolveCode
{
///
/// Nothing changed in resolving new times.
///
NoChanges,
///
/// Resolved times are different than before.
///
NewTimes,
///
/// The children of this timeline need a full reset time resolution. This flag
/// indicates that a partial resolution needs to be prunned at the current
/// timeline in favor of a full resolution for its children.
///
NeedNewChildResolve
}
///
/// Implements a finalizer for a clock subtree.
///
private class SubtreeFinalizer
{
///
/// Creates a finalizer for a clock subtree.
///
internal SubtreeFinalizer(TimeManager timeManager)
{
_timeManager = timeManager;
}
///
/// Finalizes a clock subtree.
///
~SubtreeFinalizer()
{
#pragma warning disable 1634, 1691
#pragma warning suppress 6525
_timeManager.ScheduleClockCleanup();
}
private TimeManager _timeManager;
}
///
/// Holds [....]-related data when it is applicable
///
internal class SyncData
{
internal SyncData(Clock syncClock)
{
Debug.Assert(syncClock != null);
Debug.Assert(syncClock.GetCanSlip());
Debug.Assert(syncClock.IsRoot || syncClock._timeline.BeginTime.HasValue); // Only roots may later validate their _beginTime
_syncClock = syncClock;
UpdateClockBeginTime(); // This will update the remaining dependencies
}
// This method should be invoked anytime we invalidate the SyncClock's _beginTime only
internal void UpdateClockBeginTime()
{
//
_syncClockBeginTime = _syncClock._beginTime;
_syncClockSpeedRatio = _syncClock._appliedSpeedRatio;
_syncClockResolvedDuration = SyncClockResolvedDuration; // This is to detect media finding its true duration
}
internal Clock SyncClock
{
get { return _syncClock; }
}
internal Duration SyncClockResolvedDuration
{
get
{
// Duration can only change its value while it is Automatic
if (!_syncClockResolvedDuration.HasTimeSpan)
{
_syncClockEffectiveDuration = _syncClock.ComputeEffectiveDuration(); // null == infinity
_syncClockResolvedDuration = _syncClock._resolvedDuration;
}
return _syncClockResolvedDuration;
}
}
internal bool SyncClockHasReachedEffectiveDuration
{
get
{
if (_syncClockEffectiveDuration.HasValue) // If the [....] clock has a finite duration
{
return (_previousRepeatTime + _syncClock.GetCurrentTimeCore() >= _syncClockEffectiveDuration.Value);
}
else
{
return false;
}
}
}
// NOTE: This value is in SyncNode coordinates, not its parent's coordinates
internal TimeSpan? SyncClockEffectiveDuration
{
get { return _syncClockEffectiveDuration; }
}
internal double SyncClockSpeedRatio
{
get { return _syncClockSpeedRatio; }
}
internal bool IsInSyncPeriod
{
get { return _isInSyncPeriod; }
set { _isInSyncPeriod = value; }
}
internal bool SyncClockDiscontinuousEvent
{
get { return _syncClockDiscontinuousEvent; }
set { _syncClockDiscontinuousEvent = value; }
}
internal TimeSpan PreviousSyncClockTime
{
get { return _previousSyncClockTime; }
set { _previousSyncClockTime = value; }
}
internal TimeSpan PreviousRepeatTime
{
get { return _previousRepeatTime; }
set { _previousRepeatTime = value; }
}
internal TimeSpan SyncClockBeginTime
{
get
{
Debug.Assert(_syncClockBeginTime.HasValue); // This should never be queried on a root without beginTime
return _syncClockBeginTime.Value;
}
}
private Clock _syncClock;
private double _syncClockSpeedRatio;
private bool _isInSyncPeriod, _syncClockDiscontinuousEvent;
private Duration _syncClockResolvedDuration = Duration.Automatic; // Duration -- *local* coordinates
private TimeSpan? _syncClockEffectiveDuration; // This reflects RepeatBehavior (local coordinates)
private TimeSpan? _syncClockBeginTime;
private TimeSpan _previousSyncClockTime;
private TimeSpan _previousRepeatTime; // How many complete iterations we already have done
}
///
/// Holds data specific to root clocks.
///
internal class RootData
{
internal RootData()
{
}
internal TimeSpan CurrentAdjustedGlobalTime
{
get { return _currentAdjustedGlobalTime; }
set { _currentAdjustedGlobalTime = value; }
}
internal Int32 DesiredFrameRate
{
get { return _desiredFrameRate; }
set { _desiredFrameRate = value; }
}
internal Double InteractiveSpeedRatio
{
get { return _interactiveSpeedRatio; }
set { _interactiveSpeedRatio = value; }
}
internal TimeSpan LastAdjustedGlobalTime
{
get { return _lastAdjustedGlobalTime; }
set { _lastAdjustedGlobalTime = value; }
}
///
/// The time to which we want to seek this timeline at the next tick
///
internal TimeSpan? PendingSeekDestination
{
get { return _pendingSeekDestination; }
set { _pendingSeekDestination = value; }
}
internal Double? PendingSpeedRatio
{
get { return _pendingSpeedRatio; }
set { _pendingSpeedRatio = value; }
}
private Int32 _desiredFrameRate;
private double _interactiveSpeedRatio = 1.0;
private double? _pendingSpeedRatio;
private TimeSpan _currentAdjustedGlobalTime;
private TimeSpan _lastAdjustedGlobalTime;
private TimeSpan? _pendingSeekDestination;
}
#endregion // Nested Types
//
// Debugging Instrumentation
//
#region Debugging instrumentation
///
/// Debug-only method to verify that the recomputed input time
/// is close to the original. See ComputeCurrentIteration
///
/// original input time
/// input time without rounding errors
[Conditional("DEBUG")]
private void Debug_VerifyOffsetFromBegin(long inputTime, long optimizedInputTime)
{
long error = (long)Math.Max(_appliedSpeedRatio, 1.0);
// Assert the computed inputTime is very close to the original.
// _appliedSpeedRatio is the upper bound of the error (in Ticks) caused by the
// calculation of inputTime. The reason is that we truncate (floor) during the
// computation of EffectiveDuration, losing up to 0.99999.... off the number.
// The computation of inputTime multiplies the truncated value by _appliedSpeedRatio,
// so _appliedSpeedRatio is guaranteed to be close to but higher than the actual error.
Debug.Assert(Math.Abs(optimizedInputTime - inputTime) <= error,
"This optimized inputTime does not match the original - did the calculation of inputTime change?");
}
#if DEBUG
///
/// Dumps the description of the subtree rooted at this clock.
///
internal void Dump()
{
System.Text.StringBuilder builder = new System.Text.StringBuilder();
builder.Capacity = 1024;
builder.Append("======================================================================\n");
builder.Append("Clocks rooted at Clock ");
builder.Append(_debugIdentity);
builder.Append('\n');
builder.Append("----------------------------------------------------------------------\n");
builder.Append("Flags LastBegin LastEnd NextBegin NextEnd Name\n");
builder.Append("----------------------------------------------------------------------\n");
if (IsTimeManager)
{
RootBuildInfoRecursive(builder);
}
else
{
BuildInfoRecursive(builder, 0);
}
builder.Append("----------------------------------------------------------------------\n");
Trace.Write(builder.ToString());
}
///
/// Dumps the description of all clocks in the known clock table.
///
internal static void DumpAll()
{
System.Text.StringBuilder builder = new System.Text.StringBuilder();
int clockCount = 0;
builder.Capacity = 1024;
builder.Append("======================================================================\n");
builder.Append("Clocks in the GC heap\n");
builder.Append("----------------------------------------------------------------------\n");
builder.Append("Flags LastBegin LastEnd NextBegin NextEnd Name\n");
builder.Append("----------------------------------------------------------------------\n");
lock (_debugLockObject)
{
if (_objectTable.Count > 0)
{
// Output the clocks sorted by ID
int[] idTable = new int[_objectTable.Count];
_objectTable.Keys.CopyTo(idTable, 0);
Array.Sort(idTable);
for (int index = 0; index < idTable.Length; index++)
{
WeakReference weakRef = (WeakReference)_objectTable[idTable[index]];
Clock clock = (Clock)weakRef.Target;
if (clock != null)
{
clock.BuildInfo(builder, 0, true);
clockCount++;
}
}
}
}
if (clockCount == 0)
{
builder.Append("There are no Clocks in the GC heap.\n");
}
builder.Append("----------------------------------------------------------------------\n");
Trace.Write(builder.ToString());
}
///
/// Dumps the description of the subtree rooted at this clock.
///
///
/// A StringBuilder that accumulates the description text.
///
///
/// The depth of recursion for this clock.
///
// Normally a virtual method would be implemented for the dervied class
// to handle the children property, but the asmmeta would be different
// since this is only availabe in a debug build. For this reason we're
// handling the children in the base class.
internal void BuildInfoRecursive(System.Text.StringBuilder builder, int depth)
{
// Add the info for this clock
BuildInfo(builder, depth, false);
// Recurse into the children
ClockGroup thisGroup = this as ClockGroup;
if (thisGroup != null)
{
depth++;
List children = thisGroup.InternalChildren;
if (children != null)
{
for (int childIndex = 0; childIndex < children.Count; childIndex++)
{
children[childIndex].BuildInfoRecursive(builder, depth);
}
}
}
}
///
/// Dumps the description of the subtree rooted at this root clock.
///
///
/// A StringBuilder that accumulates the description text.
///
internal void RootBuildInfoRecursive(System.Text.StringBuilder builder)
{
// Add the info for this clock
BuildInfo(builder, 0, false);
// Recurse into the children. Don't use the enumerator because
// that would remove dead references, which would be an undesirable
// side-effect for a debug output method.
List children = ((ClockGroup) this).InternalRootChildren;
for (int index = 0; index < children.Count; index++)
{
Clock child = (Clock)children[index].Target;
if (child != null)
{
child.BuildInfoRecursive(builder, 1);
}
}
}
///
/// Dumps the description of this clock.
///
///
/// A StringBuilder that accumulates the description text.
///
///
/// The depth of recursion for this clock.
///
///
/// True to dump the ID of the parent clock, false otherwise.
///
internal void BuildInfo(System.Text.StringBuilder builder, int depth, bool includeParentID)
{
builder.Append(depth);
builder.Append(GetType().Name);
builder.Append(' ');
builder.Append(_debugIdentity);
builder.Append(' ');
_timeline.BuildInfo(builder, 0, false);
}
///
/// Finds a previously registered object.
///
///
/// The ID of the object to look for
///
///
/// The object if found, null otherwise.
///
internal static Clock Find(int id)
{
Clock clock = null;
lock (_debugLockObject)
{
object handleReference = _objectTable[id];
if (handleReference != null)
{
WeakReference weakRef = (WeakReference)handleReference;
clock = (Clock)weakRef.Target;
if (clock == null)
{
// Object has been destroyed, so remove the weakRef.
_objectTable.Remove(id);
}
}
}
return clock;
}
///
/// Cleans up the known timeline clocks table by removing dead weak
/// references.
///
internal static void CleanKnownClocksTable()
{
lock (_debugLockObject)
{
Hashtable removeTable = new Hashtable();
// Identify dead references
foreach (DictionaryEntry e in _objectTable)
{
WeakReference weakRef = (WeakReference) e.Value;
if (weakRef.Target == null)
{
removeTable[e.Key] = weakRef;
}
}
// Remove dead references
foreach (DictionaryEntry e in removeTable)
{
_objectTable.Remove(e.Key);
}
}
}
#endif // DEBUG
#endregion // Debugging instrumentation
//
// Data
//
#region Data
private ClockFlags _flags;
private int? _currentIteration; // Precalculated current iteration
private double? _currentProgress; // Precalculated current progress value
private double? _currentGlobalSpeed; // Precalculated current global speed value
private TimeSpan? _currentTime; // Precalculated current global time
private ClockState _currentClockState; // Precalculated current clock state
private RootData _rootData = null; // Keeps track of root-related data for DesiredFrameRate
internal SyncData _syncData = null; // Keeps track of [....]-related data for SlipBehavior
// Stores the clock's begin time as an offset from the clock's
// parent's begin time (i.e. a begin time of 2 sec means begin
// 2 seconds afer the parent starts). For non-root clocks this
// is always the same as its timeline's begin time.
// For root clocks, the begin time is adjusted in response to seeks,
// pauses, etc (see AdjustBeginTime())
//
// This must be null when the clock is stopped.
internal TimeSpan? _beginTime;
// This is only used for repeating timelines which have CanSlip children/descendants;
// In this case, we use this variable instead of _beginTime to compute the current state
// of the clock (in conjunction with _currentIteration, so we know how many we have
// already completed.) This makes us agnostic to slip/growth in our past iterations.
private TimeSpan? _currentIterationBeginTime;
// How soon this Clock needs another tick
internal TimeSpan? _nextTickNeededTime = null;
private WeakReference _weakReference;
private SubtreeFinalizer _subtreeFinalizer;
private EventHandlersStore _eventHandlersStore;
///
/// Cache Duration for perf reasons and also to accommodate one time
/// only resolution of natural duration.
/// If Timeline.Duration is Duration.Automatic, we will at first treat
/// this as Duration.Forever, but will periodically ask what the resolved
/// duration is. Once we receive an answer, that will be the duration
/// used from then on, and we won't ask again.
/// Otherwise, this will be set to Timeline.Duration when the Clock is
/// created and won't change.
///
internal Duration _resolvedDuration;
///
/// This is a cached estimated duration of the current iteration of this clock.
/// For clocks which return false to CanGrow, this should always equal the
/// _resolvedDuration. However, for clocks with CanGrow, this may change from
/// tick to tick. Based on how far we are in the present iteration, and how
/// on track our slipping children are, we make estimates of when we will finish
/// the iteration, which are reflected by our estimated _currentDuration.
///
internal Duration _currentDuration;
///
/// For a root, this is the Timeline's speed ratio multiplied by the
/// interactive speed ratio. It's updated whenever the interactive speed
/// ratio is updated. If the interactive speed ratio is 0, we'll use the
/// Timeline's speed ratio, that is, treat interactive speed ratio as 1.
/// This is why this is "applied" speed ratio.
///
/// For a non-root, this is just a cache for the Timeline's speed ratio.
///
private Double _appliedSpeedRatio;
#region Linking data
internal Timeline _timeline;
internal TimeManager _timeManager;
internal ClockGroup _parent; // Parents can only be ClockGroups since
// they're the only ones having children
internal int _childIndex;
internal int _depth;
static Int64 s_TimeSpanTicksPerSecond = TimeSpan.FromSeconds(1).Ticks;
#endregion // Linking data
#region Debug data
#if DEBUG
internal int _debugIdentity;
internal static int _nextIdentity;
internal static Hashtable _objectTable = new Hashtable();
internal static object _debugLockObject = new object();
#endif // DEBUG
#endregion // Debug data
#endregion // Data
}
}
// 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
- IUnknownConstantAttribute.cs
- SendKeys.cs
- ToolStripRenderer.cs
- DataTableReader.cs
- ExtensionQuery.cs
- ListViewInsertedEventArgs.cs
- RoutedEventValueSerializer.cs
- DesignTimeParseData.cs
- BinaryObjectInfo.cs
- CodeNamespace.cs
- Decimal.cs
- StringBuilder.cs
- Expressions.cs
- ConnectionStringsExpressionEditor.cs
- EncoderBestFitFallback.cs
- EventlogProvider.cs
- TextRunProperties.cs
- FrameworkTextComposition.cs
- RadioButtonAutomationPeer.cs
- XmlSchemaElement.cs
- ButtonBase.cs
- DocumentViewerHelper.cs
- HtmlTextArea.cs
- DefaultPropertiesToSend.cs
- CompiledQuery.cs
- NumberFunctions.cs
- StylusPointProperty.cs
- AvtEvent.cs
- ImageUrlEditor.cs
- KnownBoxes.cs
- SettingsBindableAttribute.cs
- Constraint.cs
- CodeIterationStatement.cs
- CompositeScriptReferenceEventArgs.cs
- Win32.cs
- ICspAsymmetricAlgorithm.cs
- ImageFormatConverter.cs
- Parameter.cs
- ImageProxy.cs
- WrappedKeySecurityTokenParameters.cs
- MediaSystem.cs
- CompressStream.cs
- DataGridViewCellStyleChangedEventArgs.cs
- TextTreeRootTextBlock.cs
- TextFormatterContext.cs
- SafeBitVector32.cs
- Splitter.cs
- PreProcessor.cs
- SqlRowUpdatedEvent.cs
- DataRowCollection.cs
- IncomingWebRequestContext.cs
- ParagraphResult.cs
- TemplateInstanceAttribute.cs
- WebPartDeleteVerb.cs
- DataRowView.cs
- ClientRolePrincipal.cs
- AsyncResult.cs
- MsmqInputMessagePool.cs
- HttpWriter.cs
- versioninfo.cs
- BackgroundFormatInfo.cs
- Single.cs
- SimplePropertyEntry.cs
- QfeChecker.cs
- Model3D.cs
- DependencyObject.cs
- DoubleCollectionValueSerializer.cs
- ProxyWebPartConnectionCollection.cs
- DoubleAnimationUsingPath.cs
- EdmFunction.cs
- ResourceKey.cs
- CompositionAdorner.cs
- MatrixCamera.cs
- UnsafeCollabNativeMethods.cs
- SQLDoubleStorage.cs
- IUnknownConstantAttribute.cs
- MailAddressCollection.cs
- MailWriter.cs
- ParameterModifier.cs
- QueryExpression.cs
- BorderGapMaskConverter.cs
- OneWayElement.cs
- EndpointNotFoundException.cs
- LinearGradientBrush.cs
- ping.cs
- odbcmetadatacollectionnames.cs
- DataBindingsDialog.cs
- XPathSelfQuery.cs
- indexingfiltermarshaler.cs
- SponsorHelper.cs
- MediaScriptCommandRoutedEventArgs.cs
- FrameworkEventSource.cs
- WebControlParameterProxy.cs
- XpsFixedDocumentReaderWriter.cs
- TranslateTransform.cs
- BindingExpressionUncommonField.cs
- Facet.cs
- PersistenceProviderElement.cs
- ModuleElement.cs
- SettingsSavedEventArgs.cs