public ClockState Tick(TimeSpan time)
{
ClockState state = clock.Tick(time - offset);
TimeSpan previousTick = state.PreviousTick == Granular.Compatibility.TimeSpan.MinValue ? Granular.Compatibility.TimeSpan.MinValue : offset + state.PreviousTick;
TimeSpan nextTick = state.NextTick == Granular.Compatibility.TimeSpan.MaxValue ? Granular.Compatibility.TimeSpan.MaxValue : offset + state.NextTick;
return(new ClockState(state.ProgressState, state.Progress, state.Iteration, previousTick, nextTick));
}
public ClockState Tick(TimeSpan time)
{
ClockState state = clock.Tick(time - beginTime);
TimeSpan previousTick = state.PreviousTick == Granular.Compatibility.TimeSpan.MinValue ? Granular.Compatibility.TimeSpan.MinValue : beginTime + state.PreviousTick;
TimeSpan nextTick = state.NextTick == Granular.Compatibility.TimeSpan.MaxValue ? Granular.Compatibility.TimeSpan.MaxValue : beginTime + state.NextTick;
this.CurrentState = new ClockState(state.ProgressState, state.Progress, state.Iteration, previousTick, nextTick);
Invalidated.Raise(this);
return(CurrentState);
}
public ClockState Tick(TimeSpan time)
{
if (time < FirstTick)
{
CurrentState = new ClockState(ClockProgressState.BeforeStarted, 0, 0, Granular.Compatibility.TimeSpan.MinValue, FirstTick);
}
else if (time < LastTick)
{
CurrentState = new ClockState(ClockProgressState.Active, (time - FirstTick).Divide(LastTick - FirstTick), 0, time, time);
}
else
{
CurrentState = new ClockState(ClockProgressState.AfterEnded, 1, 0, LastTick, Granular.Compatibility.TimeSpan.MaxValue);
}
return CurrentState;
}
public ClockState Tick(TimeSpan time)
{
ClockProgressState progressState;
if (time < FirstTick)
{
progressState = ClockProgressState.BeforeStarted;
}
else if (time < LastTick)
{
progressState = ClockProgressState.Active;
}
else
{
progressState = ClockProgressState.AfterEnded;
}
TimeSpan previousTick = Granular.Compatibility.TimeSpan.MinValue;
TimeSpan nextTick = Granular.Compatibility.TimeSpan.MaxValue;
TimeSpan totalDuration = TimeSpan.Zero;
foreach (IClock clock in clocks)
{
ClockState state = clock.Tick(time - totalDuration);
if (state.PreviousTick != Granular.Compatibility.TimeSpan.MinValue)
{
previousTick = previousTick.Max(state.PreviousTick + totalDuration);
}
if (state.NextTick != Granular.Compatibility.TimeSpan.MaxValue)
{
nextTick = nextTick.Min(state.NextTick + totalDuration);
}
totalDuration += clock.Duration;
}
return(new ClockState(progressState, 0, 0, previousTick, nextTick));
}
public ClockState Tick(TimeSpan time)
{
if (time < TimeSpan.Zero)
{
ClockState state = clock.Tick(TimeSpan.Zero);
TimeSpan previousTick = Granular.Compatibility.TimeSpan.MinValue;
TimeSpan nextTick = TimeSpan.Zero;
return(new ClockState(ClockProgressState.BeforeStarted, state.Progress, state.Iteration, previousTick, nextTick));
}
if (time >= Duration)
{
ClockState state = clock.Tick(Duration);
TimeSpan previousTick = Duration;
TimeSpan nextTick = Granular.Compatibility.TimeSpan.MaxValue;
return(new ClockState(ClockProgressState.AfterEnded, state.Progress, state.Iteration, previousTick, nextTick));
}
return(clock.Tick(time));
}
public void Tick(TimeSpan time)
{
ClockState state = Clock.Tick(time);
NextTick = state.NextTick;
}
public ClockState Tick(TimeSpan time)
{
double iteration = time.Divide(iterationDuration);
ClockProgressState progressState = time < FirstTick ? ClockProgressState.BeforeStarted : (time >= LastTick ? ClockProgressState.AfterEnded : ClockProgressState.Active);
iteration = Math.Min(Math.Max(iteration, 0), iterationsCount);
double iterationRemainder = iteration - Math.Floor(iteration);
TimeSpan currentIterationStart;
TimeSpan currentIterationTime;
if (progressState == ClockProgressState.AfterEnded && iterationRemainder == 0)
{
currentIterationStart = iterationDuration.Scale(iteration - 1);
currentIterationTime = iterationDuration;
}
else
{
currentIterationStart = iterationDuration.Scale(iteration - iterationRemainder);
currentIterationTime = iterationDuration.Scale(iterationRemainder);
}
ClockState state = clock.Tick(currentIterationTime);
TimeSpan previousTick;
TimeSpan nextTick;
if (time < FirstTick)
{
previousTick = Granular.Compatibility.TimeSpan.MinValue;
nextTick = FirstTick;
}
else if (time >= LastTick)
{
previousTick = LastTick;
nextTick = Granular.Compatibility.TimeSpan.MaxValue;
}
else
{
if (currentIterationTime > clock.FirstTick || Math.Floor(iteration) == 0)
{
previousTick = (currentIterationStart + state.PreviousTick).Max(FirstTick);
}
else
{
previousTick = (currentIterationStart - iterationDuration + clock.LastTick).Max(FirstTick);
}
if (currentIterationTime < clock.LastTick || Math.Floor(iteration) == Math.Floor(iterationsCount))
{
nextTick = (currentIterationStart + state.NextTick).Min(LastTick);
}
else
{
nextTick = (currentIterationStart + iterationDuration + clock.FirstTick).Min(LastTick);
}
}
if (progressState == ClockProgressState.Active)
{
progressState = state.ProgressState;
}
return(new ClockState(progressState, state.Progress, iteration, previousTick, nextTick));
}
internal void StepTime(int milliseconds)
{
if (myClockState != ClockState.Active)
return;
myCurrentGlobalTime += milliseconds;
OnClockChanged();
if (myCurrentGlobalTime >= myTotalTime)
{
myClockState = ClockState.Stopped;
mySystem.RemoveClock(this);
}
}