1 : /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 : /* ***** BEGIN LICENSE BLOCK *****
3 : * Version: MPL 1.1/GPL 2.0/LGPL 2.1
4 : *
5 : * The contents of this file are subject to the Mozilla Public License Version
6 : * 1.1 (the "License"); you may not use this file except in compliance with
7 : * the License. You may obtain a copy of the License at
8 : * http://www.mozilla.org/MPL/
9 : *
10 : * Software distributed under the License is distributed on an "AS IS" basis,
11 : * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
12 : * for the specific language governing rights and limitations under the
13 : * License.
14 : *
15 : * The Original Code is the Mozilla SMIL module.
16 : *
17 : * The Initial Developer of the Original Code is Brian Birtles.
18 : * Portions created by the Initial Developer are Copyright (C) 2005
19 : * the Initial Developer. All Rights Reserved.
20 : *
21 : * Contributor(s):
22 : * Brian Birtles <birtles@gmail.com>
23 : *
24 : * Alternatively, the contents of this file may be used under the terms of
25 : * either of the GNU General Public License Version 2 or later (the "GPL"),
26 : * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
27 : * in which case the provisions of the GPL or the LGPL are applicable instead
28 : * of those above. If you wish to allow use of your version of this file only
29 : * under the terms of either the GPL or the LGPL, and not to allow others to
30 : * use your version of this file under the terms of the MPL, indicate your
31 : * decision by deleting the provisions above and replace them with the notice
32 : * and other provisions required by the GPL or the LGPL. If you do not delete
33 : * the provisions above, a recipient may use your version of this file under
34 : * the terms of any one of the MPL, the GPL or the LGPL.
35 : *
36 : * ***** END LICENSE BLOCK ***** */
37 :
38 : #ifndef NS_SMILTIMEDELEMENT_H_
39 : #define NS_SMILTIMEDELEMENT_H_
40 :
41 : #include "nsSMILInterval.h"
42 : #include "nsSMILInstanceTime.h"
43 : #include "nsSMILMilestone.h"
44 : #include "nsSMILTimeValueSpec.h"
45 : #include "nsSMILRepeatCount.h"
46 : #include "nsSMILTypes.h"
47 : #include "nsTArray.h"
48 : #include "nsTHashtable.h"
49 : #include "nsHashKeys.h"
50 : #include "nsAutoPtr.h"
51 : #include "nsAttrValue.h"
52 :
53 : class nsISMILAnimationElement;
54 : class nsSMILAnimationFunction;
55 : class nsSMILTimeContainer;
56 : class nsSMILTimeValue;
57 : class nsIAtom;
58 :
59 : //----------------------------------------------------------------------
60 : // nsSMILTimedElement
61 :
62 : class nsSMILTimedElement
63 : {
64 : public:
65 : nsSMILTimedElement();
66 : ~nsSMILTimedElement();
67 :
68 : typedef mozilla::dom::Element Element;
69 :
70 : /*
71 : * Sets the owning animation element which this class uses to convert between
72 : * container times and to register timebase elements.
73 : */
74 : void SetAnimationElement(nsISMILAnimationElement* aElement);
75 :
76 : /*
77 : * Returns the time container with which this timed element is associated or
78 : * nsnull if it is not associated with a time container.
79 : */
80 : nsSMILTimeContainer* GetTimeContainer();
81 :
82 : /*
83 : * Returns the element targeted by the animation element. Needed for
84 : * registering event listeners against the appropriate element.
85 : */
86 0 : mozilla::dom::Element* GetTargetElement()
87 : {
88 : return mAnimationElement ?
89 0 : mAnimationElement->GetTargetElementContent() :
90 0 : nsnull;
91 : }
92 :
93 : /**
94 : * Methods for supporting the nsIDOMElementTimeControl interface.
95 : */
96 :
97 : /*
98 : * Adds a new begin instance time at the current container time plus or minus
99 : * the specified offset.
100 : *
101 : * @param aOffsetSeconds A real number specifying the number of seconds to add
102 : * to the current container time.
103 : * @return NS_OK if the operation succeeeded, or an error code otherwise.
104 : */
105 : nsresult BeginElementAt(double aOffsetSeconds);
106 :
107 : /*
108 : * Adds a new end instance time at the current container time plus or minus
109 : * the specified offset.
110 : *
111 : * @param aOffsetSeconds A real number specifying the number of seconds to add
112 : * to the current container time.
113 : * @return NS_OK if the operation succeeeded, or an error code otherwise.
114 : */
115 : nsresult EndElementAt(double aOffsetSeconds);
116 :
117 : /**
118 : * Methods for supporting the nsSVGAnimationElement interface.
119 : */
120 :
121 : /**
122 : * According to SVG 1.1 SE this returns
123 : *
124 : * the begin time, in seconds, for this animation element's current
125 : * interval, if it exists, regardless of whether the interval has begun yet.
126 : *
127 : * @return the start time as defined above in milliseconds or an unresolved
128 : * time if there is no current interval.
129 : */
130 : nsSMILTimeValue GetStartTime() const;
131 :
132 : /**
133 : * Returns the simple duration of this element.
134 : *
135 : * @return the simple duration in milliseconds or INDEFINITE.
136 : */
137 0 : nsSMILTimeValue GetSimpleDuration() const
138 : {
139 0 : return mSimpleDur;
140 : }
141 :
142 : /**
143 : * Internal SMIL methods
144 : */
145 :
146 : /**
147 : * Adds an instance time object this element's list of instance times.
148 : * These instance times are used when creating intervals.
149 : *
150 : * This method is typically called by an nsSMILTimeValueSpec.
151 : *
152 : * @param aInstanceTime The time to add, expressed in container time.
153 : * @param aIsBegin true if the time to be added represents a begin
154 : * time or false if it represents an end time.
155 : */
156 : void AddInstanceTime(nsSMILInstanceTime* aInstanceTime, bool aIsBegin);
157 :
158 : /**
159 : * Requests this element update the given instance time.
160 : *
161 : * This method is typically called by a child nsSMILTimeValueSpec.
162 : *
163 : * @param aInstanceTime The instance time to update.
164 : * @param aUpdatedTime The time to update aInstanceTime with.
165 : * @param aDependentTime The instance time upon which aInstanceTime should be
166 : * based.
167 : * @param aIsBegin true if the time to be updated represents a begin
168 : * instance time or false if it represents an end
169 : * instance time.
170 : */
171 : void UpdateInstanceTime(nsSMILInstanceTime* aInstanceTime,
172 : nsSMILTimeValue& aUpdatedTime,
173 : bool aIsBegin);
174 :
175 : /**
176 : * Removes an instance time object from this element's list of instance times.
177 : *
178 : * This method is typically called by a child nsSMILTimeValueSpec.
179 : *
180 : * @param aInstanceTime The instance time to remove.
181 : * @param aIsBegin true if the time to be removed represents a begin
182 : * time or false if it represents an end time.
183 : */
184 : void RemoveInstanceTime(nsSMILInstanceTime* aInstanceTime, bool aIsBegin);
185 :
186 : /**
187 : * Removes all the instance times associated with the given
188 : * nsSMILTimeValueSpec object. Used when an ID assignment changes and hence
189 : * all the previously associated instance times become invalid.
190 : *
191 : * @param aSpec The nsSMILTimeValueSpec object whose created
192 : * nsSMILInstanceTime's should be removed.
193 : * @param aIsBegin true if the times to be removed represent begin
194 : * times or false if they are end times.
195 : */
196 : void RemoveInstanceTimesForCreator(const nsSMILTimeValueSpec* aSpec,
197 : bool aIsBegin);
198 :
199 : /**
200 : * Sets the object that will be called by this timed element each time it is
201 : * sampled.
202 : *
203 : * In Schmitz's model it is possible to associate several time clients with
204 : * a timed element but for now we only allow one.
205 : *
206 : * @param aClient The time client to associate. Any previous time client
207 : * will be disassociated and no longer sampled. Setting this
208 : * to nsnull will simply disassociate the previous client, if
209 : * any.
210 : */
211 : void SetTimeClient(nsSMILAnimationFunction* aClient);
212 :
213 : /**
214 : * Samples the object at the given container time. Timing intervals are
215 : * updated and if this element is active at the given time the associated time
216 : * client will be sampled with the appropriate simple time.
217 : *
218 : * @param aContainerTime The container time at which to sample.
219 : */
220 : void SampleAt(nsSMILTime aContainerTime);
221 :
222 : /**
223 : * Performs a special sample for the end of an interval. Such a sample should
224 : * only advance the timed element (and any dependent elements) to the waiting
225 : * or postactive state. It should not cause a transition to the active state.
226 : * Transition to the active state is only performed on a regular SampleAt.
227 : *
228 : * This allows all interval ends at a given time to be processed first and
229 : * hence the new interval can be established based on full information of the
230 : * available instance times.
231 : *
232 : * @param aContainerTime The container time at which to sample.
233 : */
234 : void SampleEndAt(nsSMILTime aContainerTime);
235 :
236 : /**
237 : * Informs the timed element that its time container has changed time
238 : * relative to document time. The timed element therefore needs to update its
239 : * dependent elements (which may belong to a different time container) so they
240 : * can re-resolve their times.
241 : */
242 : void HandleContainerTimeChange();
243 :
244 : /**
245 : * Resets this timed element's accumulated times and intervals back to start
246 : * up state.
247 : *
248 : * This is used for backwards seeking where rather than accumulating
249 : * historical timing state and winding it back, we reset the element and seek
250 : * forwards.
251 : */
252 : void Rewind();
253 :
254 : /**
255 : * Attempts to set an attribute on this timed element.
256 : *
257 : * @param aAttribute The name of the attribute to set. The namespace of this
258 : * attribute is not specified as it is checked by the host
259 : * element. Only attributes in the namespace defined for
260 : * SMIL attributes in the host language are passed to the
261 : * timed element.
262 : * @param aValue The attribute value.
263 : * @param aResult The nsAttrValue object that may be used for storing the
264 : * parsed result.
265 : * @param aContextNode The element to use for context when resolving
266 : * references to other elements.
267 : * @param[out] aParseResult The result of parsing the attribute. Will be set
268 : * to NS_OK if parsing is successful.
269 : *
270 : * @return true if the given attribute is a timing attribute, false
271 : * otherwise.
272 : */
273 : bool SetAttr(nsIAtom* aAttribute, const nsAString& aValue,
274 : nsAttrValue& aResult, Element* aContextNode,
275 : nsresult* aParseResult = nsnull);
276 :
277 : /**
278 : * Attempts to unset an attribute on this timed element.
279 : *
280 : * @param aAttribute The name of the attribute to set. As with SetAttr the
281 : * namespace of the attribute is not specified (see
282 : * SetAttr).
283 : *
284 : * @return true if the given attribute is a timing attribute, false
285 : * otherwise.
286 : */
287 : bool UnsetAttr(nsIAtom* aAttribute);
288 :
289 : /**
290 : * Adds a syncbase dependency to the list of dependents that will be notified
291 : * when this timed element creates, deletes, or updates its current interval.
292 : *
293 : * @param aDependent The nsSMILTimeValueSpec object to notify. A raw pointer
294 : * to this object will be stored. Therefore it is necessary
295 : * for the object to be explicitly unregistered (with
296 : * RemoveDependent) when it is destroyed.
297 : */
298 : void AddDependent(nsSMILTimeValueSpec& aDependent);
299 :
300 : /**
301 : * Removes a syncbase dependency from the list of dependents that are notified
302 : * when the current interval is modified.
303 : *
304 : * @param aDependent The nsSMILTimeValueSpec object to unregister.
305 : */
306 : void RemoveDependent(nsSMILTimeValueSpec& aDependent);
307 :
308 : /**
309 : * Determines if this timed element is dependent on the given timed element's
310 : * begin time for the interval currently in effect. Whilst the element is in
311 : * the active state this is the current interval and in the postactive or
312 : * waiting state this is the previous interval if one exists. In all other
313 : * cases the element is not considered a time dependent of any other element.
314 : *
315 : * @param aOther The potential syncbase element.
316 : * @return true if this timed element's begin time for the currently
317 : * effective interval is directly or indirectly derived from aOther, false
318 : * otherwise.
319 : */
320 : bool IsTimeDependent(const nsSMILTimedElement& aOther) const;
321 :
322 : /**
323 : * Called when the timed element has been bound to the document so that
324 : * references from this timed element to other elements can be resolved.
325 : *
326 : * @param aContextNode The node which provides the necessary context for
327 : * resolving references. This is typically the element in
328 : * the host language that owns this timed element. Should
329 : * not be null.
330 : */
331 : void BindToTree(nsIContent* aContextNode);
332 :
333 : /**
334 : * Called when the target of the animation has changed so that event
335 : * registrations can be updated.
336 : */
337 : void HandleTargetElementChange(mozilla::dom::Element* aNewTarget);
338 :
339 : /**
340 : * Called when the timed element has been removed from a document so that
341 : * references to other elements can be broken.
342 : */
343 0 : void DissolveReferences() { Unlink(); }
344 :
345 : // Cycle collection
346 : void Traverse(nsCycleCollectionTraversalCallback* aCallback);
347 : void Unlink();
348 :
349 : typedef bool (*RemovalTestFunction)(nsSMILInstanceTime* aInstance);
350 :
351 : protected:
352 : // Typedefs
353 : typedef nsTArray<nsAutoPtr<nsSMILTimeValueSpec> > TimeValueSpecList;
354 : typedef nsTArray<nsRefPtr<nsSMILInstanceTime> > InstanceTimeList;
355 : typedef nsTArray<nsAutoPtr<nsSMILInterval> > IntervalList;
356 : typedef nsPtrHashKey<nsSMILTimeValueSpec> TimeValueSpecPtrKey;
357 : typedef nsTHashtable<TimeValueSpecPtrKey> TimeValueSpecHashSet;
358 :
359 : // Helper classes
360 : class InstanceTimeComparator {
361 : public:
362 : bool Equals(const nsSMILInstanceTime* aElem1,
363 : const nsSMILInstanceTime* aElem2) const;
364 : bool LessThan(const nsSMILInstanceTime* aElem1,
365 : const nsSMILInstanceTime* aElem2) const;
366 : };
367 :
368 : struct NotifyTimeDependentsParams {
369 : nsSMILTimedElement* mTimedElement;
370 : nsSMILTimeContainer* mTimeContainer;
371 : };
372 :
373 : // Templated helper functions
374 : template <class TestFunctor>
375 : void RemoveInstanceTimes(InstanceTimeList& aArray, TestFunctor& aTest);
376 :
377 : //
378 : // Implementation helpers
379 : //
380 :
381 : nsresult SetBeginSpec(const nsAString& aBeginSpec,
382 : Element* aContextNode,
383 : RemovalTestFunction aRemove);
384 : nsresult SetEndSpec(const nsAString& aEndSpec,
385 : Element* aContextNode,
386 : RemovalTestFunction aRemove);
387 : nsresult SetSimpleDuration(const nsAString& aDurSpec);
388 : nsresult SetMin(const nsAString& aMinSpec);
389 : nsresult SetMax(const nsAString& aMaxSpec);
390 : nsresult SetRestart(const nsAString& aRestartSpec);
391 : nsresult SetRepeatCount(const nsAString& aRepeatCountSpec);
392 : nsresult SetRepeatDur(const nsAString& aRepeatDurSpec);
393 : nsresult SetFillMode(const nsAString& aFillModeSpec);
394 :
395 : void UnsetBeginSpec(RemovalTestFunction aRemove);
396 : void UnsetEndSpec(RemovalTestFunction aRemove);
397 : void UnsetSimpleDuration();
398 : void UnsetMin();
399 : void UnsetMax();
400 : void UnsetRestart();
401 : void UnsetRepeatCount();
402 : void UnsetRepeatDur();
403 : void UnsetFillMode();
404 :
405 : nsresult SetBeginOrEndSpec(const nsAString& aSpec,
406 : Element* aContextNode,
407 : bool aIsBegin,
408 : RemovalTestFunction aRemove);
409 : void ClearSpecs(TimeValueSpecList& aSpecs,
410 : InstanceTimeList& aInstances,
411 : RemovalTestFunction aRemove);
412 : void ClearIntervals();
413 : void DoSampleAt(nsSMILTime aContainerTime, bool aEndOnly);
414 :
415 : /**
416 : * Helper function to check for an early end and, if necessary, update the
417 : * current interval accordingly.
418 : *
419 : * See SMIL 3.0, section 5.4.5, Element life cycle, "Active Time - Playing an
420 : * interval" for a description of ending early.
421 : *
422 : * @param aSampleTime The current sample time. Early ends should only be
423 : * applied at the last possible moment (i.e. if they are at
424 : * or before the current sample time) and only if the
425 : * current interval is not already ending.
426 : * @return true if the end time of the current interval was updated,
427 : * false otherwise.
428 : */
429 : bool ApplyEarlyEnd(const nsSMILTimeValue& aSampleTime);
430 :
431 : /**
432 : * Clears certain state in response to the element restarting.
433 : *
434 : * This state is described in SMIL 3.0, section 5.4.3, Resetting element state
435 : */
436 : void Reset();
437 :
438 : /**
439 : * Completes a seek operation by sending appropriate events and, in the case
440 : * of a backwards seek, updating the state of timing information that was
441 : * previously considered historical.
442 : */
443 : void DoPostSeek();
444 :
445 : /**
446 : * Unmarks instance times that were previously preserved because they were
447 : * considered important historical milestones but are no longer such because
448 : * a backwards seek has been performed.
449 : */
450 : void UnpreserveInstanceTimes(InstanceTimeList& aList);
451 :
452 : /**
453 : * Helper function to iterate through this element's accumulated timing
454 : * information (specifically old nsSMILIntervals and nsSMILTimeInstanceTimes)
455 : * and discard items that are no longer needed or exceed some threshold of
456 : * accumulated state.
457 : */
458 : void FilterHistory();
459 :
460 : // Helper functions for FilterHistory to clear old nsSMILIntervals and
461 : // nsSMILInstanceTimes respectively.
462 : void FilterIntervals();
463 : void FilterInstanceTimes(InstanceTimeList& aList);
464 :
465 : /**
466 : * Calculates the next acceptable interval for this element after the
467 : * specified interval, or, if no previous interval is specified, it will be
468 : * the first interval with an end time after t=0.
469 : *
470 : * @see SMILANIM 3.6.8
471 : *
472 : * @param aPrevInterval The previous interval used. If supplied, the first
473 : * interval that begins after aPrevInterval will be
474 : * returned. May be nsnull.
475 : * @param aReplacedInterval The interval that is being updated (if any). This
476 : * used to ensure we don't return interval endpoints
477 : * that are dependent on themselves. May be nsnull.
478 : * @param aFixedBeginTime The time to use for the start of the interval. This
479 : * is used when only the endpoint of the interval
480 : * should be updated such as when the animation is in
481 : * the ACTIVE state. May be nsnull.
482 : * @param[out] aResult The next interval. Will be unchanged if no suitable
483 : * interval was found (in which case false will be
484 : * returned).
485 : * @return true if a suitable interval was found, false otherwise.
486 : */
487 : bool GetNextInterval(const nsSMILInterval* aPrevInterval,
488 : const nsSMILInterval* aReplacedInterval,
489 : const nsSMILInstanceTime* aFixedBeginTime,
490 : nsSMILInterval& aResult) const;
491 : nsSMILInstanceTime* GetNextGreater(const InstanceTimeList& aList,
492 : const nsSMILTimeValue& aBase,
493 : PRInt32& aPosition) const;
494 : nsSMILInstanceTime* GetNextGreaterOrEqual(const InstanceTimeList& aList,
495 : const nsSMILTimeValue& aBase,
496 : PRInt32& aPosition) const;
497 : nsSMILTimeValue CalcActiveEnd(const nsSMILTimeValue& aBegin,
498 : const nsSMILTimeValue& aEnd) const;
499 : nsSMILTimeValue GetRepeatDuration() const;
500 : nsSMILTimeValue ApplyMinAndMax(const nsSMILTimeValue& aDuration) const;
501 : nsSMILTime ActiveTimeToSimpleTime(nsSMILTime aActiveTime,
502 : PRUint32& aRepeatIteration);
503 : nsSMILInstanceTime* CheckForEarlyEnd(
504 : const nsSMILTimeValue& aContainerTime) const;
505 : void UpdateCurrentInterval(bool aForceChangeNotice = false);
506 : void SampleSimpleTime(nsSMILTime aActiveTime);
507 : void SampleFillValue();
508 : nsresult AddInstanceTimeFromCurrentTime(nsSMILTime aCurrentTime,
509 : double aOffsetSeconds, bool aIsBegin);
510 : void RegisterMilestone();
511 : bool GetNextMilestone(nsSMILMilestone& aNextMilestone) const;
512 :
513 : // Notification methods. Note that these notifications can result in nested
514 : // calls to this same object. Therefore,
515 : // (i) we should not perform notification until this object is in
516 : // a consistent state to receive callbacks, and
517 : // (ii) after calling these methods we must assume that the state of the
518 : // element may have changed.
519 : void NotifyNewInterval();
520 : void NotifyChangedInterval(nsSMILInterval* aInterval,
521 : bool aBeginObjectChanged,
522 : bool aEndObjectChanged);
523 :
524 : void FireTimeEventAsync(PRUint32 aMsg, PRInt32 aDetail);
525 : const nsSMILInstanceTime* GetEffectiveBeginInstance() const;
526 : const nsSMILInterval* GetPreviousInterval() const;
527 0 : bool HasPlayed() const { return !mOldIntervals.IsEmpty(); }
528 : bool EndHasEventConditions() const;
529 : bool AreEndTimesDependentOn(
530 : const nsSMILInstanceTime* aBase) const;
531 :
532 : // Reset the current interval by first passing ownership to a temporary
533 : // variable so that if Unlink() results in us receiving a callback,
534 : // mCurrentInterval will be nsnull and we will be in a consistent state.
535 0 : void ResetCurrentInterval()
536 : {
537 0 : if (mCurrentInterval) {
538 : // Transfer ownership to temp var. (This sets mCurrentInterval to null.)
539 0 : nsAutoPtr<nsSMILInterval> interval(mCurrentInterval);
540 0 : interval->Unlink();
541 : }
542 0 : }
543 :
544 : // Hashtable callback methods
545 : PR_STATIC_CALLBACK(PLDHashOperator) NotifyNewIntervalCallback(
546 : TimeValueSpecPtrKey* aKey, void* aData);
547 :
548 : //
549 : // Members
550 : //
551 : nsISMILAnimationElement* mAnimationElement; // [weak] won't outlive
552 : // owner
553 : TimeValueSpecList mBeginSpecs; // [strong]
554 : TimeValueSpecList mEndSpecs; // [strong]
555 :
556 : nsSMILTimeValue mSimpleDur;
557 :
558 : nsSMILRepeatCount mRepeatCount;
559 : nsSMILTimeValue mRepeatDur;
560 :
561 : nsSMILTimeValue mMin;
562 : nsSMILTimeValue mMax;
563 :
564 : enum nsSMILFillMode
565 : {
566 : FILL_REMOVE,
567 : FILL_FREEZE
568 : };
569 : nsSMILFillMode mFillMode;
570 : static nsAttrValue::EnumTable sFillModeTable[];
571 :
572 : enum nsSMILRestartMode
573 : {
574 : RESTART_ALWAYS,
575 : RESTART_WHENNOTACTIVE,
576 : RESTART_NEVER
577 : };
578 : nsSMILRestartMode mRestartMode;
579 : static nsAttrValue::EnumTable sRestartModeTable[];
580 :
581 : InstanceTimeList mBeginInstances;
582 : InstanceTimeList mEndInstances;
583 : PRUint32 mInstanceSerialIndex;
584 :
585 : nsSMILAnimationFunction* mClient;
586 : nsAutoPtr<nsSMILInterval> mCurrentInterval;
587 : IntervalList mOldIntervals;
588 : PRUint32 mCurrentRepeatIteration;
589 : nsSMILMilestone mPrevRegisteredMilestone;
590 : static const nsSMILMilestone sMaxMilestone;
591 : static const PRUint8 sMaxNumIntervals;
592 : static const PRUint8 sMaxNumInstanceTimes;
593 :
594 : // Set of dependent time value specs to be notified when establishing a new
595 : // current interval. Change notifications and delete notifications are handled
596 : // by the interval.
597 : //
598 : // [weak] The nsSMILTimeValueSpec objects register themselves and unregister
599 : // on destruction. Likewise, we notify them when we are destroyed.
600 : TimeValueSpecHashSet mTimeDependents;
601 :
602 : /**
603 : * The state of the element in its life-cycle. These states are based on the
604 : * element life-cycle described in SMILANIM 3.6.8
605 : */
606 : enum nsSMILElementState
607 : {
608 : STATE_STARTUP,
609 : STATE_WAITING,
610 : STATE_ACTIVE,
611 : STATE_POSTACTIVE
612 : };
613 : nsSMILElementState mElementState;
614 :
615 : enum nsSMILSeekState
616 : {
617 : SEEK_NOT_SEEKING,
618 : SEEK_FORWARD_FROM_ACTIVE,
619 : SEEK_FORWARD_FROM_INACTIVE,
620 : SEEK_BACKWARD_FROM_ACTIVE,
621 : SEEK_BACKWARD_FROM_INACTIVE
622 : };
623 : nsSMILSeekState mSeekState;
624 :
625 : // Used to batch updates to the timing model
626 : class AutoIntervalUpdateBatcher;
627 : bool mDeferIntervalUpdates;
628 : bool mDoDeferredUpdate; // Set if an update to the current interval was
629 : // requested while mDeferIntervalUpdates was set
630 :
631 : // Recursion depth checking
632 : PRUint8 mDeleteCount;
633 : PRUint8 mUpdateIntervalRecursionDepth;
634 : static const PRUint8 sMaxUpdateIntervalRecursionDepth;
635 : };
636 :
637 : #endif // NS_SMILTIMEDELEMENT_H_
|