| java.lang.Object
 com.sun.perseus.model.TimedElementSupport
All known Subclasses: com.sun.perseus.model.TimeContainerSupport,
| TimedElementSupport | | public class TimedElementSupport (Code) | | The TimedElementSupport class is the main abstraction of the
SMIL timing model implementation.
It is responsible for computing the animation's state (inactive, active,
post-acitve, frozen) and, when the application is active, what the current
simple time is. That simple time is then used by the animation engine to
compute animated values.
SMIL has a notion of time containers. A TimedElementSupport
is the child of a time container. The relationship is that the element's
current time is the container's simple time. In otherwords, sampling a
container for a given time (in its own container), yields a simple time for
the container. That simple time is the timed element's current time, used to
compute the timed element's own simple time. Refer to the SMIL 2
specification for an explanation of what the various time semantics are.
version:
$Id: TimedElementSupport.java,v 1.7 2006/07/13 00:55:58 st125089 Exp $ |
| Method Summary | |
| public void | activate()
Called when this element is the target of an hyperlink. | | void | addInstance(boolean isBegin, long offset)
| | void | addTimeCondition(TimeCondition newCondition)
Called by TimeConditions when they are constructed.
Parameters:
newCondition - the new TimeCondition to add to the list. | | void | addTimeInstance(TimeInstance newInstance)
Called to add a new TimeInstance to the begin or end
instance list (depending on the new instance's isBegin
setting).
This is also called as a result of invoking beginAt or endAt.
Parameters:
newInstance - the new TimeInstance to add to the list. | | public void | begin()
Calling this method causes a new TimeInstance to
be inserted in the begin instance list. | | public void | beginAt(long offset)
Calling this method causes a new TimeInstance to
be inserted in the begin instance list. | | Time | calculateActiveEnd(Time begin, Time end)
Computes the active end of this TimedElement for
the given begin and end time constraints. | | final Time | calculateIntermediateActiveDuration(Time p0)
Intermediate Active Duration Computation, as defined in the
SMIL 2 specifications. | | boolean | checkNewInterval(TimeInterval interval)
Checks if the input interval is non null. | | public void | checkPreInit()
Implementation helper. | | Time | computeEndTime(Time tempBegin)
Computes the end time corresponding to the input begin time.
Parameters:
tempBegin - the begin time for which to search an end time. | | TimeInterval | computeFirstInterval()
The following computes the element's first interval, as defined
in the SMIL specification. | | TimeInterval | computeLastDur(TimeInterval ti)
Computes the time of the last simple duration instance
for the given time interval.
Parameters:
ti - the TimeInterval instance for which the time of the lastsimple duration instance should be computed. | | TimeInterval | computeNextInterval()
The following computes the element's next interval, as defined
in the SMIL specification. | | final Time | computeSimpleDuration(Time end)
Computes the element's simple duration, as defined in the
SMIL 2 specification except that the 'media' value is
not supported.
For the purpose of computing the simple duration, an unspecified
dur or an UNRESOLVED dur yield the same computed simple duration.
Parameters:
end - the interval end time. | | void | dispatchBeginEvent(Time currentTime)
Dispatches beginEvent. | | void | dispatchEndEvent(Time currentTime)
Dispatches endEvent. | | void | dispatchLastDurEndEvent()
Dispatches lastDurEndEvent. | | void | dispatchOnNewInterval()
Calls all the registered TimeDependents so that they
are notified of a new TimeInterval creation. | | void | dispatchRepeatEvent(Time currentTime)
Dispatches repeatEvent. | | void | dispatchSeekEndEvent()
Dispatches seekeEndEvent. | | public void | end()
Calling this method causes a new TimeInstance to
be inserted in the end instance list. | | public void | endAt(long offset)
Calling this method causes a new TimeInstance to
be inserted in the end instance list. | | boolean | endHasEventConditions()
| | Time | getContainerSimpleDuration()
| | Time | getCurrentTime()
| | protected Time | getImplicitElementDuration()
this element's implicit duration. | | TimeContainerRootSupport | getRootContainer()
Helper method. | | String | getStateString()
Debug helper. | | Time | getTimeAfter(Time after, Vector instances)
Parameters:
after - we are looking for a time greater than or equalto after.
Parameters:
instances - the Vector containing the TimeInstances tolook up. | | Time | getTimeAfterStrict(Time after, Vector instances)
Parameters:
after - we are looking for a time greater than or equalto after.
Parameters:
instances - the Vector containing the TimeInstances tolook up. | | protected TimeContainerSupport | getTimeContainer()
| | boolean | hasBeginCondition(EventBaseCondition eventCondition)
Parameters:
eventCondition - the EventBaseCondition to checkagainst. | | protected void | initialize()
This method is called by the element's time container when it
resets, i.e., when the container starts it's simple time again.
This has the effect of:
1. | | boolean | isDescendant(TimeContainerSupport parent)
Parameters:
parent - the time container which might be on the timed element'sparent hierarchy. | | boolean | isSeekingBack()
Helper method. | | protected void | onStartingRepeat(int prevIter, int curIter)
To be overridden by extensions (TimeContainerSupport) to do specific
processing when a new iteration is started. | | void | onTimeInstanceUpdate(TimeInstance timeInstance)
Called by TimeInstances when they are updated.
In response, the TimedElement may recompute its current
interval. | | void | reEvaluateEndTime()
Recomputes the end time. | | void | removeSyncBaseTimesUnder(TimeContainerSupport syncTimeContainer)
| | void | removeTimeInstance(TimeInstance timeInstance)
Called to remove a TimeInstance when a
TimeInterval is pruned. | | void | reset()
Resetting the element clears all of its 'clearOnReset' instances from the
begin and end list. | | void | sample(Time currentTime)
This method is typically called by this element's time container
when it samples.
Note that if this element is not in the waiting or playing
state, this does nothing. | | void | sampleAt(long simpleTime)
Samples this element at the given simple time. | | void | seekTo(Time seekToTime)
Implementation helper method for seekTo behavior.
Parameters:
seekToTime - the time to seek to. | | TimeInterval | seekToInterval(Time seekToTime)
Helper method to find the active interval, or next interval, for
the requested time.
Parameters:
seekToTime - the time we are seeking the active or next intervalfor. | | public void | setDur(Time dur)
| | public void | setFillBehavior(int fillBehavior)
Sets the fill state behavior. | | public void | setMax(Time max)
Sets the maximun active duration for any timed element
interval.
Parameters:
max - the new maximum active duration. | | public void | setMin(Time min)
Sets the minimum active duration for any timed element interval.
Parameters:
min - the new minimum active duration. | | public void | setRepeatCount(float repeatCount)
Sets the repeat count.
Parameters:
repeatCount - the new repeat count. | | public void | setRepeatDur(Time repeatDur)
Sets the repeat duration. | | public void | setRestart(int restart)
Sets the restart strategy. | | protected void | setTimeContainer(TimeContainerSupport timeContainer)
| | Time | toContainerSimpleTime(Time simpleTime)
Converts the input root container simple time (i.e., a time in the root
container's simple time interval) to a time in this element's time
container simple duration. | | Time | toRootContainerSimpleTime(Time simpleTime)
Converts the input simple time (i.e., a time in the parent container's
simple duration) to a root container simple time (i.e., a time
in the root time container's simple time interval). | | Time | toRootContainerSimpleTimeClamp(Time simpleTime)
Same definition and behavior as toRootContainerSimpleTime, except that
this method clamps values to the container's simple duration. | | public String | toString()
Debug helper. | | long | toWallClockTime(long localTime)
Converts the input 'local' time to an absolute wallclock time. |
| BEGIN_EVENT_TYPE | | final public static String BEGIN_EVENT_TYPE(Code) | | Begin event type.
|
| END_EVENT_TYPE | | final public static String END_EVENT_TYPE(Code) | | End event type.
|
| FILL_BEHAVIOR_FREEZE | | final public static int FILL_BEHAVIOR_FREEZE(Code) | | Used when this TimedElement should maintain the
last value of its simple interval after it becomes inactive.
|
| FILL_BEHAVIOR_REMOVE | | final public static int FILL_BEHAVIOR_REMOVE(Code) | | Used when this TimedElement should not modify the
animated value when it is post active.
|
| LAST_DUR_END_EVENT_TYPE | | final public static String LAST_DUR_END_EVENT_TYPE(Code) | | Last Simple Duration End event type.
|
| REPEAT_EVENT_TYPE | | final public static String REPEAT_EVENT_TYPE(Code) | | Repeat event type
|
| RESTART_ALWAYS | | final public static int RESTART_ALWAYS(Code) | | Used when this TimedElement can be restarted under
any circumstance.
|
| RESTART_NEVER | | final public static int RESTART_NEVER(Code) | | Used when this TimedElement cannot be restarted under
any circumstance
|
| RESTART_WHEN_NOT_ACTIVE | | final public static int RESTART_WHEN_NOT_ACTIVE(Code) | | Used when this TimedElement can only be restarted when
it is not active (i.e., it does not have a current interval.
|
| SEEK_BEGIN_EVENT_TYPE | | final public static String SEEK_BEGIN_EVENT_TYPE(Code) | | Seek End event type.
|
| SEEK_END_EVENT_TYPE | | final public static String SEEK_END_EVENT_TYPE(Code) | | Seek End event type.
|
| STATE_FILL | | final protected static int STATE_FILL(Code) | | State when the element performs any fill on the previous
interval.
|
| STATE_NO_INTERVAL | | final protected static int STATE_NO_INTERVAL(Code) | | State where there has never been a current interval
(since the last init).
|
| STATE_PLAYING | | final protected static int STATE_PLAYING(Code) | | State while the element is playing the current
interval.
|
| STATE_PRE_INIT | | final protected static int STATE_PRE_INIT(Code) | | State before the element has been initialized
|
| STATE_WAITING_INTERVAL_0 | | final protected static int STATE_WAITING_INTERVAL_0(Code) | | State while the element is waiting to begin
the first interval.
|
| STATE_WAITING_INTERVAL_N | | final protected static int STATE_WAITING_INTERVAL_N(Code) | | State while the element is waiting to begin
an interval other than the first one
|
| animationElement | | ModelNode animationElement(Code) | | The associated animation element.
|
| beginConditions | | Vector beginConditions(Code) | | Begin TimeConditions. Should _never_ be null.
|
| beginDependents | | Vector beginDependents(Code) | | List of SyncBaseConditions depedent on this
element's begin condition.
|
| beginInstances | | Vector beginInstances(Code) | | List of begin TimeInstances.
|
| curIter | | int curIter(Code) | | The current iteration (only used while playing
|
| currentInterval | | TimeInterval currentInterval(Code) | | Keeps a reference to the current TimeInterval
|
| endConditions | | Vector endConditions(Code) | | End TimeConditions. Should _never_ be null.
|
| endDependents | | Vector endDependents(Code) | | List of SyncBaseConditions dependent on this
element's end condition.
|
| endInstances | | Vector endInstances(Code) | | List of end TimeInstances.
|
| eventTime | | final protected Time eventTime(Code) | | This time value is used to avoid creating Time instances
over and over again in animation loops, when dispatching
events.
|
| fillBehavior | | int fillBehavior(Code) | | Defines the behavior after this element is no longer active.
If FILL_BEHAVIOR_FILL, it means the element will keep sampling at the
last simple duration time. If FILL_BEHAVIOR_REMOVE (the default),
the effect of the animation is removed when the element is
inactive (i.e., when it no longer has a current interval.
|
| implicitDuration | | Time implicitDuration(Code) | | This element's implicit duration
|
| lastSampleTime | | long lastSampleTime(Code) | | Last local time (i.e., within the simple duration) this element
was sampled at.
|
| max | | Time max(Code) | | max sets an upper limit on the active duration
|
| min | | Time min(Code) | | min sets a lower limit on the active duration.
|
| playFill | | boolean playFill(Code) | | Controls whether the element is in this rare state
where it is playing but its last simple duration
is finished. In that state, the element is 'playing',
but acting as if frozen.
There are situations where the min attribute may cause the
active duration to go beyond the time of the last simple
duration instance. In that case, the element is still
in the playing state, but we mark it as 'playFill', which
means that it should behave almost as if in the fill state.
|
| previousInterval | | TimeInterval previousInterval(Code) | | Keeps a reference to the interval preceding the current one.
|
| repeatCount | | float repeatCount(Code) | | The number of times this element repeats the simple duration.
NaN means unspecified.
|
| repeatDur | | Time repeatDur(Code) | | repeatDur set a limit on active duration length.
|
| restart | | int restart(Code) | | Defines the restart behavior for this element. This should be
one of RESTART_ALWAYS, RESTART_WHEN_NOT_ACTIVE, RESTART_NEVER.
|
| seeking | | boolean seeking(Code) | | The seeking flag is used when seeking to a particular time
to prevent generation of beginEvent, endEvent and repeat
event.
|
| state | | int state(Code) | | The element's state. One of the STATE_XXX constants.
|
| timingUpdate | | boolean timingUpdate(Code) | | Time dependency cycles detector. This flag is set to true
when a timing update starts. There should only be one at
a time, and it should always be set back to true after
and timing update is complete.
|
| activate | | public void activate()(Code) | | Called when this element is the target of an hyperlink. The
behavior is that defined in the SMIL 2 specification.
See Also:
* SMIL 2 Specification |
| addInstance | | void addInstance(boolean isBegin, long offset)(Code) | | Adds a new TimedInstance with the specified offset
to the begin or end instance list (depending on isBegin
Parameters:
isBegin - if true, the instance is a begin instance
Parameters:
offset - the instance offset from 0. |
| addTimeCondition | | void addTimeCondition(TimeCondition newCondition)(Code) | | Called by TimeConditions when they are constructed.
Parameters:
newCondition - the new TimeCondition to add to the list. Should not be null. |
| begin | | public void begin()(Code) | | Calling this method causes a new TimeInstance to
be inserted in the begin instance list. The behavior depends
on the restart setting.
|
| beginAt | | public void beginAt(long offset)(Code) | | Calling this method causes a new TimeInstance to
be inserted in the begin instance list. The behavior depends
on the restart setting.
Parameters:
offset - the begin time inserted into the instance listis offset by 'offset' milliseconds from the currenttime. |
| calculateActiveEnd | | Time calculateActiveEnd(Time begin, Time end)(Code) | | Computes the active end of this TimedElement for
the given begin and end time constraints. This accounts for
the other attributes which control or constrain the
active duration.
Parameters:
begin - the input begin time. Should not be unresolved or null.
Parameters:
end - the proposed end time. May be null. the computed, constrained end time.
See Also:
* SMIL 2: Computing the active duration |
| calculateIntermediateActiveDuration | | final Time calculateIntermediateActiveDuration(Time p0)(Code) | | Intermediate Active Duration Computation, as defined in the
SMIL 2 specifications.
Parameters:
p0 - the element's simple duration. Should not be null the intermediate active duration.
See Also:
* Intermediate Active Duration Computation |
| checkNewInterval | | boolean checkNewInterval(TimeInterval interval)(Code) | | Checks if the input interval is non null. If it is, that interval
becomes the new currentInterval and the element sets its state
accordingly.
Parameters:
interval - the interval to check. true if the candidate interval has become the current interval. |
| checkPreInit | | public void checkPreInit()(Code) | | Implementation helper. Throws an exception if the element is
not in the STATE_PRE_INIT state.
throws:
IllegalStateException - if the element is not in theSTATE_PRE_INIT state. |
| computeEndTime | | Time computeEndTime(Time tempBegin)(Code) | | Computes the end time corresponding to the input begin time.
Parameters:
tempBegin - the begin time for which to search an end time. the computed end time or null if there is no matching end. |
| computeLastDur | | TimeInterval computeLastDur(TimeInterval ti)(Code) | | Computes the time of the last simple duration instance
for the given time interval.
Parameters:
ti - the TimeInterval instance for which the time of the lastsimple duration instance should be computed. the input TimeInterval instance. |
| computeNextInterval | | TimeInterval computeNextInterval()(Code) | | The following computes the element's next interval, as defined
in the SMIL specification.
the next interval given the current begin and end time instances.
See Also:
* End of an interval |
| computeSimpleDuration | | final Time computeSimpleDuration(Time end)(Code) | | Computes the element's simple duration, as defined in the
SMIL 2 specification except that the 'media' value is
not supported.
For the purpose of computing the simple duration, an unspecified
dur or an UNRESOLVED dur yield the same computed simple duration.
Parameters:
end - the interval end time. Can be null or have any Timevalue. the computed simple duration.
See Also:
* Defining the simple duration |
| dispatchBeginEvent | | void dispatchBeginEvent(Time currentTime)(Code) | | Dispatches beginEvent. As per the SMIL 2 specification, this dispatches
a beginEvent for the resolved begin time, not the observed begin
time. It also dispatches any repeat event that might be needed.
Parameters:
currentTime - the current sampling time.
See Also:
* SMIL2's Begin value semantics |
| dispatchEndEvent | | void dispatchEndEvent(Time currentTime)(Code) | | Dispatches endEvent. As per the SMIL 2 specification, this dispatches an
endEvent for the resolved end time, not the observed end time.
Parameters:
currentTime - the current sampling time.
See Also:
* SMIL2's Begin value semantics |
| dispatchLastDurEndEvent | | void dispatchLastDurEndEvent()(Code) | | Dispatches lastDurEndEvent.
See Also: | dispatchOnNewInterval | | void dispatchOnNewInterval()(Code) | | Calls all the registered TimeDependents so that they
are notified of a new TimeInterval creation.
|
| dispatchRepeatEvent | | void dispatchRepeatEvent(Time currentTime)(Code) | | Dispatches repeatEvent. As per the SMIL 2 specification, this dispatches
a repeatEvent for the resolved end time, not the observed repeat
time(s).
See Also:
* SMIL2's Begin value semantics |
| dispatchSeekEndEvent | | void dispatchSeekEndEvent()(Code) | | Dispatches seekeEndEvent.
See Also: | end | | public void end()(Code) | | Calling this method causes a new TimeInstance to
be inserted in the end instance list. This typically causes
the current interval (if any), to be ended.
|
| endAt | | public void endAt(long offset)(Code) | | Calling this method causes a new TimeInstance to
be inserted in the end instance list. This typically causes
the current interval (if any), to be ended.
Parameters:
offset - the end time inserted into the instance listis offset by 'offset' milliseconds from the currenttime. |
| endHasEventConditions | | boolean endHasEventConditions()(Code) | | true if there is at least one event end condition. |
| getContainerSimpleDuration | | Time getContainerSimpleDuration()(Code) | | the container's simple duration. |
| getCurrentTime | | Time getCurrentTime()(Code) | | this TimedElement's current time. |
| getImplicitElementDuration | | protected Time getImplicitElementDuration()(Code) | | this element's implicit duration. Can be used for media suchas audio and video where there is a natural, implicit duration. |
| getStateString | | String getStateString()(Code) | | Debug helper. Converts the state to a string.
a string describing the element's state. |
| getTimeAfter | | Time getTimeAfter(Time after, Vector instances)(Code) | |
Parameters:
after - we are looking for a time greater than or equalto after.
Parameters:
instances - the Vector containing the TimeInstances tolook up. the first value in the given instance list thatstarts after the input time. |
| getTimeAfterStrict | | Time getTimeAfterStrict(Time after, Vector instances)(Code) | |
Parameters:
after - we are looking for a time greater than or equalto after.
Parameters:
instances - the Vector containing the TimeInstances tolook up. the first value in the given instance list thatstarts strictly after the input time. |
| hasBeginCondition | | boolean hasBeginCondition(EventBaseCondition eventCondition)(Code) | |
Parameters:
eventCondition - the EventBaseCondition to checkagainst. true if this TimedElement has a begin conditioncorresponding to the input EventBaseCondition |
| initialize | | protected void initialize()(Code) | | This method is called by the element's time container when it
resets, i.e., when the container starts it's simple time again.
This has the effect of:
1. clearing all the instance times which have the clearOnReset
flag set to true.
2. compute the first interval.
|
| isDescendant | | boolean isDescendant(TimeContainerSupport parent)(Code) | |
Parameters:
parent - the time container which might be on the timed element'sparent hierarchy. true if this timed element is equal to 'parent' or is a descendant of 'parent' |
| isSeekingBack | | boolean isSeekingBack()(Code) | | Helper method.
true if the root time container is flagged as seeking back. |
| onStartingRepeat | | protected void onStartingRepeat(int prevIter, int curIter)(Code) | | To be overridden by extensions (TimeContainerSupport) to do specific
processing when a new iteration is started.
Parameters:
prevIter - the last iteration this element was playing.
Parameters:
curIter - the new iteration this element is playing. |
| reEvaluateEndTime | | void reEvaluateEndTime()(Code) | | Recomputes the end time. This only does something if the
element is playing or waiting to play, because it may update
the currentInterval's end time.
|
| removeSyncBaseTimesUnder | | void removeSyncBaseTimesUnder(TimeContainerSupport syncTimeContainer)(Code) | | Removes all IntervalTimeInstances in the begin and end
instance list if the syncBase is a descendant of syncTimeContainer
Parameters:
syncTimeContainer - the container under whichIntervalTimeInstance should be removed. |
| removeTimeInstance | | void removeTimeInstance(TimeInstance timeInstance)(Code) | | Called to remove a TimeInstance when a
TimeInterval is pruned. This causes a re-evaluation
of the current interval's begin or end time.
Parameters:
timeInstance - the instance to remove from its instance list. |
| reset | | void reset()(Code) | | Resetting the element clears all of its 'clearOnReset' instances from the
begin and end list. This includes event based time instances, time
instances resulting from begin() or end() calls and resolved
IntervalTimeInstance.
|
| sample | | void sample(Time currentTime)(Code) | | This method is typically called by this element's time container
when it samples.
Note that if this element is not in the waiting or playing
state, this does nothing. This method assumes that successive
calls are made with increasing time values.
Parameters:
currentTime - the time at which this element should be sampled. |
| sampleAt | | void sampleAt(long simpleTime)(Code) | | Samples this element at the given simple time.
Should be overridden for specific behaviors.
Parameters:
simpleTime - this timed element simple time. |
| seekTo | | void seekTo(Time seekToTime)(Code) | | Implementation helper method for seekTo behavior.
Parameters:
seekToTime - the time to seek to. |
| seekToInterval | | TimeInterval seekToInterval(Time seekToTime)(Code) | | Helper method to find the active interval, or next interval, for
the requested time.
Parameters:
seekToTime - the time we are seeking the active or next intervalfor. the TimeInterval corresponding toseekToTime |
| setDur | | public void setDur(Time dur)(Code) | | Sets the duration for this timed element
Parameters:
dur - the new element duration.
throws:
IllegalStateException - if the element is not in theSTATE_PRE_INIT state. |
| setFillBehavior | | public void setFillBehavior(int fillBehavior)(Code) | | Sets the fill state behavior.
Parameters:
fillBehavior - the new fill strategy, one of FILL_BEHAVIOR_FREEZE orFILL_BEHAVIOR_REMOVE
throws:
IllegalStateException - if the element is not in the STATE_PRE_INIT state. |
| setMax | | public void setMax(Time max)(Code) | | Sets the maximun active duration for any timed element
interval.
Parameters:
max - the new maximum active duration. Should not benull.
throws:
IllegalStateException - if the element is not in theSTATE_PRE_INIT state. |
| setMin | | public void setMin(Time min)(Code) | | Sets the minimum active duration for any timed element interval.
Parameters:
min - the new minimum active duration. Should not be null.
throws:
IllegalStateException - if the element is not in theSTATE_PRE_INIT state. |
| setRepeatCount | | public void setRepeatCount(float repeatCount)(Code) | | Sets the repeat count.
Parameters:
repeatCount - the new repeat count. Must be greater thanzero.
throws:
IllegalStateException - if the element is not in theSTATE_PRE_INIT state. |
| setRepeatDur | | public void setRepeatDur(Time repeatDur)(Code) | | Sets the repeat duration.
Parameters:
repeatDur - the new repeat duration.
throws:
IllegalStateException - if the element is not in theSTATE_PRE_INIT state. |
| setRestart | | public void setRestart(int restart)(Code) | | Sets the restart strategy.
Parameters:
restart - the new restart strategy, one ofRESTART_ALWAYS, RESTART_NEVER or RESTART_WHEN_NOT_ACTIVE.
throws:
IllegalStateException - if the element is not in theSTATE_PRE_INIT state. |
| setTimeContainer | | protected void setTimeContainer(TimeContainerSupport timeContainer)(Code) | | Sets this timed element's time container
Parameters:
timeContainer - time container |
| toContainerSimpleTime | | Time toContainerSimpleTime(Time simpleTime)(Code) | | Converts the input root container simple time (i.e., a time in the root
container's simple time interval) to a time in this element's time
container simple duration. Note that this method mutates the input
argument. If the associated time container does not
have a current interval, this method returns Time.UNRESOLVED.
Parameters:
simpleTime - the time in the root container's simple duration. IfsimpleTime is Time.UNRESOLVED, the returned time is UNRESOLVED. IfsimpleTime is Time.INDEFINITE, the returned time is INDEFINITE. a simple time in the parent container's simple duration Thereturn value is in the [0, container simple duration] interval. |
| toRootContainerSimpleTime | | Time toRootContainerSimpleTime(Time simpleTime)(Code) | | Converts the input simple time (i.e., a time in the parent container's
simple duration) to a root container simple time (i.e., a time
in the root time container's simple time interval). Note that this method
mutates the input time value. If the associated time container does not
have a current interval, this method returns Time.UNRESOLVED.
Parameters:
simpleTime - the time in the parent container's simple duration.Should not be null. If simpleTime is Time.UNRESOLVED, the returnedtime is UNRESOLVED. If simpleTime is Time.INDEFINITE, the returnedtime is INDEFINITE. a time in the root time container's simple duration (i.e., in the root container's simple time interval). |
| toRootContainerSimpleTimeClamp | | Time toRootContainerSimpleTimeClamp(Time simpleTime)(Code) | | Same definition and behavior as toRootContainerSimpleTime, except that
this method clamps values to the container's simple duration. This
means that a value smaller than zero is converted to 0 and a value
greater than the simple duration is reduced to the simple duration.
Parameters:
simpleTime - the time in the parent container's simple duration.Should not be null. If simpleTime is Time.UNRESOLVED, the returnedtime is UNRESOLVED. If simpleTime is Time.INDEFINITE, the returnedtime is INDEFINITE. a time in the root time container's simple duration (i.e., in the root container's simple time interval). |
| toString | | public String toString()(Code) | | Debug helper.
a description of this object. |
| toWallClockTime | | long toWallClockTime(long localTime)(Code) | | Converts the input 'local' time to an absolute wallclock time.
Parameters:
localTime - the time to convert to wallclock time the time converted to an absolute wallclock time. |
|
|
|
|