1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 |
|
8 |
|
9 |
|
10 |
|
11 |
|
12 |
|
13 |
|
14 | import TweenLite, { _gsScope, globals, Ease, Animation } from "./TweenLite.js";
|
15 | import TimelineLite from "./TimelineLite.js";
|
16 |
|
17 | _gsScope._gsDefine("TimelineMax", ["TimelineLite","TweenLite","easing.Ease"], function() {
|
18 |
|
19 | var TimelineMax = function(vars) {
|
20 | TimelineLite.call(this, vars);
|
21 | this._repeat = this.vars.repeat || 0;
|
22 | this._repeatDelay = this.vars.repeatDelay || 0;
|
23 | this._cycle = 0;
|
24 | this._yoyo = !!this.vars.yoyo;
|
25 | this._dirty = true;
|
26 | },
|
27 | _tinyNum = 0.00000001,
|
28 | TweenLiteInternals = TweenLite._internals,
|
29 | _lazyTweens = TweenLiteInternals.lazyTweens,
|
30 | _lazyRender = TweenLiteInternals.lazyRender,
|
31 | _globals = _gsScope._gsDefine.globals,
|
32 | _easeNone = new Ease(null, null, 1, 0),
|
33 | p = TimelineMax.prototype = new TimelineLite();
|
34 |
|
35 | p.constructor = TimelineMax;
|
36 | p.kill()._gc = false;
|
37 | TimelineMax.version = "2.1.3";
|
38 |
|
39 | p.invalidate = function() {
|
40 | this._yoyo = !!this.vars.yoyo;
|
41 | this._repeat = this.vars.repeat || 0;
|
42 | this._repeatDelay = this.vars.repeatDelay || 0;
|
43 | this._uncache(true);
|
44 | return TimelineLite.prototype.invalidate.call(this);
|
45 | };
|
46 |
|
47 | p.addCallback = function(callback, position, params, scope) {
|
48 | return this.add( TweenLite.delayedCall(0, callback, params, scope), position);
|
49 | };
|
50 |
|
51 | p.removeCallback = function(callback, position) {
|
52 | if (callback) {
|
53 | if (position == null) {
|
54 | this._kill(null, callback);
|
55 | } else {
|
56 | var a = this.getTweensOf(callback, false),
|
57 | i = a.length,
|
58 | time = this._parseTimeOrLabel(position);
|
59 | while (--i > -1) {
|
60 | if (a[i]._startTime === time) {
|
61 | a[i]._enabled(false, false);
|
62 | }
|
63 | }
|
64 | }
|
65 | }
|
66 | return this;
|
67 | };
|
68 |
|
69 | p.removePause = function(position) {
|
70 | return this.removeCallback(TimelineLite._internals.pauseCallback, position);
|
71 | };
|
72 |
|
73 | p.tweenTo = function(position, vars) {
|
74 | vars = vars || {};
|
75 | var copy = {ease:_easeNone, useFrames:this.usesFrames(), immediateRender:false, lazy:false},
|
76 | Engine = (vars.repeat && _globals.TweenMax) || TweenLite,
|
77 | duration, p, t;
|
78 | for (p in vars) {
|
79 | copy[p] = vars[p];
|
80 | }
|
81 | copy.time = this._parseTimeOrLabel(position);
|
82 | duration = (Math.abs(Number(copy.time) - this._time) / this._timeScale) || 0.001;
|
83 | t = new Engine(this, duration, copy);
|
84 | copy.onStart = function() {
|
85 | t.target.paused(true);
|
86 | if (t.vars.time !== t.target.time() && duration === t.duration() && !t.isFromTo) {
|
87 | t.duration( Math.abs( t.vars.time - t.target.time()) / t.target._timeScale ).render(t.time(), true, true);
|
88 | }
|
89 | if (vars.onStart) {
|
90 | vars.onStart.apply(vars.onStartScope || vars.callbackScope || t, vars.onStartParams || []);
|
91 | }
|
92 | };
|
93 | return t;
|
94 | };
|
95 |
|
96 | p.tweenFromTo = function(fromPosition, toPosition, vars) {
|
97 | vars = vars || {};
|
98 | fromPosition = this._parseTimeOrLabel(fromPosition);
|
99 | vars.startAt = {onComplete:this.seek, onCompleteParams:[fromPosition], callbackScope:this};
|
100 | vars.immediateRender = (vars.immediateRender !== false);
|
101 | var t = this.tweenTo(toPosition, vars);
|
102 | t.isFromTo = 1;
|
103 | return t.duration((Math.abs( t.vars.time - fromPosition) / this._timeScale) || 0.001);
|
104 | };
|
105 |
|
106 | p.render = function(time, suppressEvents, force) {
|
107 | if (this._gc) {
|
108 | this._enabled(true, false);
|
109 | }
|
110 | var self = this,
|
111 | prevTime = self._time,
|
112 | totalDur = (!self._dirty) ? self._totalDuration : self.totalDuration(),
|
113 | dur = self._duration,
|
114 | prevTotalTime = self._totalTime,
|
115 | prevStart = self._startTime,
|
116 | prevTimeScale = self._timeScale,
|
117 | prevRawPrevTime = self._rawPrevTime,
|
118 | prevPaused = self._paused,
|
119 | prevCycle = self._cycle,
|
120 | tween, isComplete, next, callback, internalForce, cycleDuration, pauseTween, curTime, pauseTime;
|
121 | if (prevTime !== self._time) {
|
122 | time += self._time - prevTime;
|
123 | }
|
124 | if (time >= totalDur - _tinyNum && time >= 0) {
|
125 | if (!self._locked) {
|
126 | self._totalTime = totalDur;
|
127 | self._cycle = self._repeat;
|
128 | }
|
129 | if (!self._reversed) if (!self._hasPausedChild()) {
|
130 | isComplete = true;
|
131 | callback = "onComplete";
|
132 | internalForce = !!self._timeline.autoRemoveChildren;
|
133 | if (self._duration === 0) if ((time <= 0 && time >= -_tinyNum) || prevRawPrevTime < 0 || prevRawPrevTime === _tinyNum) if (prevRawPrevTime !== time && self._first) {
|
134 | internalForce = true;
|
135 | if (prevRawPrevTime > _tinyNum) {
|
136 | callback = "onReverseComplete";
|
137 | }
|
138 | }
|
139 | }
|
140 | self._rawPrevTime = (self._duration || !suppressEvents || time || self._rawPrevTime === time) ? time : _tinyNum;
|
141 | if (self._yoyo && (self._cycle & 1)) {
|
142 | self._time = time = 0;
|
143 | } else {
|
144 | self._time = dur;
|
145 | time = dur + 0.0001;
|
146 | }
|
147 |
|
148 | } else if (time < _tinyNum) {
|
149 | if (!self._locked) {
|
150 | self._totalTime = self._cycle = 0;
|
151 | }
|
152 | self._time = 0;
|
153 | if (time > -_tinyNum) {
|
154 | time = 0;
|
155 | }
|
156 | if (prevTime !== 0 || (dur === 0 && prevRawPrevTime !== _tinyNum && (prevRawPrevTime > 0 || (time < 0 && prevRawPrevTime >= 0)) && !self._locked)) {
|
157 | callback = "onReverseComplete";
|
158 | isComplete = self._reversed;
|
159 | }
|
160 | if (time < 0) {
|
161 | self._active = false;
|
162 | if (self._timeline.autoRemoveChildren && self._reversed) {
|
163 | internalForce = isComplete = true;
|
164 | callback = "onReverseComplete";
|
165 | } else if (prevRawPrevTime >= 0 && self._first) {
|
166 | internalForce = true;
|
167 | }
|
168 | self._rawPrevTime = time;
|
169 | } else {
|
170 | self._rawPrevTime = (dur || !suppressEvents || time || self._rawPrevTime === time) ? time : _tinyNum;
|
171 | if (time === 0 && isComplete) {
|
172 | tween = self._first;
|
173 | while (tween && tween._startTime === 0) {
|
174 | if (!tween._duration) {
|
175 | isComplete = false;
|
176 | }
|
177 | tween = tween._next;
|
178 | }
|
179 | }
|
180 | time = 0;
|
181 | if (!self._initted) {
|
182 | internalForce = true;
|
183 | }
|
184 | }
|
185 |
|
186 | } else {
|
187 | if (dur === 0 && prevRawPrevTime < 0) {
|
188 | internalForce = true;
|
189 | }
|
190 | self._time = self._rawPrevTime = time;
|
191 | if (!self._locked) {
|
192 | self._totalTime = time;
|
193 | if (self._repeat !== 0) {
|
194 | cycleDuration = dur + self._repeatDelay;
|
195 | self._cycle = (self._totalTime / cycleDuration) >> 0;
|
196 | if (self._cycle) if (self._cycle === self._totalTime / cycleDuration && prevTotalTime <= time) {
|
197 | self._cycle--;
|
198 | }
|
199 | self._time = self._totalTime - (self._cycle * cycleDuration);
|
200 | if (self._yoyo) if (self._cycle & 1) {
|
201 | self._time = dur - self._time;
|
202 | }
|
203 | if (self._time > dur) {
|
204 | self._time = dur;
|
205 | time = dur + 0.0001;
|
206 | } else if (self._time < 0) {
|
207 | self._time = time = 0;
|
208 | } else {
|
209 | time = self._time;
|
210 | }
|
211 | }
|
212 | }
|
213 | }
|
214 |
|
215 | if (self._hasPause && !self._forcingPlayhead && !suppressEvents) {
|
216 | time = self._time;
|
217 | if (time > prevTime || (self._repeat && prevCycle !== self._cycle)) {
|
218 | tween = self._first;
|
219 | while (tween && tween._startTime <= time && !pauseTween) {
|
220 | if (!tween._duration) if (tween.data === "isPause" && !tween.ratio && !(tween._startTime === 0 && self._rawPrevTime === 0)) {
|
221 | pauseTween = tween;
|
222 | }
|
223 | tween = tween._next;
|
224 | }
|
225 | } else {
|
226 | tween = self._last;
|
227 | while (tween && tween._startTime >= time && !pauseTween) {
|
228 | if (!tween._duration) if (tween.data === "isPause" && tween._rawPrevTime > 0) {
|
229 | pauseTween = tween;
|
230 | }
|
231 | tween = tween._prev;
|
232 | }
|
233 | }
|
234 | if (pauseTween) {
|
235 | pauseTime = self._startTime + (self._reversed ? self._duration - pauseTween._startTime : pauseTween._startTime) / self._timeScale;
|
236 | if (pauseTween._startTime < dur) {
|
237 | self._time = self._rawPrevTime = time = pauseTween._startTime;
|
238 | self._totalTime = time + (self._cycle * (self._totalDuration + self._repeatDelay));
|
239 | }
|
240 | }
|
241 | }
|
242 |
|
243 | if (self._cycle !== prevCycle) if (!self._locked) {
|
244 | |
245 |
|
246 |
|
247 |
|
248 |
|
249 |
|
250 |
|
251 |
|
252 | var backwards = (self._yoyo && (prevCycle & 1) !== 0),
|
253 | wrap = (backwards === (self._yoyo && (self._cycle & 1) !== 0)),
|
254 | recTotalTime = self._totalTime,
|
255 | recCycle = self._cycle,
|
256 | recRawPrevTime = self._rawPrevTime,
|
257 | recTime = self._time;
|
258 |
|
259 | self._totalTime = prevCycle * dur;
|
260 | if (self._cycle < prevCycle) {
|
261 | backwards = !backwards;
|
262 | } else {
|
263 | self._totalTime += dur;
|
264 | }
|
265 | self._time = prevTime;
|
266 |
|
267 | self._rawPrevTime = (dur === 0) ? prevRawPrevTime - 0.0001 : prevRawPrevTime;
|
268 | self._cycle = prevCycle;
|
269 | self._locked = true;
|
270 | prevTime = (backwards) ? 0 : dur;
|
271 | self.render(prevTime, suppressEvents, (dur === 0));
|
272 | if (!suppressEvents) if (!self._gc) {
|
273 | if (self.vars.onRepeat) {
|
274 | self._cycle = recCycle;
|
275 | self._locked = false;
|
276 | self._callback("onRepeat");
|
277 | }
|
278 | }
|
279 | if (prevTime !== self._time) {
|
280 | return;
|
281 | }
|
282 | if (wrap) {
|
283 | self._cycle = prevCycle;
|
284 | self._locked = true;
|
285 | prevTime = (backwards) ? dur + 0.0001 : -0.0001;
|
286 | self.render(prevTime, true, false);
|
287 | }
|
288 | self._locked = false;
|
289 | if (self._paused && !prevPaused) {
|
290 | return;
|
291 | }
|
292 | self._time = recTime;
|
293 | self._totalTime = recTotalTime;
|
294 | self._cycle = recCycle;
|
295 | self._rawPrevTime = recRawPrevTime;
|
296 | }
|
297 |
|
298 | if ((self._time === prevTime || !self._first) && !force && !internalForce && !pauseTween) {
|
299 | if (prevTotalTime !== self._totalTime) if (self._onUpdate) if (!suppressEvents) {
|
300 | self._callback("onUpdate");
|
301 | }
|
302 | return;
|
303 | } else if (!self._initted) {
|
304 | self._initted = true;
|
305 | }
|
306 |
|
307 | if (!self._active) if (!self._paused && self._totalTime !== prevTotalTime && time > 0) {
|
308 | self._active = true;
|
309 | }
|
310 |
|
311 | if (prevTotalTime === 0) if (self.vars.onStart) if (self._totalTime !== 0 || !self._totalDuration) if (!suppressEvents) {
|
312 | self._callback("onStart");
|
313 | }
|
314 |
|
315 | curTime = self._time;
|
316 | if (curTime >= prevTime) {
|
317 | tween = self._first;
|
318 | while (tween) {
|
319 | next = tween._next;
|
320 | if (curTime !== self._time || (self._paused && !prevPaused)) {
|
321 | break;
|
322 | } else if (tween._active || (tween._startTime <= self._time && !tween._paused && !tween._gc)) {
|
323 | if (pauseTween === tween) {
|
324 | self.pause();
|
325 | self._pauseTime = pauseTime;
|
326 | }
|
327 | if (!tween._reversed) {
|
328 | tween.render((time - tween._startTime) * tween._timeScale, suppressEvents, force);
|
329 | } else {
|
330 | tween.render(((!tween._dirty) ? tween._totalDuration : tween.totalDuration()) - ((time - tween._startTime) * tween._timeScale), suppressEvents, force);
|
331 | }
|
332 | }
|
333 | tween = next;
|
334 | }
|
335 | } else {
|
336 | tween = self._last;
|
337 | while (tween) {
|
338 | next = tween._prev;
|
339 | if (curTime !== self._time || (self._paused && !prevPaused)) {
|
340 | break;
|
341 | } else if (tween._active || (tween._startTime <= prevTime && !tween._paused && !tween._gc)) {
|
342 | if (pauseTween === tween) {
|
343 | pauseTween = tween._prev;
|
344 | while (pauseTween && pauseTween.endTime() > self._time) {
|
345 | pauseTween.render( (pauseTween._reversed ? pauseTween.totalDuration() - ((time - pauseTween._startTime) * pauseTween._timeScale) : (time - pauseTween._startTime) * pauseTween._timeScale), suppressEvents, force);
|
346 | pauseTween = pauseTween._prev;
|
347 | }
|
348 | pauseTween = null;
|
349 | self.pause();
|
350 | self._pauseTime = pauseTime;
|
351 | }
|
352 | if (!tween._reversed) {
|
353 | tween.render((time - tween._startTime) * tween._timeScale, suppressEvents, force);
|
354 | } else {
|
355 | tween.render(((!tween._dirty) ? tween._totalDuration : tween.totalDuration()) - ((time - tween._startTime) * tween._timeScale), suppressEvents, force);
|
356 | }
|
357 | }
|
358 | tween = next;
|
359 | }
|
360 | }
|
361 |
|
362 | if (self._onUpdate) if (!suppressEvents) {
|
363 | if (_lazyTweens.length) {
|
364 | _lazyRender();
|
365 | }
|
366 | self._callback("onUpdate");
|
367 | }
|
368 | if (callback) if (!self._locked) if (!self._gc) if (prevStart === self._startTime || prevTimeScale !== self._timeScale) if (self._time === 0 || totalDur >= self.totalDuration()) {
|
369 | if (isComplete) {
|
370 | if (_lazyTweens.length) {
|
371 | _lazyRender();
|
372 | }
|
373 | if (self._timeline.autoRemoveChildren) {
|
374 | self._enabled(false, false);
|
375 | }
|
376 | self._active = false;
|
377 | }
|
378 | if (!suppressEvents && self.vars[callback]) {
|
379 | self._callback(callback);
|
380 | }
|
381 | }
|
382 | };
|
383 |
|
384 | p.getActive = function(nested, tweens, timelines) {
|
385 | var a = [],
|
386 | all = this.getChildren(nested || (nested == null), tweens || (nested == null), !!timelines),
|
387 | cnt = 0,
|
388 | l = all.length,
|
389 | i, tween;
|
390 | for (i = 0; i < l; i++) {
|
391 | tween = all[i];
|
392 | if (tween.isActive()) {
|
393 | a[cnt++] = tween;
|
394 | }
|
395 | }
|
396 | return a;
|
397 | };
|
398 |
|
399 |
|
400 | p.getLabelAfter = function(time) {
|
401 | if (!time) if (time !== 0) {
|
402 | time = this._time;
|
403 | }
|
404 | var labels = this.getLabelsArray(),
|
405 | l = labels.length,
|
406 | i;
|
407 | for (i = 0; i < l; i++) {
|
408 | if (labels[i].time > time) {
|
409 | return labels[i].name;
|
410 | }
|
411 | }
|
412 | return null;
|
413 | };
|
414 |
|
415 | p.getLabelBefore = function(time) {
|
416 | if (time == null) {
|
417 | time = this._time;
|
418 | }
|
419 | var labels = this.getLabelsArray(),
|
420 | i = labels.length;
|
421 | while (--i > -1) {
|
422 | if (labels[i].time < time) {
|
423 | return labels[i].name;
|
424 | }
|
425 | }
|
426 | return null;
|
427 | };
|
428 |
|
429 | p.getLabelsArray = function() {
|
430 | var a = [],
|
431 | cnt = 0,
|
432 | p;
|
433 | for (p in this._labels) {
|
434 | a[cnt++] = {time:this._labels[p], name:p};
|
435 | }
|
436 | a.sort(function(a,b) {
|
437 | return a.time - b.time;
|
438 | });
|
439 | return a;
|
440 | };
|
441 |
|
442 | p.invalidate = function() {
|
443 | this._locked = false;
|
444 | return TimelineLite.prototype.invalidate.call(this);
|
445 | };
|
446 |
|
447 |
|
448 |
|
449 |
|
450 | p.progress = function(value, suppressEvents) {
|
451 | return (!arguments.length) ? (this._time / this.duration()) || 0 : this.totalTime( this.duration() * ((this._yoyo && (this._cycle & 1) !== 0) ? 1 - value : value) + (this._cycle * (this._duration + this._repeatDelay)), suppressEvents);
|
452 | };
|
453 |
|
454 | p.totalProgress = function(value, suppressEvents) {
|
455 | return (!arguments.length) ? (this._totalTime / this.totalDuration()) || 0 : this.totalTime( this.totalDuration() * value, suppressEvents);
|
456 | };
|
457 |
|
458 | p.totalDuration = function(value) {
|
459 | if (!arguments.length) {
|
460 | if (this._dirty) {
|
461 | TimelineLite.prototype.totalDuration.call(this);
|
462 |
|
463 | this._totalDuration = (this._repeat === -1) ? 999999999999 : this._duration * (this._repeat + 1) + (this._repeatDelay * this._repeat);
|
464 | }
|
465 | return this._totalDuration;
|
466 | }
|
467 | return (this._repeat === -1 || !value) ? this : this.timeScale( this.totalDuration() / value );
|
468 | };
|
469 |
|
470 | p.time = function(value, suppressEvents) {
|
471 | if (!arguments.length) {
|
472 | return this._time;
|
473 | }
|
474 | if (this._dirty) {
|
475 | this.totalDuration();
|
476 | }
|
477 | var duration = this._duration,
|
478 | cycle = this._cycle,
|
479 | cycleDur = cycle * (duration + this._repeatDelay);
|
480 | if (value > duration) {
|
481 | value = duration;
|
482 | }
|
483 | return this.totalTime((this._yoyo && (cycle & 1)) ? duration - value + cycleDur : this._repeat ? value + cycleDur : value, suppressEvents);
|
484 | };
|
485 |
|
486 | p.repeat = function(value) {
|
487 | if (!arguments.length) {
|
488 | return this._repeat;
|
489 | }
|
490 | this._repeat = value;
|
491 | return this._uncache(true);
|
492 | };
|
493 |
|
494 | p.repeatDelay = function(value) {
|
495 | if (!arguments.length) {
|
496 | return this._repeatDelay;
|
497 | }
|
498 | this._repeatDelay = value;
|
499 | return this._uncache(true);
|
500 | };
|
501 |
|
502 | p.yoyo = function(value) {
|
503 | if (!arguments.length) {
|
504 | return this._yoyo;
|
505 | }
|
506 | this._yoyo = value;
|
507 | return this;
|
508 | };
|
509 |
|
510 | p.currentLabel = function(value) {
|
511 | if (!arguments.length) {
|
512 | return this.getLabelBefore(this._time + _tinyNum);
|
513 | }
|
514 | return this.seek(value, true);
|
515 | };
|
516 |
|
517 | return TimelineMax;
|
518 |
|
519 | }, true);
|
520 |
|
521 | export var TimelineMax = globals.TimelineMax;
|
522 | export { TimelineLite, TimelineMax as default }; |
\ | No newline at end of file |