| Index: third_party/web-animations-js/web-animations.js
|
| diff --git a/third_party/web-animations-js/web-animations.js b/third_party/web-animations-js/web-animations.js
|
| new file mode 100644
|
| index 0000000000000000000000000000000000000000..ff8ba6fe6f74c67b79fb156d7de15c69c6deebef
|
| --- /dev/null
|
| +++ b/third_party/web-animations-js/web-animations.js
|
| @@ -0,0 +1,5529 @@
|
| +/**
|
| + * Copyright 2012 Google Inc. All Rights Reserved.
|
| + *
|
| + * Licensed under the Apache License, Version 2.0 (the "License");
|
| + * you may not use this file except in compliance with the License.
|
| + * You may obtain a copy of the License at
|
| + *
|
| + * http://www.apache.org/licenses/LICENSE-2.0
|
| + *
|
| + * Unless required by applicable law or agreed to in writing, software
|
| + * distributed under the License is distributed on an "AS IS" BASIS,
|
| + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
| + * See the License for the specific language governing permissions and
|
| + * limitations under the License.
|
| + */
|
| +
|
| +(function() {
|
| +'use strict';
|
| +
|
| +var ASSERT_ENABLED = false;
|
| +var SVG_NS = 'http://www.w3.org/2000/svg';
|
| +
|
| +function assert(check, message) {
|
| + console.assert(ASSERT_ENABLED,
|
| + 'assert should not be called when ASSERT_ENABLED is false');
|
| + console.assert(check, message);
|
| + // Some implementations of console.assert don't actually throw
|
| + if (!check) { throw message; }
|
| +}
|
| +
|
| +function detectFeatures() {
|
| + var el = createDummyElement();
|
| + el.style.cssText = 'width: calc(0px);' +
|
| + 'width: -webkit-calc(0px);';
|
| + var calcFunction = el.style.width.split('(')[0];
|
| + function detectProperty(candidateProperties) {
|
| + return [].filter.call(candidateProperties, function(property) {
|
| + return property in el.style;
|
| + })[0];
|
| + }
|
| + var transformProperty = detectProperty([
|
| + 'transform',
|
| + 'webkitTransform',
|
| + 'msTransform']);
|
| + var perspectiveProperty = detectProperty([
|
| + 'perspective',
|
| + 'webkitPerspective',
|
| + 'msPerspective']);
|
| + return {
|
| + calcFunction: calcFunction,
|
| + transformProperty: transformProperty,
|
| + transformOriginProperty: transformProperty + 'Origin',
|
| + perspectiveProperty: perspectiveProperty,
|
| + perspectiveOriginProperty: perspectiveProperty + 'Origin'
|
| + };
|
| +}
|
| +var features = detectFeatures();
|
| +
|
| +function prefixProperty(property) {
|
| + switch (property) {
|
| + case 'transform':
|
| + return features.transformProperty;
|
| + case 'transformOrigin':
|
| + return features.transformOriginProperty;
|
| + case 'perspective':
|
| + return features.perspectiveProperty;
|
| + case 'perspectiveOrigin':
|
| + return features.perspectiveOriginProperty;
|
| + default:
|
| + return property;
|
| + }
|
| +}
|
| +
|
| +function createDummyElement() {
|
| + return document.documentElement.namespaceURI == SVG_NS ?
|
| + document.createElementNS(SVG_NS, 'g') :
|
| + document.createElement('div');
|
| +}
|
| +
|
| +var constructorToken = {};
|
| +var deprecationsSilenced = {};
|
| +
|
| +var createObject = function(proto, obj) {
|
| + var newObject = Object.create(proto);
|
| + Object.getOwnPropertyNames(obj).forEach(function(name) {
|
| + Object.defineProperty(
|
| + newObject, name, Object.getOwnPropertyDescriptor(obj, name));
|
| + });
|
| + return newObject;
|
| +};
|
| +
|
| +var abstractMethod = function() {
|
| + throw 'Abstract method not implemented.';
|
| +};
|
| +
|
| +var deprecated = function(name, deprecationDate, advice, plural) {
|
| + if (deprecationsSilenced[name]) {
|
| + return;
|
| + }
|
| + var auxVerb = plural ? 'are' : 'is';
|
| + var today = new Date();
|
| + var cutoffDate = new Date(deprecationDate);
|
| + cutoffDate.setMonth(cutoffDate.getMonth() + 3); // 3 months grace period
|
| +
|
| + if (today < cutoffDate) {
|
| + console.warn('Web Animations: ' + name +
|
| + ' ' + auxVerb + ' deprecated and will stop working on ' +
|
| + cutoffDate.toDateString() + '. ' + advice);
|
| + deprecationsSilenced[name] = true;
|
| + } else {
|
| + throw new Error(name + ' ' + auxVerb + ' no longer supported. ' + advice);
|
| + }
|
| +};
|
| +
|
| +var defineDeprecatedProperty = function(object, property, getFunc, setFunc) {
|
| + var descriptor = {
|
| + get: getFunc,
|
| + configurable: true
|
| + };
|
| + if (setFunc) {
|
| + descriptor.set = setFunc;
|
| + }
|
| + Object.defineProperty(object, property, descriptor);
|
| +};
|
| +
|
| +var IndexSizeError = function(message) {
|
| + Error.call(this);
|
| + this.name = 'IndexSizeError';
|
| + this.message = message;
|
| +};
|
| +
|
| +IndexSizeError.prototype = Object.create(Error.prototype);
|
| +
|
| +
|
| +
|
| +/** @constructor */
|
| +var TimingDict = function(timingInput) {
|
| + if (typeof timingInput === 'object') {
|
| + for (var k in timingInput) {
|
| + if (k in TimingDict.prototype) {
|
| + this[k] = timingInput[k];
|
| + }
|
| + }
|
| + } else if (isDefinedAndNotNull(timingInput)) {
|
| + this.duration = Number(timingInput);
|
| + }
|
| +};
|
| +
|
| +TimingDict.prototype = {
|
| + delay: 0,
|
| + endDelay: 0,
|
| + fill: 'auto',
|
| + iterationStart: 0,
|
| + iterations: 1,
|
| + duration: 'auto',
|
| + playbackRate: 1,
|
| + direction: 'normal',
|
| + easing: 'linear'
|
| +};
|
| +
|
| +
|
| +
|
| +/** @constructor */
|
| +var Timing = function(token, timingInput, changeHandler) {
|
| + if (token !== constructorToken) {
|
| + throw new TypeError('Illegal constructor');
|
| + }
|
| + this._dict = new TimingDict(timingInput);
|
| + this._changeHandler = changeHandler;
|
| +};
|
| +
|
| +Timing.prototype = {
|
| + _timingFunction: function(timedItem) {
|
| + var timingFunction = TimingFunction.createFromString(
|
| + this.easing, timedItem);
|
| + this._timingFunction = function() {
|
| + return timingFunction;
|
| + };
|
| + return timingFunction;
|
| + },
|
| + _invalidateTimingFunction: function() {
|
| + delete this._timingFunction;
|
| + },
|
| + _iterations: function() {
|
| + var value = this._dict.iterations;
|
| + return value < 0 ? 1 : value;
|
| + },
|
| + _duration: function() {
|
| + var value = this._dict.duration;
|
| + return typeof value === 'number' ? value : 'auto';
|
| + },
|
| + _clone: function() {
|
| + return new Timing(
|
| + constructorToken, this._dict, this._updateInternalState.bind(this));
|
| + }
|
| +};
|
| +
|
| +// Configures an accessor descriptor for use with Object.defineProperty() to
|
| +// allow the property to be changed and enumerated, to match __defineGetter__()
|
| +// and __defineSetter__().
|
| +var configureDescriptor = function(descriptor) {
|
| + descriptor.configurable = true;
|
| + descriptor.enumerable = true;
|
| + return descriptor;
|
| +};
|
| +
|
| +Timing._defineProperty = function(prop) {
|
| + Object.defineProperty(Timing.prototype, prop, configureDescriptor({
|
| + get: function() {
|
| + return this._dict[prop];
|
| + },
|
| + set: function(value) {
|
| + if (isDefinedAndNotNull(value)) {
|
| + if (prop == 'duration' && value == 'auto') {
|
| + // duration is not always a number
|
| + } else if (['delay', 'endDelay', 'iterationStart', 'iterations',
|
| + 'duration', 'playbackRate'].indexOf(prop) >= 0) {
|
| + value = Number(value);
|
| + }
|
| + this._dict[prop] = value;
|
| + } else {
|
| + delete this._dict[prop];
|
| + }
|
| + // FIXME: probably need to implement specialized handling parsing
|
| + // for each property
|
| + if (prop === 'easing') {
|
| + // Cached timing function may be invalid now.
|
| + this._invalidateTimingFunction();
|
| + }
|
| + this._changeHandler();
|
| + }
|
| + }));
|
| +};
|
| +
|
| +for (var prop in TimingDict.prototype) {
|
| + Timing._defineProperty(prop);
|
| +}
|
| +
|
| +var isDefined = function(val) {
|
| + return typeof val !== 'undefined';
|
| +};
|
| +
|
| +var isDefinedAndNotNull = function(val) {
|
| + return isDefined(val) && (val !== null);
|
| +};
|
| +
|
| +
|
| +
|
| +/** @constructor */
|
| +var AnimationTimeline = function(token) {
|
| + if (token !== constructorToken) {
|
| + throw new TypeError('Illegal constructor');
|
| + }
|
| + // TODO: This will probably need to change.
|
| + this._startTime = documentTimeZeroAsClockTime;
|
| +};
|
| +
|
| +AnimationTimeline.prototype = {
|
| + get currentTime() {
|
| + if (this._startTime === undefined) {
|
| + this._startTime = documentTimeZeroAsClockTime;
|
| + if (this._startTime === undefined) {
|
| + return null;
|
| + }
|
| + }
|
| + return relativeTime(cachedClockTime(), this._startTime);
|
| + },
|
| + get effectiveCurrentTime() {
|
| + return this.currentTime || 0;
|
| + },
|
| + play: function(source) {
|
| + return new AnimationPlayer(constructorToken, source, this);
|
| + },
|
| + getCurrentPlayers: function() {
|
| + return PLAYERS.filter(function(player) {
|
| + return !player._isPastEndOfActiveInterval();
|
| + });
|
| + },
|
| + toTimelineTime: function(otherTime, other) {
|
| + if ((this.currentTime === null) || (other.currentTime === null)) {
|
| + return null;
|
| + } else {
|
| + return otherTime + other._startTime - this._startTime;
|
| + }
|
| + },
|
| + _pauseAnimationsForTesting: function(pauseAt) {
|
| + PLAYERS.forEach(function(player) {
|
| + player.pause();
|
| + player.currentTime = pauseAt;
|
| + });
|
| + }
|
| +};
|
| +
|
| +// TODO: Remove dead players from here?
|
| +var PLAYERS = [];
|
| +var playersAreSorted = false;
|
| +var playerSequenceNumber = 0;
|
| +
|
| +// Methods for event target objects.
|
| +var initializeEventTarget = function(eventTarget) {
|
| + eventTarget._handlers = {};
|
| + eventTarget._onHandlers = {};
|
| +};
|
| +var setOnEventHandler = function(eventTarget, type, handler) {
|
| + if (typeof handler === 'function') {
|
| + eventTarget._onHandlers[type] = {
|
| + callback: handler,
|
| + index: (eventTarget._handlers[type] || []).length
|
| + };
|
| + } else {
|
| + eventTarget._onHandlers[type] = null;
|
| + }
|
| +};
|
| +var getOnEventHandler = function(eventTarget, type) {
|
| + if (isDefinedAndNotNull(eventTarget._onHandlers[type])) {
|
| + return eventTarget._onHandlers[type].callback;
|
| + }
|
| + return null;
|
| +};
|
| +var addEventHandler = function(eventTarget, type, handler) {
|
| + if (typeof handler !== 'function') {
|
| + return;
|
| + }
|
| + if (!isDefinedAndNotNull(eventTarget._handlers[type])) {
|
| + eventTarget._handlers[type] = [];
|
| + } else if (eventTarget._handlers[type].indexOf(handler) !== -1) {
|
| + return;
|
| + }
|
| + eventTarget._handlers[type].push(handler);
|
| +};
|
| +var removeEventHandler = function(eventTarget, type, handler) {
|
| + if (!eventTarget._handlers[type]) {
|
| + return;
|
| + }
|
| + var index = eventTarget._handlers[type].indexOf(handler);
|
| + if (index === -1) {
|
| + return;
|
| + }
|
| + eventTarget._handlers[type].splice(index, 1);
|
| + if (isDefinedAndNotNull(eventTarget._onHandlers[type]) &&
|
| + (index < eventTarget._onHandlers[type].index)) {
|
| + eventTarget._onHandlers[type].index -= 1;
|
| + }
|
| +};
|
| +var hasEventHandlersForEvent = function(eventTarget, type) {
|
| + return (isDefinedAndNotNull(eventTarget._handlers[type]) &&
|
| + eventTarget._handlers[type].length > 0) ||
|
| + isDefinedAndNotNull(eventTarget._onHandlers[type]);
|
| +};
|
| +var callEventHandlers = function(eventTarget, type, event) {
|
| + var callbackList;
|
| + if (isDefinedAndNotNull(eventTarget._handlers[type])) {
|
| + callbackList = eventTarget._handlers[type].slice();
|
| + } else {
|
| + callbackList = [];
|
| + }
|
| + if (isDefinedAndNotNull(eventTarget._onHandlers[type])) {
|
| + callbackList.splice(eventTarget._onHandlers[type].index, 0,
|
| + eventTarget._onHandlers[type].callback);
|
| + }
|
| + setTimeout(function() {
|
| + for (var i = 0; i < callbackList.length; i++) {
|
| + callbackList[i].call(eventTarget, event);
|
| + }
|
| + }, 0);
|
| +};
|
| +var createEventPrototype = function() {
|
| + var prototype = Object.create(window.Event.prototype, {
|
| + type: { get: function() { return this._type; } },
|
| + target: { get: function() { return this._target; } },
|
| + currentTarget: { get: function() { return this._target; } },
|
| + eventPhase: { get: function() { return this._eventPhase; } },
|
| + bubbles: { get: function() { return false; } },
|
| + cancelable: { get: function() { return false; } },
|
| + timeStamp: { get: function() { return this._timeStamp; } },
|
| + defaultPrevented: { get: function() { return false; } }
|
| + });
|
| + prototype._type = '';
|
| + prototype._target = null;
|
| + prototype._eventPhase = Event.NONE;
|
| + prototype._timeStamp = 0;
|
| + prototype._initialize = function(target) {
|
| + this._target = target;
|
| + this._eventPhase = Event.AT_TARGET;
|
| + this._timeStamp = cachedClockTime();
|
| + };
|
| + return prototype;
|
| +};
|
| +
|
| +
|
| +
|
| +/** @constructor */
|
| +var AnimationPlayer = function(token, source, timeline) {
|
| + if (token !== constructorToken) {
|
| + throw new TypeError('Illegal constructor');
|
| + }
|
| + enterModifyCurrentAnimationState();
|
| + try {
|
| + this._registeredOnTimeline = false;
|
| + this._sequenceNumber = playerSequenceNumber++;
|
| + this._timeline = timeline;
|
| + this._startTime =
|
| + this.timeline.currentTime === null ? 0 : this.timeline.currentTime;
|
| + this._storedTimeLag = 0.0;
|
| + this._pausedState = false;
|
| + this._holdTime = null;
|
| + this._previousCurrentTime = null;
|
| + this._playbackRate = 1.0;
|
| + this._hasTicked = false;
|
| +
|
| + this.source = source;
|
| + this._lastCurrentTime = undefined;
|
| + this._finishedFlag = false;
|
| + initializeEventTarget(this);
|
| +
|
| + playersAreSorted = false;
|
| + maybeRestartAnimation();
|
| + } finally {
|
| + exitModifyCurrentAnimationState(ensureRetickBeforeGetComputedStyle);
|
| + }
|
| +};
|
| +
|
| +AnimationPlayer.prototype = {
|
| + set source(source) {
|
| + enterModifyCurrentAnimationState();
|
| + try {
|
| + if (isDefinedAndNotNull(this.source)) {
|
| + // To prevent infinite recursion.
|
| + var oldTimedItem = this.source;
|
| + this._source = null;
|
| + oldTimedItem._attach(null);
|
| + }
|
| + this._source = source;
|
| + if (isDefinedAndNotNull(this.source)) {
|
| + this.source._attach(this);
|
| + this._update();
|
| + maybeRestartAnimation();
|
| + }
|
| + } finally {
|
| + exitModifyCurrentAnimationState(repeatLastTick);
|
| + }
|
| + },
|
| + get source() {
|
| + return this._source;
|
| + },
|
| + // This is the effective current time.
|
| + set currentTime(currentTime) {
|
| + enterModifyCurrentAnimationState();
|
| + try {
|
| + this._currentTime = currentTime;
|
| + } finally {
|
| + exitModifyCurrentAnimationState(repeatLastTick);
|
| + }
|
| + },
|
| + get currentTime() {
|
| + return this._currentTime;
|
| + },
|
| + set _currentTime(seekTime) {
|
| + // If we are paused or seeking to a time where limiting applies (i.e. beyond
|
| + // the end in the current direction), update the hold time.
|
| + var sourceContentEnd = this.source ? this.source.endTime : 0;
|
| + if (this.paused ||
|
| + (this.playbackRate > 0 && seekTime >= sourceContentEnd) ||
|
| + (this.playbackRate < 0 && seekTime <= 0)) {
|
| + this._holdTime = seekTime;
|
| + // Otherwise, clear the hold time (it may been set by previously seeking to
|
| + // a limited time) and update the time lag.
|
| + } else {
|
| + this._holdTime = null;
|
| + this._storedTimeLag = (this.timeline.effectiveCurrentTime -
|
| + this.startTime) * this.playbackRate - seekTime;
|
| + }
|
| + this._update();
|
| + maybeRestartAnimation();
|
| + },
|
| + get _currentTime() {
|
| + this._previousCurrentTime = (this.timeline.effectiveCurrentTime -
|
| + this.startTime) * this.playbackRate - this.timeLag;
|
| + return this._previousCurrentTime;
|
| + },
|
| + get _unlimitedCurrentTime() {
|
| + return (this.timeline.effectiveCurrentTime - this.startTime) *
|
| + this.playbackRate - this._storedTimeLag;
|
| + },
|
| + get timeLag() {
|
| + if (this.paused) {
|
| + return this._pauseTimeLag;
|
| + }
|
| +
|
| + // Apply limiting at start of interval when playing in reverse
|
| + if (this.playbackRate < 0 && this._unlimitedCurrentTime <= 0) {
|
| + if (this._holdTime === null) {
|
| + this._holdTime = Math.min(this._previousCurrentTime, 0);
|
| + }
|
| + return this._pauseTimeLag;
|
| + }
|
| +
|
| + // Apply limiting at end of interval when playing forwards
|
| + var sourceContentEnd = this.source ? this.source.endTime : 0;
|
| + if (this.playbackRate > 0 &&
|
| + this._unlimitedCurrentTime >= sourceContentEnd) {
|
| + if (this._holdTime === null) {
|
| + this._holdTime = Math.max(this._previousCurrentTime, sourceContentEnd);
|
| + }
|
| + return this._pauseTimeLag;
|
| + }
|
| +
|
| + // Finished limiting so store pause time lag
|
| + if (this._holdTime !== null) {
|
| + this._storedTimeLag = this._pauseTimeLag;
|
| + this._holdTime = null;
|
| + }
|
| +
|
| + return this._storedTimeLag;
|
| + },
|
| + get _pauseTimeLag() {
|
| + return ((this.timeline.currentTime || 0) - this.startTime) *
|
| + this.playbackRate - this._holdTime;
|
| + },
|
| + set startTime(startTime) {
|
| + enterModifyCurrentAnimationState();
|
| + try {
|
| + // This seeks by updating _startTime and hence the currentTime. It does
|
| + // not affect _storedTimeLag.
|
| + this._startTime = startTime;
|
| + this._holdTime = null;
|
| + playersAreSorted = false;
|
| + this._update();
|
| + maybeRestartAnimation();
|
| + } finally {
|
| + exitModifyCurrentAnimationState(repeatLastTick);
|
| + }
|
| + },
|
| + get startTime() {
|
| + return this._startTime;
|
| + },
|
| + set _paused(isPaused) {
|
| + if (isPaused === this._pausedState) {
|
| + return;
|
| + }
|
| + if (this._pausedState) {
|
| + this._storedTimeLag = this.timeLag;
|
| + this._holdTime = null;
|
| + maybeRestartAnimation();
|
| + } else {
|
| + this._holdTime = this.currentTime;
|
| + }
|
| + this._pausedState = isPaused;
|
| + },
|
| + get paused() {
|
| + return this._pausedState;
|
| + },
|
| + get timeline() {
|
| + return this._timeline;
|
| + },
|
| + set playbackRate(playbackRate) {
|
| + enterModifyCurrentAnimationState();
|
| + try {
|
| + var cachedCurrentTime = this.currentTime;
|
| + // This will impact currentTime, so perform a compensatory seek.
|
| + this._playbackRate = playbackRate;
|
| + this.currentTime = cachedCurrentTime;
|
| + } finally {
|
| + exitModifyCurrentAnimationState(repeatLastTick);
|
| + }
|
| + },
|
| + get playbackRate() {
|
| + return this._playbackRate;
|
| + },
|
| + get finished() {
|
| + return this._isLimited;
|
| + },
|
| + get _isLimited() {
|
| + var sourceEnd = this.source ? this.source.endTime : 0;
|
| + return ((this.playbackRate > 0 && this.currentTime >= sourceEnd) ||
|
| + (this.playbackRate < 0 && this.currentTime <= 0));
|
| + },
|
| + cancel: function() {
|
| + this.source = null;
|
| + },
|
| + finish: function() {
|
| + if (this.playbackRate < 0) {
|
| + this.currentTime = 0;
|
| + } else if (this.playbackRate > 0) {
|
| + var sourceEndTime = this.source ? this.source.endTime : 0;
|
| + if (sourceEndTime === Infinity) {
|
| + throw new Error('InvalidStateError');
|
| + }
|
| + this.currentTime = sourceEndTime;
|
| + }
|
| + },
|
| + play: function() {
|
| + this._paused = false;
|
| + if (!this.source) {
|
| + return;
|
| + }
|
| + if (this.playbackRate > 0 &&
|
| + (this.currentTime < 0 ||
|
| + this.currentTime >= this.source.endTime)) {
|
| + this.currentTime = 0;
|
| + } else if (this.playbackRate < 0 &&
|
| + (this.currentTime <= 0 ||
|
| + this.currentTime > this.source.endTime)) {
|
| + this.currentTime = this.source.endTime;
|
| + }
|
| + },
|
| + pause: function() {
|
| + this._paused = true;
|
| + },
|
| + reverse: function() {
|
| + if (this.playbackRate === 0) {
|
| + return;
|
| + }
|
| + if (this.source) {
|
| + if (this.playbackRate > 0 && this.currentTime >= this.source.endTime) {
|
| + this.currentTime = this.source.endTime;
|
| + } else if (this.playbackRate < 0 && this.currentTime < 0) {
|
| + this.currentTime = 0;
|
| + }
|
| + }
|
| + this.playbackRate = -this.playbackRate;
|
| + this._paused = false;
|
| + },
|
| + _update: function() {
|
| + if (this.source !== null) {
|
| + this.source._updateInheritedTime(
|
| + this.timeline.currentTime === null ? null : this._currentTime);
|
| + this._registerOnTimeline();
|
| + }
|
| + },
|
| + _hasFutureAnimation: function() {
|
| + return this.source === null || this.playbackRate === 0 ||
|
| + this.source._hasFutureAnimation(this.playbackRate > 0);
|
| + },
|
| + _isPastEndOfActiveInterval: function() {
|
| + return this.source === null ||
|
| + this.source._isPastEndOfActiveInterval();
|
| + },
|
| + _isCurrent: function() {
|
| + return this.source && this.source._isCurrent();
|
| + },
|
| + _hasFutureEffect: function() {
|
| + return this.source && this.source._hasFutureEffect();
|
| + },
|
| + _getLeafItemsInEffect: function(items) {
|
| + if (this.source) {
|
| + this.source._getLeafItemsInEffect(items);
|
| + }
|
| + },
|
| + _isTargetingElement: function(element) {
|
| + return this.source && this.source._isTargetingElement(element);
|
| + },
|
| + _getAnimationsTargetingElement: function(element, animations) {
|
| + if (this.source) {
|
| + this.source._getAnimationsTargetingElement(element, animations);
|
| + }
|
| + },
|
| + set onfinish(handler) {
|
| + return setOnEventHandler(this, 'finish', handler);
|
| + },
|
| + get onfinish() {
|
| + return getOnEventHandler(this, 'finish');
|
| + },
|
| + addEventListener: function(type, handler) {
|
| + if (type === 'finish') {
|
| + addEventHandler(this, type, handler);
|
| + }
|
| + },
|
| + removeEventListener: function(type, handler) {
|
| + if (type === 'finish') {
|
| + removeEventHandler(this, type, handler);
|
| + }
|
| + },
|
| + _generateEvents: function() {
|
| + if (!this._finishedFlag && this.finished &&
|
| + hasEventHandlersForEvent(this, 'finish')) {
|
| + var event = new AnimationPlayerEvent('finish', {
|
| + currentTime: this.currentTime,
|
| + timelineTime: this.timeline.currentTime
|
| + });
|
| + event._initialize(this);
|
| + callEventHandlers(this, 'finish', event);
|
| + }
|
| + this._finishedFlag = this.finished;
|
| +
|
| + // The following code is for deprecated TimedItem event handling and should
|
| + // be removed once we stop supporting it.
|
| + if (!isDefinedAndNotNull(this._lastCurrentTime)) {
|
| + this._lastCurrentTime = 0;
|
| + }
|
| +
|
| + this._lastCurrentTime = this._unlimitedCurrentTime;
|
| + },
|
| + _registerOnTimeline: function() {
|
| + if (!this._registeredOnTimeline) {
|
| + PLAYERS.push(this);
|
| + this._registeredOnTimeline = true;
|
| + }
|
| + },
|
| + _deregisterFromTimeline: function() {
|
| + PLAYERS.splice(PLAYERS.indexOf(this), 1);
|
| + this._registeredOnTimeline = false;
|
| + }
|
| +};
|
| +
|
| +
|
| +
|
| +/** @constructor */
|
| +var AnimationPlayerEvent = function(type, eventInit) {
|
| + this._type = type;
|
| + this.currentTime = eventInit.currentTime;
|
| + this.timelineTime = eventInit.timelineTime;
|
| +};
|
| +
|
| +AnimationPlayerEvent.prototype = createEventPrototype();
|
| +
|
| +
|
| +
|
| +/** @constructor */
|
| +var TimedItem = function(token, timingInput) {
|
| + if (token !== constructorToken) {
|
| + throw new TypeError('Illegal constructor');
|
| + }
|
| + this.timing = new Timing(
|
| + constructorToken, timingInput,
|
| + this._specifiedTimingModified.bind(this));
|
| + this._inheritedTime = null;
|
| + this.currentIteration = null;
|
| + this._iterationTime = null;
|
| + this._animationTime = null;
|
| + this._startTime = 0.0;
|
| + this._player = null;
|
| + this._parent = null;
|
| + this._updateInternalState();
|
| + this._fill = this._resolveFillMode(this.timing.fill);
|
| + initializeEventTarget(this);
|
| +};
|
| +
|
| +TimedItem.prototype = {
|
| + // TODO: It would be good to avoid the need for this. We would need to modify
|
| + // call sites to instead rely on a call from the parent.
|
| + get _effectiveParentTime() {
|
| + return this.parent !== null && this.parent._iterationTime !== null ?
|
| + this.parent._iterationTime : 0;
|
| + },
|
| + get localTime() {
|
| + return this._inheritedTime === null ?
|
| + null : this._inheritedTime - this._startTime;
|
| + },
|
| + get startTime() {
|
| + return this._startTime;
|
| + },
|
| + get duration() {
|
| + var result = this.timing._duration();
|
| + if (result === 'auto') {
|
| + result = this._intrinsicDuration();
|
| + }
|
| + return result;
|
| + },
|
| + get activeDuration() {
|
| + var repeatedDuration = this.duration * this.timing._iterations();
|
| + return repeatedDuration / Math.abs(this.timing.playbackRate);
|
| + },
|
| + get endTime() {
|
| + return this._startTime + this.activeDuration + this.timing.delay +
|
| + this.timing.endDelay;
|
| + },
|
| + get parent() {
|
| + return this._parent;
|
| + },
|
| + get previousSibling() {
|
| + if (!this.parent) {
|
| + return null;
|
| + }
|
| + var siblingIndex = this.parent.indexOf(this) - 1;
|
| + if (siblingIndex < 0) {
|
| + return null;
|
| + }
|
| + return this.parent.children[siblingIndex];
|
| + },
|
| + get nextSibling() {
|
| + if (!this.parent) {
|
| + return null;
|
| + }
|
| + var siblingIndex = this.parent.indexOf(this) + 1;
|
| + if (siblingIndex >= this.parent.children.length) {
|
| + return null;
|
| + }
|
| + return this.parent.children[siblingIndex];
|
| + },
|
| + _attach: function(player) {
|
| + // Remove ourselves from our parent, if we have one. This also removes any
|
| + // exsisting player.
|
| + this._reparent(null);
|
| + this._player = player;
|
| + },
|
| + // Takes care of updating the outgoing parent. This is called with a non-null
|
| + // parent only from TimingGroup.splice(), which takes care of calling
|
| + // TimingGroup._childrenStateModified() for the new parent.
|
| + _reparent: function(parent) {
|
| + if (parent === this) {
|
| + throw new Error('parent can not be set to self!');
|
| + }
|
| + enterModifyCurrentAnimationState();
|
| + try {
|
| + if (this._player !== null) {
|
| + this._player.source = null;
|
| + this._player = null;
|
| + }
|
| + if (this.parent !== null) {
|
| + this.remove();
|
| + }
|
| + this._parent = parent;
|
| + // In the case of a AnimationSequence parent, _startTime will be updated
|
| + // by TimingGroup.splice().
|
| + if (this.parent === null || this.parent.type !== 'seq') {
|
| + this._startTime =
|
| + this._stashedStartTime === undefined ? 0.0 : this._stashedStartTime;
|
| + this._stashedStartTime = undefined;
|
| + }
|
| + // In the case of the parent being non-null, _childrenStateModified() will
|
| + // call this via _updateChildInheritedTimes().
|
| + // TODO: Consider optimising this case by skipping this call.
|
| + this._updateTimeMarkers();
|
| + } finally {
|
| + exitModifyCurrentAnimationState(
|
| + Boolean(this.player) ? repeatLastTick : null);
|
| + }
|
| + },
|
| + _intrinsicDuration: function() {
|
| + return 0.0;
|
| + },
|
| + _resolveFillMode: abstractMethod,
|
| + _updateInternalState: function() {
|
| + this._fill = this._resolveFillMode(this.timing.fill);
|
| + if (this.parent) {
|
| + this.parent._childrenStateModified();
|
| + } else if (this._player) {
|
| + this._player._registerOnTimeline();
|
| + }
|
| + this._updateTimeMarkers();
|
| + },
|
| + _specifiedTimingModified: function() {
|
| + enterModifyCurrentAnimationState();
|
| + try {
|
| + this._updateInternalState();
|
| + } finally {
|
| + exitModifyCurrentAnimationState(
|
| + Boolean(this.player) ? repeatLastTick : null);
|
| + }
|
| + },
|
| + // We push time down to children. We could instead have children pull from
|
| + // above, but this is tricky because a TimedItem may use either a parent
|
| + // TimedItem or an AnimationPlayer. This requires either logic in
|
| + // TimedItem, or for TimedItem and AnimationPlayer to implement Timeline
|
| + // (or an equivalent), both of which are ugly.
|
| + _updateInheritedTime: function(inheritedTime) {
|
| + this._inheritedTime = inheritedTime;
|
| + this._updateTimeMarkers();
|
| + },
|
| + _updateAnimationTime: function() {
|
| + if (this.localTime < this.timing.delay) {
|
| + if (this._fill === 'backwards' ||
|
| + this._fill === 'both') {
|
| + this._animationTime = 0;
|
| + } else {
|
| + this._animationTime = null;
|
| + }
|
| + } else if (this.localTime <
|
| + this.timing.delay + this.activeDuration) {
|
| + this._animationTime = this.localTime - this.timing.delay;
|
| + } else {
|
| + if (this._fill === 'forwards' ||
|
| + this._fill === 'both') {
|
| + this._animationTime = this.activeDuration;
|
| + } else {
|
| + this._animationTime = null;
|
| + }
|
| + }
|
| + },
|
| + _updateIterationParamsZeroDuration: function() {
|
| + this._iterationTime = 0;
|
| + var isAtEndOfIterations = this.timing._iterations() !== 0 &&
|
| + this.localTime >= this.timing.delay;
|
| + this.currentIteration = (
|
| + isAtEndOfIterations ?
|
| + this._floorWithOpenClosedRange(
|
| + this.timing.iterationStart + this.timing._iterations(),
|
| + 1.0) :
|
| + this._floorWithClosedOpenRange(this.timing.iterationStart, 1.0));
|
| + // Equivalent to unscaledIterationTime below.
|
| + var unscaledFraction = (
|
| + isAtEndOfIterations ?
|
| + this._modulusWithOpenClosedRange(
|
| + this.timing.iterationStart + this.timing._iterations(),
|
| + 1.0) :
|
| + this._modulusWithClosedOpenRange(this.timing.iterationStart, 1.0));
|
| + var timingFunction = this.timing._timingFunction(this);
|
| + this._timeFraction = (
|
| + this._isCurrentDirectionForwards() ?
|
| + unscaledFraction :
|
| + 1.0 - unscaledFraction);
|
| + ASSERT_ENABLED && assert(
|
| + this._timeFraction >= 0.0 && this._timeFraction <= 1.0,
|
| + 'Time fraction should be in the range [0, 1]');
|
| + if (timingFunction) {
|
| + this._timeFraction = timingFunction.scaleTime(this._timeFraction);
|
| + }
|
| + },
|
| + _getAdjustedAnimationTime: function(animationTime) {
|
| + var startOffset =
|
| + multiplyZeroGivesZero(this.timing.iterationStart, this.duration);
|
| + return (this.timing.playbackRate < 0 ?
|
| + (animationTime - this.activeDuration) : animationTime) *
|
| + this.timing.playbackRate + startOffset;
|
| + },
|
| + _scaleIterationTime: function(unscaledIterationTime) {
|
| + return this._isCurrentDirectionForwards() ?
|
| + unscaledIterationTime :
|
| + this.duration - unscaledIterationTime;
|
| + },
|
| + _updateIterationParams: function() {
|
| + var adjustedAnimationTime =
|
| + this._getAdjustedAnimationTime(this._animationTime);
|
| + var repeatedDuration = this.duration * this.timing._iterations();
|
| + var startOffset = this.timing.iterationStart * this.duration;
|
| + var isAtEndOfIterations = (this.timing._iterations() !== 0) &&
|
| + (adjustedAnimationTime - startOffset === repeatedDuration);
|
| + this.currentIteration = isAtEndOfIterations ?
|
| + this._floorWithOpenClosedRange(
|
| + adjustedAnimationTime, this.duration) :
|
| + this._floorWithClosedOpenRange(
|
| + adjustedAnimationTime, this.duration);
|
| + var unscaledIterationTime = isAtEndOfIterations ?
|
| + this._modulusWithOpenClosedRange(
|
| + adjustedAnimationTime, this.duration) :
|
| + this._modulusWithClosedOpenRange(
|
| + adjustedAnimationTime, this.duration);
|
| + this._iterationTime = this._scaleIterationTime(unscaledIterationTime);
|
| + if (this.duration == Infinity) {
|
| + this._timeFraction = 0;
|
| + return;
|
| + }
|
| + this._timeFraction = this._iterationTime / this.duration;
|
| + ASSERT_ENABLED && assert(
|
| + this._timeFraction >= 0.0 && this._timeFraction <= 1.0,
|
| + 'Time fraction should be in the range [0, 1], got ' +
|
| + this._timeFraction + ' ' + this._iterationTime + ' ' +
|
| + this.duration + ' ' + isAtEndOfIterations + ' ' +
|
| + unscaledIterationTime);
|
| + var timingFunction = this.timing._timingFunction(this);
|
| + if (timingFunction) {
|
| + this._timeFraction = timingFunction.scaleTime(this._timeFraction);
|
| + }
|
| + this._iterationTime = this._timeFraction * this.duration;
|
| + },
|
| + _updateTimeMarkers: function() {
|
| + if (this.localTime === null) {
|
| + this._animationTime = null;
|
| + this._iterationTime = null;
|
| + this.currentIteration = null;
|
| + this._timeFraction = null;
|
| + return false;
|
| + }
|
| + this._updateAnimationTime();
|
| + if (this._animationTime === null) {
|
| + this._iterationTime = null;
|
| + this.currentIteration = null;
|
| + this._timeFraction = null;
|
| + } else if (this.duration === 0) {
|
| + this._updateIterationParamsZeroDuration();
|
| + } else {
|
| + this._updateIterationParams();
|
| + }
|
| + maybeRestartAnimation();
|
| + },
|
| + _floorWithClosedOpenRange: function(x, range) {
|
| + return Math.floor(x / range);
|
| + },
|
| + _floorWithOpenClosedRange: function(x, range) {
|
| + return Math.ceil(x / range) - 1;
|
| + },
|
| + _modulusWithClosedOpenRange: function(x, range) {
|
| + ASSERT_ENABLED && assert(
|
| + range > 0, 'Range must be strictly positive');
|
| + var modulus = x % range;
|
| + var result = modulus < 0 ? modulus + range : modulus;
|
| + ASSERT_ENABLED && assert(
|
| + result >= 0.0 && result < range,
|
| + 'Result should be in the range [0, range)');
|
| + return result;
|
| + },
|
| + _modulusWithOpenClosedRange: function(x, range) {
|
| + var modulus = this._modulusWithClosedOpenRange(x, range);
|
| + var result = modulus === 0 ? range : modulus;
|
| + ASSERT_ENABLED && assert(
|
| + result > 0.0 && result <= range,
|
| + 'Result should be in the range (0, range]');
|
| + return result;
|
| + },
|
| + _isCurrentDirectionForwards: function() {
|
| + if (this.timing.direction === 'normal') {
|
| + return true;
|
| + }
|
| + if (this.timing.direction === 'reverse') {
|
| + return false;
|
| + }
|
| + var d = this.currentIteration;
|
| + if (this.timing.direction === 'alternate-reverse') {
|
| + d += 1;
|
| + }
|
| + // TODO: 6.13.3 step 3. wtf?
|
| + return d % 2 === 0;
|
| + },
|
| + clone: abstractMethod,
|
| + before: function() {
|
| + var newItems = [];
|
| + for (var i = 0; i < arguments.length; i++) {
|
| + newItems.push(arguments[i]);
|
| + }
|
| + this.parent._splice(this.parent.indexOf(this), 0, newItems);
|
| + },
|
| + after: function() {
|
| + var newItems = [];
|
| + for (var i = 0; i < arguments.length; i++) {
|
| + newItems.push(arguments[i]);
|
| + }
|
| + this.parent._splice(this.parent.indexOf(this) + 1, 0, newItems);
|
| + },
|
| + replace: function() {
|
| + var newItems = [];
|
| + for (var i = 0; i < arguments.length; i++) {
|
| + newItems.push(arguments[i]);
|
| + }
|
| + this.parent._splice(this.parent.indexOf(this), 1, newItems);
|
| + },
|
| + remove: function() {
|
| + this.parent._splice(this.parent.indexOf(this), 1);
|
| + },
|
| + // Gets the leaf TimedItems currently in effect. Note that this is a superset
|
| + // of the leaf TimedItems in their active interval, as a TimedItem can have an
|
| + // effect outside its active interval due to fill.
|
| + _getLeafItemsInEffect: function(items) {
|
| + if (this._timeFraction !== null) {
|
| + this._getLeafItemsInEffectImpl(items);
|
| + }
|
| + },
|
| + _getLeafItemsInEffectImpl: abstractMethod,
|
| + _hasFutureAnimation: function(timeDirectionForwards) {
|
| + return timeDirectionForwards ? this._inheritedTime < this.endTime :
|
| + this._inheritedTime > this.startTime;
|
| + },
|
| + _isPastEndOfActiveInterval: function() {
|
| + return this._inheritedTime >= this.endTime;
|
| + },
|
| + get player() {
|
| + return this.parent === null ?
|
| + this._player : this.parent.player;
|
| + },
|
| + _isCurrent: function() {
|
| + return !this._isPastEndOfActiveInterval() ||
|
| + (this.parent !== null && this.parent._isCurrent());
|
| + },
|
| + _isTargetingElement: abstractMethod,
|
| + _getAnimationsTargetingElement: abstractMethod,
|
| + _netEffectivePlaybackRate: function() {
|
| + var effectivePlaybackRate = this._isCurrentDirectionForwards() ?
|
| + this.timing.playbackRate : -this.timing.playbackRate;
|
| + return this.parent === null ? effectivePlaybackRate :
|
| + effectivePlaybackRate * this.parent._netEffectivePlaybackRate();
|
| + },
|
| + // Note that this restriction is currently incomplete - for example,
|
| + // Animations which are playing forwards and have a fill of backwards
|
| + // are not in effect unless current.
|
| + // TODO: Complete this restriction.
|
| + _hasFutureEffect: function() {
|
| + return this._isCurrent() || this._fill !== 'none';
|
| + },
|
| + _toSubRanges: function(fromTime, toTime, iterationTimes) {
|
| + if (fromTime > toTime) {
|
| + var revRanges = this._toSubRanges(toTime, fromTime, iterationTimes);
|
| + revRanges.ranges.forEach(function(a) { a.reverse(); });
|
| + revRanges.ranges.reverse();
|
| + revRanges.start = iterationTimes.length - revRanges.start - 1;
|
| + revRanges.delta = -1;
|
| + return revRanges;
|
| + }
|
| + var skipped = 0;
|
| + // TODO: this should be calculatable. This would be more efficient
|
| + // than searching through the list.
|
| + while (iterationTimes[skipped] < fromTime) {
|
| + skipped++;
|
| + }
|
| + var currentStart = fromTime;
|
| + var ranges = [];
|
| + for (var i = skipped; i < iterationTimes.length; i++) {
|
| + if (iterationTimes[i] < toTime) {
|
| + ranges.push([currentStart, iterationTimes[i]]);
|
| + currentStart = iterationTimes[i];
|
| + } else {
|
| + ranges.push([currentStart, toTime]);
|
| + return {start: skipped, delta: 1, ranges: ranges};
|
| + }
|
| + }
|
| + ranges.push([currentStart, toTime]);
|
| + return {start: skipped, delta: 1, ranges: ranges};
|
| + }
|
| +};
|
| +
|
| +var TimingEvent = function(
|
| + token, target, type, localTime, timelineTime, iterationIndex, seeked) {
|
| + if (token !== constructorToken) {
|
| + throw new TypeError('Illegal constructor');
|
| + }
|
| + this._initialize(target);
|
| + this._type = type;
|
| + this.localTime = localTime;
|
| + this.timelineTime = timelineTime;
|
| + this.iterationIndex = iterationIndex;
|
| + this.seeked = seeked ? true : false;
|
| +};
|
| +
|
| +TimingEvent.prototype = createEventPrototype();
|
| +
|
| +var isEffectCallback = function(animationEffect) {
|
| + return typeof animationEffect === 'function';
|
| +};
|
| +
|
| +var interpretAnimationEffect = function(animationEffect) {
|
| + if (animationEffect instanceof AnimationEffect ||
|
| + isEffectCallback(animationEffect)) {
|
| + return animationEffect;
|
| + } else if (isDefinedAndNotNull(animationEffect) &&
|
| + typeof animationEffect === 'object') {
|
| + // The spec requires animationEffect to be an instance of
|
| + // OneOrMoreKeyframes, but this type is just a dictionary or a list of
|
| + // dictionaries, so the best we can do is test for an object.
|
| + return new KeyframeEffect(animationEffect);
|
| + }
|
| + return null;
|
| +};
|
| +
|
| +var cloneAnimationEffect = function(animationEffect) {
|
| + if (animationEffect instanceof AnimationEffect) {
|
| + return animationEffect.clone();
|
| + } else if (isEffectCallback(animationEffect)) {
|
| + return animationEffect;
|
| + } else {
|
| + return null;
|
| + }
|
| +};
|
| +
|
| +
|
| +
|
| +/** @constructor */
|
| +var Animation = function(target, animationEffect, timingInput) {
|
| + enterModifyCurrentAnimationState();
|
| + try {
|
| + TimedItem.call(this, constructorToken, timingInput);
|
| + this.effect = interpretAnimationEffect(animationEffect);
|
| + this._target = target;
|
| + } finally {
|
| + exitModifyCurrentAnimationState(null);
|
| + }
|
| +};
|
| +
|
| +Animation.prototype = createObject(TimedItem.prototype, {
|
| + _resolveFillMode: function(fillMode) {
|
| + return fillMode === 'auto' ? 'none' : fillMode;
|
| + },
|
| + _sample: function() {
|
| + if (isDefinedAndNotNull(this.effect) &&
|
| + !(this.target instanceof PseudoElementReference)) {
|
| + if (isEffectCallback(this.effect)) {
|
| + this.effect(this._timeFraction, this.target, this);
|
| + } else {
|
| + this.effect._sample(this._timeFraction, this.currentIteration,
|
| + this.target, this.underlyingValue);
|
| + }
|
| + }
|
| + },
|
| + _getLeafItemsInEffectImpl: function(items) {
|
| + items.push(this);
|
| + },
|
| + _isTargetingElement: function(element) {
|
| + return element === this.target;
|
| + },
|
| + _getAnimationsTargetingElement: function(element, animations) {
|
| + if (this._isTargetingElement(element)) {
|
| + animations.push(this);
|
| + }
|
| + },
|
| + get target() {
|
| + return this._target;
|
| + },
|
| + set effect(effect) {
|
| + enterModifyCurrentAnimationState();
|
| + try {
|
| + this._effect = effect;
|
| + this.timing._invalidateTimingFunction();
|
| + } finally {
|
| + exitModifyCurrentAnimationState(
|
| + Boolean(this.player) ? repeatLastTick : null);
|
| + }
|
| + },
|
| + get effect() {
|
| + return this._effect;
|
| + },
|
| + clone: function() {
|
| + return new Animation(this.target,
|
| + cloneAnimationEffect(this.effect), this.timing._dict);
|
| + },
|
| + toString: function() {
|
| + var effectString = '<none>';
|
| + if (this.effect instanceof AnimationEffect) {
|
| + effectString = this.effect.toString();
|
| + } else if (isEffectCallback(this.effect)) {
|
| + effectString = 'Effect callback';
|
| + }
|
| + return 'Animation ' + this.startTime + '-' + this.endTime + ' (' +
|
| + this.localTime + ') ' + effectString;
|
| + }
|
| +});
|
| +
|
| +function throwNewHierarchyRequestError() {
|
| + var element = document.createElement('span');
|
| + element.appendChild(element);
|
| +}
|
| +
|
| +
|
| +
|
| +/** @constructor */
|
| +var TimedItemList = function(token, children) {
|
| + if (token !== constructorToken) {
|
| + throw new TypeError('Illegal constructor');
|
| + }
|
| + this._children = children;
|
| + this._getters = 0;
|
| + this._ensureGetters();
|
| +};
|
| +
|
| +TimedItemList.prototype = {
|
| + get length() {
|
| + return this._children.length;
|
| + },
|
| + _ensureGetters: function() {
|
| + while (this._getters < this._children.length) {
|
| + this._ensureGetter(this._getters++);
|
| + }
|
| + },
|
| + _ensureGetter: function(i) {
|
| + Object.defineProperty(this, i, {
|
| + get: function() {
|
| + return this._children[i];
|
| + }
|
| + });
|
| + }
|
| +};
|
| +
|
| +
|
| +
|
| +/** @constructor */
|
| +var TimingGroup = function(token, type, children, timing) {
|
| + if (token !== constructorToken) {
|
| + throw new TypeError('Illegal constructor');
|
| + }
|
| + // Take a copy of the children array, as it could be modified as a side-effect
|
| + // of creating this object. See
|
| + // https://github.com/web-animations/web-animations-js/issues/65 for details.
|
| + var childrenCopy = (children && Array.isArray(children)) ?
|
| + children.slice() : [];
|
| + // used by TimedItem via _intrinsicDuration(), so needs to be set before
|
| + // initializing super.
|
| + this.type = type || 'par';
|
| + this._children = [];
|
| + this._cachedTimedItemList = null;
|
| + this._cachedIntrinsicDuration = null;
|
| + TimedItem.call(this, constructorToken, timing);
|
| + // We add children after setting the parent. This means that if an ancestor
|
| + // (including the parent) is specified as a child, it will be removed from our
|
| + // ancestors and used as a child,
|
| + this.append.apply(this, childrenCopy);
|
| +};
|
| +
|
| +TimingGroup.prototype = createObject(TimedItem.prototype, {
|
| + _resolveFillMode: function(fillMode) {
|
| + return fillMode === 'auto' ? 'both' : fillMode;
|
| + },
|
| + _childrenStateModified: function() {
|
| + // See _updateChildStartTimes().
|
| + this._isInChildrenStateModified = true;
|
| + if (this._cachedTimedItemList) {
|
| + this._cachedTimedItemList._ensureGetters();
|
| + }
|
| + this._cachedIntrinsicDuration = null;
|
| +
|
| + // We need to walk up and down the tree to re-layout. endTime and the
|
| + // various durations (which are all calculated lazily) are the only
|
| + // properties of a TimedItem which can affect the layout of its ancestors.
|
| + // So it should be sufficient to simply update start times and time markers
|
| + // on the way down.
|
| +
|
| + // This calls up to our parent, then calls _updateTimeMarkers().
|
| + this._updateInternalState();
|
| + this._updateChildInheritedTimes();
|
| +
|
| + // Update child start times before walking down.
|
| + this._updateChildStartTimes();
|
| +
|
| + this._isInChildrenStateModified = false;
|
| + },
|
| + _updateInheritedTime: function(inheritedTime) {
|
| + this._inheritedTime = inheritedTime;
|
| + this._updateTimeMarkers();
|
| + this._updateChildInheritedTimes();
|
| + },
|
| + _updateChildInheritedTimes: function() {
|
| + for (var i = 0; i < this._children.length; i++) {
|
| + var child = this._children[i];
|
| + child._updateInheritedTime(this._iterationTime);
|
| + }
|
| + },
|
| + _updateChildStartTimes: function() {
|
| + if (this.type === 'seq') {
|
| + var cumulativeStartTime = 0;
|
| + for (var i = 0; i < this._children.length; i++) {
|
| + var child = this._children[i];
|
| + if (child._stashedStartTime === undefined) {
|
| + child._stashedStartTime = child._startTime;
|
| + }
|
| + child._startTime = cumulativeStartTime;
|
| + // Avoid updating the child's inherited time and time markers if this is
|
| + // about to be done in the down phase of _childrenStateModified().
|
| + if (!child._isInChildrenStateModified) {
|
| + // This calls _updateTimeMarkers() on the child.
|
| + child._updateInheritedTime(this._iterationTime);
|
| + }
|
| + cumulativeStartTime += Math.max(0, child.timing.delay +
|
| + child.activeDuration + child.timing.endDelay);
|
| + }
|
| + }
|
| + },
|
| + get children() {
|
| + if (!this._cachedTimedItemList) {
|
| + this._cachedTimedItemList = new TimedItemList(
|
| + constructorToken, this._children);
|
| + }
|
| + return this._cachedTimedItemList;
|
| + },
|
| + get firstChild() {
|
| + return this._children[0];
|
| + },
|
| + get lastChild() {
|
| + return this._children[this.children.length - 1];
|
| + },
|
| + _intrinsicDuration: function() {
|
| + if (!isDefinedAndNotNull(this._cachedIntrinsicDuration)) {
|
| + if (this.type === 'par') {
|
| + var dur = Math.max.apply(undefined, this._children.map(function(a) {
|
| + return a.endTime;
|
| + }));
|
| + this._cachedIntrinsicDuration = Math.max(0, dur);
|
| + } else if (this.type === 'seq') {
|
| + var result = 0;
|
| + this._children.forEach(function(a) {
|
| + result += a.activeDuration + a.timing.delay + a.timing.endDelay;
|
| + });
|
| + this._cachedIntrinsicDuration = result;
|
| + } else {
|
| + throw 'Unsupported type ' + this.type;
|
| + }
|
| + }
|
| + return this._cachedIntrinsicDuration;
|
| + },
|
| + _getLeafItemsInEffectImpl: function(items) {
|
| + for (var i = 0; i < this._children.length; i++) {
|
| + this._children[i]._getLeafItemsInEffect(items);
|
| + }
|
| + },
|
| + clone: function() {
|
| + var children = [];
|
| + this._children.forEach(function(child) {
|
| + children.push(child.clone());
|
| + });
|
| + return this.type === 'par' ?
|
| + new AnimationGroup(children, this.timing._dict) :
|
| + new AnimationSequence(children, this.timing._dict);
|
| + },
|
| + clear: function() {
|
| + this._splice(0, this._children.length);
|
| + },
|
| + append: function() {
|
| + var newItems = [];
|
| + for (var i = 0; i < arguments.length; i++) {
|
| + newItems.push(arguments[i]);
|
| + }
|
| + this._splice(this._children.length, 0, newItems);
|
| + },
|
| + prepend: function() {
|
| + var newItems = [];
|
| + for (var i = 0; i < arguments.length; i++) {
|
| + newItems.push(arguments[i]);
|
| + }
|
| + this._splice(0, 0, newItems);
|
| + },
|
| + _addInternal: function(child) {
|
| + this._children.push(child);
|
| + this._childrenStateModified();
|
| + },
|
| + indexOf: function(item) {
|
| + return this._children.indexOf(item);
|
| + },
|
| + _splice: function(start, deleteCount, newItems) {
|
| + enterModifyCurrentAnimationState();
|
| + try {
|
| + var args = arguments;
|
| + if (args.length === 3) {
|
| + args = [start, deleteCount].concat(newItems);
|
| + }
|
| + for (var i = 2; i < args.length; i++) {
|
| + var newChild = args[i];
|
| + if (this._isInclusiveAncestor(newChild)) {
|
| + throwNewHierarchyRequestError();
|
| + }
|
| + newChild._reparent(this);
|
| + }
|
| + var result = Array.prototype.splice.apply(this._children, args);
|
| + for (var i = 0; i < result.length; i++) {
|
| + result[i]._parent = null;
|
| + }
|
| + this._childrenStateModified();
|
| + return result;
|
| + } finally {
|
| + exitModifyCurrentAnimationState(
|
| + Boolean(this.player) ? repeatLastTick : null);
|
| + }
|
| + },
|
| + _isInclusiveAncestor: function(item) {
|
| + for (var ancestor = this; ancestor !== null; ancestor = ancestor.parent) {
|
| + if (ancestor === item) {
|
| + return true;
|
| + }
|
| + }
|
| + return false;
|
| + },
|
| + _isTargetingElement: function(element) {
|
| + return this._children.some(function(child) {
|
| + return child._isTargetingElement(element);
|
| + });
|
| + },
|
| + _getAnimationsTargetingElement: function(element, animations) {
|
| + this._children.map(function(child) {
|
| + return child._getAnimationsTargetingElement(element, animations);
|
| + });
|
| + },
|
| + toString: function() {
|
| + return this.type + ' ' + this.startTime + '-' + this.endTime + ' (' +
|
| + this.localTime + ') ' + ' [' +
|
| + this._children.map(function(a) { return a.toString(); }) + ']';
|
| + }
|
| +});
|
| +
|
| +
|
| +
|
| +/** @constructor */
|
| +var AnimationGroup = function(children, timing, parent) {
|
| + TimingGroup.call(this, constructorToken, 'par', children, timing, parent);
|
| +};
|
| +
|
| +AnimationGroup.prototype = Object.create(TimingGroup.prototype);
|
| +
|
| +
|
| +
|
| +/** @constructor */
|
| +var AnimationSequence = function(children, timing, parent) {
|
| + TimingGroup.call(this, constructorToken, 'seq', children, timing, parent);
|
| +};
|
| +
|
| +AnimationSequence.prototype = Object.create(TimingGroup.prototype);
|
| +
|
| +
|
| +
|
| +/** @constructor */
|
| +var PseudoElementReference = function(element, pseudoElement) {
|
| + this.element = element;
|
| + this.pseudoElement = pseudoElement;
|
| + console.warn('PseudoElementReference is not supported.');
|
| +};
|
| +
|
| +
|
| +
|
| +/** @constructor */
|
| +var MediaReference = function(mediaElement, timing, parent, delta) {
|
| + TimedItem.call(this, constructorToken, timing, parent);
|
| + this._media = mediaElement;
|
| +
|
| + // We can never be sure when _updateInheritedTime() is going to be called
|
| + // next, due to skipped frames or the player being seeked. Plus the media
|
| + // element's currentTime may drift from our iterationTime. So if a media
|
| + // element has loop set, we can't be sure that we'll stop it before it wraps.
|
| + // For this reason, we simply disable looping.
|
| + // TODO: Maybe we should let it loop if our duration exceeds it's
|
| + // length?
|
| + this._media.loop = false;
|
| +
|
| + // If the media element has a media controller, we detach it. This mirrors the
|
| + // behaviour when re-parenting a TimedItem, or attaching one to an
|
| + // AnimationPlayer.
|
| + // TODO: It would be neater to assign to MediaElement.controller, but this was
|
| + // broken in Chrome until recently. See crbug.com/226270.
|
| + this._media.mediaGroup = '';
|
| +
|
| + this._delta = delta;
|
| +};
|
| +
|
| +MediaReference.prototype = createObject(TimedItem.prototype, {
|
| + _resolveFillMode: function(fillMode) {
|
| + // TODO: Fill modes for MediaReferences are still undecided. The spec is not
|
| + // clear what 'auto' should mean for TimedItems other than Animations and
|
| + // groups.
|
| + return fillMode === 'auto' ? 'none' : fillMode;
|
| + },
|
| + _intrinsicDuration: function() {
|
| + // TODO: This should probably default to zero. But doing so means that as
|
| + // soon as our inheritedTime is zero, the polyfill deems the animation to be
|
| + // done and stops ticking, so we don't get any further calls to
|
| + // _updateInheritedTime(). One way around this would be to modify
|
| + // TimedItem._isPastEndOfActiveInterval() to recurse down the tree, then we
|
| + // could override it here.
|
| + return isNaN(this._media.duration) ?
|
| + Infinity : this._media.duration / this._media.defaultPlaybackRate;
|
| + },
|
| + _unscaledMediaCurrentTime: function() {
|
| + return this._media.currentTime / this._media.defaultPlaybackRate;
|
| + },
|
| + _getLeafItemsInEffectImpl: function(items) {
|
| + items.push(this);
|
| + },
|
| + _ensurePlaying: function() {
|
| + // The media element is paused when created.
|
| + if (this._media.paused) {
|
| + this._media.play();
|
| + }
|
| + },
|
| + _ensurePaused: function() {
|
| + if (!this._media.paused) {
|
| + this._media.pause();
|
| + }
|
| + },
|
| + _isSeekableUnscaledTime: function(time) {
|
| + var seekTime = time * this._media.defaultPlaybackRate;
|
| + var ranges = this._media.seekable;
|
| + for (var i = 0; i < ranges.length; i++) {
|
| + if (seekTime >= ranges.start(i) && seekTime <= ranges.end(i)) {
|
| + return true;
|
| + }
|
| + }
|
| + return false;
|
| + },
|
| + // Note that a media element's timeline may not start at zero, although its
|
| + // duration is always the timeline time at the end point. This means that an
|
| + // element's duration isn't always it's length and not all values of the
|
| + // timline are seekable. Furthermore, some types of media further limit the
|
| + // range of seekable timeline times. For this reason, we always map an
|
| + // iteration to the range [0, duration] and simply seek to the nearest
|
| + // seekable time.
|
| + _ensureIsAtUnscaledTime: function(time) {
|
| + if (this._unscaledMediaCurrentTime() !== time) {
|
| + this._media.currentTime = time * this._media.defaultPlaybackRate;
|
| + }
|
| + },
|
| + // This is called by the polyfill on each tick when our AnimationPlayer's tree
|
| + // is active.
|
| + _updateInheritedTime: function(inheritedTime) {
|
| + this._inheritedTime = inheritedTime;
|
| + this._updateTimeMarkers();
|
| +
|
| + // The polyfill uses a sampling model whereby time values are propagated
|
| + // down the tree at each sample. However, for the media item, we need to use
|
| + // play() and pause().
|
| +
|
| + // Handle the case of being outside our effect interval.
|
| + if (this._iterationTime === null) {
|
| + this._ensureIsAtUnscaledTime(0);
|
| + this._ensurePaused();
|
| + return;
|
| + }
|
| +
|
| + if (this._iterationTime >= this._intrinsicDuration()) {
|
| + // Our iteration time exceeds the media element's duration, so just make
|
| + // sure the media element is at the end. It will stop automatically, but
|
| + // that could take some time if the seek below is significant, so force
|
| + // it.
|
| + this._ensureIsAtUnscaledTime(this._intrinsicDuration());
|
| + this._ensurePaused();
|
| + return;
|
| + }
|
| +
|
| + var finalIteration = this._floorWithOpenClosedRange(
|
| + this.timing.iterationStart + this.timing._iterations(), 1.0);
|
| + var endTimeFraction = this._modulusWithOpenClosedRange(
|
| + this.timing.iterationStart + this.timing._iterations(), 1.0);
|
| + if (this.currentIteration === finalIteration &&
|
| + this._timeFraction === endTimeFraction &&
|
| + this._intrinsicDuration() >= this.duration) {
|
| + // We have reached the end of our final iteration, but the media element
|
| + // is not done.
|
| + this._ensureIsAtUnscaledTime(this.duration * endTimeFraction);
|
| + this._ensurePaused();
|
| + return;
|
| + }
|
| +
|
| + // Set the appropriate playback rate.
|
| + var playbackRate =
|
| + this._media.defaultPlaybackRate * this._netEffectivePlaybackRate();
|
| + if (this._media.playbackRate !== playbackRate) {
|
| + this._media.playbackRate = playbackRate;
|
| + }
|
| +
|
| + // Set the appropriate play/pause state. Note that we may not be able to
|
| + // seek to the desired time. In this case, the media element's seek
|
| + // algorithm repositions the seek to the nearest seekable time. This is OK,
|
| + // but in this case, we don't want to play the media element, as it prevents
|
| + // us from synchronising properly.
|
| + if (this.player.paused ||
|
| + !this._isSeekableUnscaledTime(this._iterationTime)) {
|
| + this._ensurePaused();
|
| + } else {
|
| + this._ensurePlaying();
|
| + }
|
| +
|
| + // Seek if required. This could be due to our AnimationPlayer being seeked,
|
| + // or video slippage. We need to handle the fact that the video may not play
|
| + // at exactly the right speed. There's also a variable delay when the video
|
| + // is first played.
|
| + // TODO: What's the right value for this delta?
|
| + var delta = isDefinedAndNotNull(this._delta) ? this._delta :
|
| + 0.2 * Math.abs(this._media.playbackRate);
|
| + if (Math.abs(this._iterationTime - this._unscaledMediaCurrentTime()) >
|
| + delta) {
|
| + this._ensureIsAtUnscaledTime(this._iterationTime);
|
| + }
|
| + },
|
| + _isTargetingElement: function(element) {
|
| + return this._media === element;
|
| + },
|
| + _getAnimationsTargetingElement: function() { },
|
| + _attach: function(player) {
|
| + this._ensurePaused();
|
| + TimedItem.prototype._attach.call(this, player);
|
| + }
|
| +});
|
| +
|
| +
|
| +
|
| +/** @constructor */
|
| +var AnimationEffect = function(token) {
|
| + if (token !== constructorToken) {
|
| + throw new TypeError('Illegal constructor');
|
| + }
|
| +};
|
| +
|
| +AnimationEffect.prototype = {
|
| + _sample: abstractMethod,
|
| + clone: abstractMethod,
|
| + toString: abstractMethod
|
| +};
|
| +
|
| +var clamp = function(x, min, max) {
|
| + return Math.max(Math.min(x, max), min);
|
| +};
|
| +
|
| +
|
| +
|
| +/** @constructor */
|
| +var MotionPathEffect = function(path, autoRotate, angle, composite) {
|
| + var iterationComposite = undefined;
|
| + var options = autoRotate;
|
| + if (typeof options == 'string' || options instanceof String ||
|
| + angle || composite) {
|
| + // FIXME: add deprecation warning - please pass an options dictionary to
|
| + // MotionPathEffect constructor
|
| + } else if (options) {
|
| + autoRotate = options.autoRotate;
|
| + angle = options.angle;
|
| + composite = options.composite;
|
| + iterationComposite = options.iterationComposite;
|
| + }
|
| +
|
| + enterModifyCurrentAnimationState();
|
| + try {
|
| + AnimationEffect.call(this, constructorToken);
|
| +
|
| + this.composite = composite;
|
| + this.iterationComposite = iterationComposite;
|
| +
|
| + // TODO: path argument is not in the spec -- seems useful since
|
| + // SVGPathSegList doesn't have a constructor.
|
| + this.autoRotate = isDefined(autoRotate) ? autoRotate : 'none';
|
| + this.angle = isDefined(angle) ? angle : 0;
|
| + this._path = document.createElementNS(SVG_NS, 'path');
|
| + if (path instanceof SVGPathSegList) {
|
| + this.segments = path;
|
| + } else {
|
| + var tempPath = document.createElementNS(SVG_NS, 'path');
|
| + tempPath.setAttribute('d', String(path));
|
| + this.segments = tempPath.pathSegList;
|
| + }
|
| + } finally {
|
| + exitModifyCurrentAnimationState(null);
|
| + }
|
| +};
|
| +
|
| +MotionPathEffect.prototype = createObject(AnimationEffect.prototype, {
|
| + get composite() {
|
| + return this._composite;
|
| + },
|
| + set composite(value) {
|
| + enterModifyCurrentAnimationState();
|
| + try {
|
| + // Use the default value if an invalid string is specified.
|
| + this._composite = value === 'add' ? 'add' : 'replace';
|
| + } finally {
|
| + exitModifyCurrentAnimationState(repeatLastTick);
|
| + }
|
| + },
|
| + get iterationComposite() {
|
| + return this._iterationComposite;
|
| + },
|
| + set iterationComposite(value) {
|
| + enterModifyCurrentAnimationState();
|
| + try {
|
| + // Use the default value if an invalid string is specified.
|
| + this._iterationComposite =
|
| + value === 'accumulate' ? 'accumulate' : 'replace';
|
| + this._updateOffsetPerIteration();
|
| + } finally {
|
| + exitModifyCurrentAnimationState(repeatLastTick);
|
| + }
|
| + },
|
| + _sample: function(timeFraction, currentIteration, target) {
|
| + // TODO: Handle accumulation.
|
| + var lengthAtTimeFraction = this._lengthAtTimeFraction(timeFraction);
|
| + var point = this._path.getPointAtLength(lengthAtTimeFraction);
|
| + var x = point.x - target.offsetWidth / 2;
|
| + var y = point.y - target.offsetHeight / 2;
|
| + if (currentIteration !== 0 && this._offsetPerIteration) {
|
| + x += this._offsetPerIteration.x * currentIteration;
|
| + y += this._offsetPerIteration.y * currentIteration;
|
| + }
|
| + // TODO: calc(point.x - 50%) doesn't work?
|
| + var value = [{t: 'translate', d: [{px: x}, {px: y}]}];
|
| + var angle = this.angle;
|
| + if (this._autoRotate === 'auto-rotate') {
|
| + // Super hacks
|
| + var lastPoint = this._path.getPointAtLength(lengthAtTimeFraction - 0.01);
|
| + var dx = point.x - lastPoint.x;
|
| + var dy = point.y - lastPoint.y;
|
| + var rotation = Math.atan2(dy, dx);
|
| + angle += rotation / 2 / Math.PI * 360;
|
| + }
|
| + value.push({t: 'rotate', d: [angle]});
|
| + compositor.setAnimatedValue(target, 'transform',
|
| + new AddReplaceCompositableValue(value, this.composite));
|
| + },
|
| + _lengthAtTimeFraction: function(timeFraction) {
|
| + var segmentCount = this._cumulativeLengths.length - 1;
|
| + if (!segmentCount) {
|
| + return 0;
|
| + }
|
| + var scaledFraction = timeFraction * segmentCount;
|
| + var index = clamp(Math.floor(scaledFraction), 0, segmentCount);
|
| + return this._cumulativeLengths[index] + ((scaledFraction % 1) * (
|
| + this._cumulativeLengths[index + 1] - this._cumulativeLengths[index]));
|
| + },
|
| + _updateOffsetPerIteration: function() {
|
| + if (this.iterationComposite === 'accumulate' &&
|
| + this._cumulativeLengths &&
|
| + this._cumulativeLengths.length > 0) {
|
| + this._offsetPerIteration = this._path.getPointAtLength(
|
| + this._cumulativeLengths[this._cumulativeLengths.length - 1]);
|
| + } else {
|
| + this._offsetPerIteration = null;
|
| + }
|
| + },
|
| + clone: function() {
|
| + return new MotionPathEffect(this._path.getAttribute('d'));
|
| + },
|
| + toString: function() {
|
| + return '<MotionPathEffect>';
|
| + },
|
| + set autoRotate(autoRotate) {
|
| + enterModifyCurrentAnimationState();
|
| + try {
|
| + this._autoRotate = String(autoRotate);
|
| + } finally {
|
| + exitModifyCurrentAnimationState(repeatLastTick);
|
| + }
|
| + },
|
| + get autoRotate() {
|
| + return this._autoRotate;
|
| + },
|
| + set angle(angle) {
|
| + enterModifyCurrentAnimationState();
|
| + try {
|
| + // TODO: This should probably be a string with a unit, but the spec
|
| + // says it's a double.
|
| + this._angle = Number(angle);
|
| + } finally {
|
| + exitModifyCurrentAnimationState(repeatLastTick);
|
| + }
|
| + },
|
| + get angle() {
|
| + return this._angle;
|
| + },
|
| + set segments(segments) {
|
| + enterModifyCurrentAnimationState();
|
| + try {
|
| + var targetSegments = this.segments;
|
| + targetSegments.clear();
|
| + var cumulativeLengths = [0];
|
| + // TODO: *moving* the path segments is not correct, but pathSegList
|
| + // is read only
|
| + var items = segments.numberOfItems;
|
| + while (targetSegments.numberOfItems < items) {
|
| + var segment = segments.removeItem(0);
|
| + targetSegments.appendItem(segment);
|
| + if (segment.pathSegType !== SVGPathSeg.PATHSEG_MOVETO_REL &&
|
| + segment.pathSegType !== SVGPathSeg.PATHSEG_MOVETO_ABS) {
|
| + cumulativeLengths.push(this._path.getTotalLength());
|
| + }
|
| + }
|
| + this._cumulativeLengths = cumulativeLengths;
|
| + this._updateOffsetPerIteration();
|
| + } finally {
|
| + exitModifyCurrentAnimationState(repeatLastTick);
|
| + }
|
| + },
|
| + get segments() {
|
| + return this._path.pathSegList;
|
| + }
|
| +});
|
| +
|
| +var shorthandToLonghand = {
|
| + background: [
|
| + 'backgroundImage',
|
| + 'backgroundPosition',
|
| + 'backgroundSize',
|
| + 'backgroundRepeat',
|
| + 'backgroundAttachment',
|
| + 'backgroundOrigin',
|
| + 'backgroundClip',
|
| + 'backgroundColor'
|
| + ],
|
| + border: [
|
| + 'borderTopColor',
|
| + 'borderTopStyle',
|
| + 'borderTopWidth',
|
| + 'borderRightColor',
|
| + 'borderRightStyle',
|
| + 'borderRightWidth',
|
| + 'borderBottomColor',
|
| + 'borderBottomStyle',
|
| + 'borderBottomWidth',
|
| + 'borderLeftColor',
|
| + 'borderLeftStyle',
|
| + 'borderLeftWidth'
|
| + ],
|
| + borderBottom: [
|
| + 'borderBottomWidth',
|
| + 'borderBottomStyle',
|
| + 'borderBottomColor'
|
| + ],
|
| + borderColor: [
|
| + 'borderTopColor',
|
| + 'borderRightColor',
|
| + 'borderBottomColor',
|
| + 'borderLeftColor'
|
| + ],
|
| + borderLeft: [
|
| + 'borderLeftWidth',
|
| + 'borderLeftStyle',
|
| + 'borderLeftColor'
|
| + ],
|
| + borderRadius: [
|
| + 'borderTopLeftRadius',
|
| + 'borderTopRightRadius',
|
| + 'borderBottomRightRadius',
|
| + 'borderBottomLeftRadius'
|
| + ],
|
| + borderRight: [
|
| + 'borderRightWidth',
|
| + 'borderRightStyle',
|
| + 'borderRightColor'
|
| + ],
|
| + borderTop: [
|
| + 'borderTopWidth',
|
| + 'borderTopStyle',
|
| + 'borderTopColor'
|
| + ],
|
| + borderWidth: [
|
| + 'borderTopWidth',
|
| + 'borderRightWidth',
|
| + 'borderBottomWidth',
|
| + 'borderLeftWidth'
|
| + ],
|
| + font: [
|
| + 'fontFamily',
|
| + 'fontSize',
|
| + 'fontStyle',
|
| + 'fontVariant',
|
| + 'fontWeight',
|
| + 'lineHeight'
|
| + ],
|
| + margin: [
|
| + 'marginTop',
|
| + 'marginRight',
|
| + 'marginBottom',
|
| + 'marginLeft'
|
| + ],
|
| + outline: [
|
| + 'outlineColor',
|
| + 'outlineStyle',
|
| + 'outlineWidth'
|
| + ],
|
| + padding: [
|
| + 'paddingTop',
|
| + 'paddingRight',
|
| + 'paddingBottom',
|
| + 'paddingLeft'
|
| + ]
|
| +};
|
| +
|
| +// This delegates parsing shorthand value syntax to the browser.
|
| +var shorthandExpanderElem = createDummyElement();
|
| +var expandShorthand = function(property, value, result) {
|
| + shorthandExpanderElem.style[property] = value;
|
| + var longProperties = shorthandToLonghand[property];
|
| + for (var i in longProperties) {
|
| + var longProperty = longProperties[i];
|
| + var longhandValue = shorthandExpanderElem.style[longProperty];
|
| + result[longProperty] = longhandValue;
|
| + }
|
| +};
|
| +
|
| +var normalizeKeyframeDictionary = function(properties) {
|
| + var result = {
|
| + offset: null,
|
| + composite: null,
|
| + easing: presetTimingFunctions.linear
|
| + };
|
| + var animationProperties = [];
|
| + for (var property in properties) {
|
| + // TODO: Apply the CSS property to IDL attribute algorithm.
|
| + if (property === 'offset') {
|
| + if (typeof properties.offset === 'number') {
|
| + result.offset = properties.offset;
|
| + }
|
| + } else if (property === 'composite') {
|
| + if (properties.composite === 'add' ||
|
| + properties.composite === 'replace') {
|
| + result.composite = properties.composite;
|
| + }
|
| + } else if (property === 'easing') {
|
| + result.easing = TimingFunction.createFromString(properties.easing);
|
| + } else {
|
| + // TODO: Check whether this is a supported property.
|
| + animationProperties.push(property);
|
| + }
|
| + }
|
| + // TODO: Remove prefixed properties if the unprefixed version is also
|
| + // supported and present.
|
| + animationProperties = animationProperties.sort(playerSortFunction);
|
| + for (var i = 0; i < animationProperties.length; i++) {
|
| + // TODO: Apply the IDL attribute to CSS property algorithm.
|
| + var property = animationProperties[i];
|
| + // TODO: The spec does not specify how to handle null values.
|
| + // See https://www.w3.org/Bugs/Public/show_bug.cgi?id=22572
|
| + var value = isDefinedAndNotNull(properties[property]) ?
|
| + properties[property].toString() : '';
|
| + if (property in shorthandToLonghand) {
|
| + expandShorthand(property, value, result);
|
| + } else {
|
| + result[property] = value;
|
| + }
|
| + }
|
| + return result;
|
| +};
|
| +
|
| +
|
| +
|
| +/** @constructor */
|
| +var KeyframeEffect = function(oneOrMoreKeyframeDictionaries,
|
| + composite) {
|
| + enterModifyCurrentAnimationState();
|
| + try {
|
| + AnimationEffect.call(this, constructorToken);
|
| +
|
| + this.composite = composite;
|
| +
|
| + this.setFrames(oneOrMoreKeyframeDictionaries);
|
| + } finally {
|
| + exitModifyCurrentAnimationState(null);
|
| + }
|
| +};
|
| +
|
| +KeyframeEffect.prototype = createObject(AnimationEffect.prototype, {
|
| + get composite() {
|
| + return this._composite;
|
| + },
|
| + set composite(value) {
|
| + enterModifyCurrentAnimationState();
|
| + try {
|
| + // Use the default value if an invalid string is specified.
|
| + this._composite = value === 'add' ? 'add' : 'replace';
|
| + } finally {
|
| + exitModifyCurrentAnimationState(repeatLastTick);
|
| + }
|
| + },
|
| + getFrames: function() {
|
| + return this._keyframeDictionaries.slice(0);
|
| + },
|
| + setFrames: function(oneOrMoreKeyframeDictionaries) {
|
| + enterModifyCurrentAnimationState();
|
| + try {
|
| + if (!Array.isArray(oneOrMoreKeyframeDictionaries)) {
|
| + oneOrMoreKeyframeDictionaries = [oneOrMoreKeyframeDictionaries];
|
| + }
|
| + this._keyframeDictionaries =
|
| + oneOrMoreKeyframeDictionaries.map(normalizeKeyframeDictionary);
|
| + // Set lazily
|
| + this._cachedPropertySpecificKeyframes = null;
|
| + } finally {
|
| + exitModifyCurrentAnimationState(repeatLastTick);
|
| + }
|
| + },
|
| + _sample: function(timeFraction, currentIteration, target) {
|
| + var frames = this._propertySpecificKeyframes();
|
| + for (var property in frames) {
|
| + compositor.setAnimatedValue(target, property,
|
| + this._sampleForProperty(
|
| + frames[property], timeFraction, currentIteration));
|
| + }
|
| + },
|
| + _sampleForProperty: function(frames, timeFraction, currentIteration) {
|
| + ASSERT_ENABLED && assert(
|
| + frames.length >= 2,
|
| + 'Interpolation requires at least two keyframes');
|
| +
|
| + var startKeyframeIndex;
|
| + var length = frames.length;
|
| + // We extrapolate differently depending on whether or not there are multiple
|
| + // keyframes at offsets of 0 and 1.
|
| + if (timeFraction < 0.0) {
|
| + if (frames[1].offset === 0.0) {
|
| + return new AddReplaceCompositableValue(frames[0].rawValue(),
|
| + this._compositeForKeyframe(frames[0]));
|
| + } else {
|
| + startKeyframeIndex = 0;
|
| + }
|
| + } else if (timeFraction >= 1.0) {
|
| + if (frames[length - 2].offset === 1.0) {
|
| + return new AddReplaceCompositableValue(frames[length - 1].rawValue(),
|
| + this._compositeForKeyframe(frames[length - 1]));
|
| + } else {
|
| + startKeyframeIndex = length - 2;
|
| + }
|
| + } else {
|
| + for (var i = length - 1; i >= 0; i--) {
|
| + if (frames[i].offset <= timeFraction) {
|
| + ASSERT_ENABLED && assert(frames[i].offset !== 1.0);
|
| + startKeyframeIndex = i;
|
| + break;
|
| + }
|
| + }
|
| + }
|
| + var startKeyframe = frames[startKeyframeIndex];
|
| + var endKeyframe = frames[startKeyframeIndex + 1];
|
| + if (startKeyframe.offset === timeFraction) {
|
| + return new AddReplaceCompositableValue(startKeyframe.rawValue(),
|
| + this._compositeForKeyframe(startKeyframe));
|
| + }
|
| + if (endKeyframe.offset === timeFraction) {
|
| + return new AddReplaceCompositableValue(endKeyframe.rawValue(),
|
| + this._compositeForKeyframe(endKeyframe));
|
| + }
|
| + var intervalDistance = (timeFraction - startKeyframe.offset) /
|
| + (endKeyframe.offset - startKeyframe.offset);
|
| + if (startKeyframe.easing) {
|
| + intervalDistance = startKeyframe.easing.scaleTime(intervalDistance);
|
| + }
|
| + return new BlendedCompositableValue(
|
| + new AddReplaceCompositableValue(startKeyframe.rawValue(),
|
| + this._compositeForKeyframe(startKeyframe)),
|
| + new AddReplaceCompositableValue(endKeyframe.rawValue(),
|
| + this._compositeForKeyframe(endKeyframe)),
|
| + intervalDistance);
|
| + },
|
| + _propertySpecificKeyframes: function() {
|
| + if (isDefinedAndNotNull(this._cachedPropertySpecificKeyframes)) {
|
| + return this._cachedPropertySpecificKeyframes;
|
| + }
|
| +
|
| + this._cachedPropertySpecificKeyframes = {};
|
| + var distributedFrames = this._getDistributedKeyframes();
|
| + for (var i = 0; i < distributedFrames.length; i++) {
|
| + for (var property in distributedFrames[i].cssValues) {
|
| + if (!(property in this._cachedPropertySpecificKeyframes)) {
|
| + this._cachedPropertySpecificKeyframes[property] = [];
|
| + }
|
| + var frame = distributedFrames[i];
|
| + this._cachedPropertySpecificKeyframes[property].push(
|
| + new PropertySpecificKeyframe(frame.offset, frame.composite,
|
| + frame.easing, property, frame.cssValues[property]));
|
| + }
|
| + }
|
| +
|
| + for (var property in this._cachedPropertySpecificKeyframes) {
|
| + var frames = this._cachedPropertySpecificKeyframes[property];
|
| + ASSERT_ENABLED && assert(
|
| + frames.length > 0,
|
| + 'There should always be keyframes for each property');
|
| +
|
| + // Add synthetic keyframes at offsets of 0 and 1 if required.
|
| + if (frames[0].offset !== 0.0) {
|
| + var keyframe = new PropertySpecificKeyframe(0.0, 'add',
|
| + presetTimingFunctions.linear, property, cssNeutralValue);
|
| + frames.unshift(keyframe);
|
| + }
|
| + if (frames[frames.length - 1].offset !== 1.0) {
|
| + var keyframe = new PropertySpecificKeyframe(1.0, 'add',
|
| + presetTimingFunctions.linear, property, cssNeutralValue);
|
| + frames.push(keyframe);
|
| + }
|
| + ASSERT_ENABLED && assert(
|
| + frames.length >= 2,
|
| + 'There should be at least two keyframes including' +
|
| + ' synthetic keyframes');
|
| + }
|
| +
|
| + return this._cachedPropertySpecificKeyframes;
|
| + },
|
| + clone: function() {
|
| + var result = new KeyframeEffect([], this.composite);
|
| + result._keyframeDictionaries = this._keyframeDictionaries.slice(0);
|
| + return result;
|
| + },
|
| + toString: function() {
|
| + return '<KeyframeEffect>';
|
| + },
|
| + _compositeForKeyframe: function(keyframe) {
|
| + return isDefinedAndNotNull(keyframe.composite) ?
|
| + keyframe.composite : this.composite;
|
| + },
|
| + _allKeyframesUseSameCompositeOperation: function(keyframes) {
|
| + ASSERT_ENABLED && assert(
|
| + keyframes.length >= 1, 'This requires at least one keyframe');
|
| + var composite = this._compositeForKeyframe(keyframes[0]);
|
| + for (var i = 1; i < keyframes.length; i++) {
|
| + if (this._compositeForKeyframe(keyframes[i]) !== composite) {
|
| + return false;
|
| + }
|
| + }
|
| + return true;
|
| + },
|
| + _areKeyframeDictionariesLooselySorted: function() {
|
| + var previousOffset = -Infinity;
|
| + for (var i = 0; i < this._keyframeDictionaries.length; i++) {
|
| + if (isDefinedAndNotNull(this._keyframeDictionaries[i].offset)) {
|
| + if (this._keyframeDictionaries[i].offset < previousOffset) {
|
| + return false;
|
| + }
|
| + previousOffset = this._keyframeDictionaries[i].offset;
|
| + }
|
| + }
|
| + return true;
|
| + },
|
| + // The spec describes both this process and the process for interpretting the
|
| + // properties of a keyframe dictionary as 'normalizing'. Here we use the term
|
| + // 'distributing' to avoid confusion with normalizeKeyframeDictionary().
|
| + _getDistributedKeyframes: function() {
|
| + if (!this._areKeyframeDictionariesLooselySorted()) {
|
| + return [];
|
| + }
|
| +
|
| + var distributedKeyframes = this._keyframeDictionaries.map(
|
| + KeyframeInternal.createFromNormalizedProperties);
|
| +
|
| + // Remove keyframes with offsets out of bounds.
|
| + var length = distributedKeyframes.length;
|
| + var count = 0;
|
| + for (var i = 0; i < length; i++) {
|
| + var offset = distributedKeyframes[i].offset;
|
| + if (isDefinedAndNotNull(offset)) {
|
| + if (offset >= 0) {
|
| + break;
|
| + } else {
|
| + count = i;
|
| + }
|
| + }
|
| + }
|
| + distributedKeyframes.splice(0, count);
|
| +
|
| + length = distributedKeyframes.length;
|
| + count = 0;
|
| + for (var i = length - 1; i >= 0; i--) {
|
| + var offset = distributedKeyframes[i].offset;
|
| + if (isDefinedAndNotNull(offset)) {
|
| + if (offset <= 1) {
|
| + break;
|
| + } else {
|
| + count = length - i;
|
| + }
|
| + }
|
| + }
|
| + distributedKeyframes.splice(length - count, count);
|
| +
|
| + // Distribute offsets.
|
| + length = distributedKeyframes.length;
|
| + if (length > 1 && !isDefinedAndNotNull(distributedKeyframes[0].offset)) {
|
| + distributedKeyframes[0].offset = 0;
|
| + }
|
| + if (length > 0 &&
|
| + !isDefinedAndNotNull(distributedKeyframes[length - 1].offset)) {
|
| + distributedKeyframes[length - 1].offset = 1;
|
| + }
|
| + var lastOffsetIndex = 0;
|
| + var nextOffsetIndex = 0;
|
| + for (var i = 1; i < distributedKeyframes.length - 1; i++) {
|
| + var keyframe = distributedKeyframes[i];
|
| + if (isDefinedAndNotNull(keyframe.offset)) {
|
| + lastOffsetIndex = i;
|
| + continue;
|
| + }
|
| + if (i > nextOffsetIndex) {
|
| + nextOffsetIndex = i;
|
| + while (!isDefinedAndNotNull(
|
| + distributedKeyframes[nextOffsetIndex].offset)) {
|
| + nextOffsetIndex++;
|
| + }
|
| + }
|
| + var lastOffset = distributedKeyframes[lastOffsetIndex].offset;
|
| + var nextOffset = distributedKeyframes[nextOffsetIndex].offset;
|
| + var unspecifiedKeyframes = nextOffsetIndex - lastOffsetIndex - 1;
|
| + ASSERT_ENABLED && assert(unspecifiedKeyframes > 0);
|
| + var localIndex = i - lastOffsetIndex;
|
| + ASSERT_ENABLED && assert(localIndex > 0);
|
| + distributedKeyframes[i].offset = lastOffset +
|
| + (nextOffset - lastOffset) * localIndex / (unspecifiedKeyframes + 1);
|
| + }
|
| +
|
| + // Remove invalid property values.
|
| + for (var i = distributedKeyframes.length - 1; i >= 0; i--) {
|
| + var keyframe = distributedKeyframes[i];
|
| + for (var property in keyframe.cssValues) {
|
| + if (!KeyframeInternal.isSupportedPropertyValue(
|
| + keyframe.cssValues[property])) {
|
| + delete(keyframe.cssValues[property]);
|
| + }
|
| + }
|
| + if (Object.keys(keyframe).length === 0) {
|
| + distributedKeyframes.splice(i, 1);
|
| + }
|
| + }
|
| +
|
| + return distributedKeyframes;
|
| + }
|
| +});
|
| +
|
| +
|
| +
|
| +/**
|
| + * An internal representation of a keyframe. The Keyframe type from the spec is
|
| + * just a dictionary and is not exposed.
|
| + *
|
| + * @constructor
|
| + */
|
| +var KeyframeInternal = function(offset, composite, easing) {
|
| + ASSERT_ENABLED && assert(
|
| + typeof offset === 'number' || offset === null,
|
| + 'Invalid offset value');
|
| + ASSERT_ENABLED && assert(
|
| + composite === 'add' || composite === 'replace' || composite === null,
|
| + 'Invalid composite value');
|
| + this.offset = offset;
|
| + this.composite = composite;
|
| + this.easing = easing;
|
| + this.cssValues = {};
|
| +};
|
| +
|
| +KeyframeInternal.prototype = {
|
| + addPropertyValuePair: function(property, value) {
|
| + ASSERT_ENABLED && assert(!this.cssValues.hasOwnProperty(property));
|
| + this.cssValues[property] = value;
|
| + },
|
| + hasValueForProperty: function(property) {
|
| + return property in this.cssValues;
|
| + }
|
| +};
|
| +
|
| +KeyframeInternal.isSupportedPropertyValue = function(value) {
|
| + ASSERT_ENABLED && assert(
|
| + typeof value === 'string' || value === cssNeutralValue);
|
| + // TODO: Check this properly!
|
| + return value !== '';
|
| +};
|
| +
|
| +KeyframeInternal.createFromNormalizedProperties = function(properties) {
|
| + ASSERT_ENABLED && assert(
|
| + isDefinedAndNotNull(properties) && typeof properties === 'object',
|
| + 'Properties must be an object');
|
| + var keyframe = new KeyframeInternal(properties.offset, properties.composite,
|
| + properties.easing);
|
| + for (var candidate in properties) {
|
| + if (candidate !== 'offset' &&
|
| + candidate !== 'composite' &&
|
| + candidate !== 'easing') {
|
| + keyframe.addPropertyValuePair(candidate, properties[candidate]);
|
| + }
|
| + }
|
| + return keyframe;
|
| +};
|
| +
|
| +
|
| +
|
| +/** @constructor */
|
| +var PropertySpecificKeyframe = function(offset, composite, easing, property,
|
| + cssValue) {
|
| + this.offset = offset;
|
| + this.composite = composite;
|
| + this.easing = easing;
|
| + this.property = property;
|
| + this.cssValue = cssValue;
|
| + // Calculated lazily
|
| + this.cachedRawValue = null;
|
| +};
|
| +
|
| +PropertySpecificKeyframe.prototype = {
|
| + rawValue: function() {
|
| + if (!isDefinedAndNotNull(this.cachedRawValue)) {
|
| + this.cachedRawValue = fromCssValue(this.property, this.cssValue);
|
| + }
|
| + return this.cachedRawValue;
|
| + }
|
| +};
|
| +
|
| +
|
| +
|
| +/** @constructor */
|
| +var TimingFunction = function() {
|
| + throw new TypeError('Illegal constructor');
|
| +};
|
| +
|
| +TimingFunction.prototype.scaleTime = abstractMethod;
|
| +
|
| +TimingFunction.createFromString = function(spec, timedItem) {
|
| + var preset = presetTimingFunctions[spec];
|
| + if (preset) {
|
| + return preset;
|
| + }
|
| + if (spec === 'paced') {
|
| + if (timedItem instanceof Animation &&
|
| + timedItem.effect instanceof MotionPathEffect) {
|
| + return new PacedTimingFunction(timedItem.effect);
|
| + }
|
| + return presetTimingFunctions.linear;
|
| + }
|
| + var stepMatch = /steps\(\s*(\d+)\s*,\s*(start|end|middle)\s*\)/.exec(spec);
|
| + if (stepMatch) {
|
| + return new StepTimingFunction(Number(stepMatch[1]), stepMatch[2]);
|
| + }
|
| + var bezierMatch =
|
| + /cubic-bezier\(([^,]*),([^,]*),([^,]*),([^)]*)\)/.exec(spec);
|
| + if (bezierMatch) {
|
| + return new CubicBezierTimingFunction([
|
| + Number(bezierMatch[1]),
|
| + Number(bezierMatch[2]),
|
| + Number(bezierMatch[3]),
|
| + Number(bezierMatch[4])
|
| + ]);
|
| + }
|
| + return presetTimingFunctions.linear;
|
| +};
|
| +
|
| +
|
| +
|
| +/** @constructor */
|
| +var CubicBezierTimingFunction = function(spec) {
|
| + this.params = spec;
|
| + this.map = [];
|
| + for (var ii = 0; ii <= 100; ii += 1) {
|
| + var i = ii / 100;
|
| + this.map.push([
|
| + 3 * i * (1 - i) * (1 - i) * this.params[0] +
|
| + 3 * i * i * (1 - i) * this.params[2] + i * i * i,
|
| + 3 * i * (1 - i) * (1 - i) * this.params[1] +
|
| + 3 * i * i * (1 - i) * this.params[3] + i * i * i
|
| + ]);
|
| + }
|
| +};
|
| +
|
| +CubicBezierTimingFunction.prototype = createObject(TimingFunction.prototype, {
|
| + scaleTime: function(fraction) {
|
| + var fst = 0;
|
| + while (fst !== 100 && fraction > this.map[fst][0]) {
|
| + fst += 1;
|
| + }
|
| + if (fraction === this.map[fst][0] || fst === 0) {
|
| + return this.map[fst][1];
|
| + }
|
| + var yDiff = this.map[fst][1] - this.map[fst - 1][1];
|
| + var xDiff = this.map[fst][0] - this.map[fst - 1][0];
|
| + var p = (fraction - this.map[fst - 1][0]) / xDiff;
|
| + return this.map[fst - 1][1] + p * yDiff;
|
| + }
|
| +});
|
| +
|
| +
|
| +
|
| +/** @constructor */
|
| +var StepTimingFunction = function(numSteps, position) {
|
| + this.numSteps = numSteps;
|
| + this.position = position || 'end';
|
| +};
|
| +
|
| +StepTimingFunction.prototype = createObject(TimingFunction.prototype, {
|
| + scaleTime: function(fraction) {
|
| + if (fraction >= 1) {
|
| + return 1;
|
| + }
|
| + var stepSize = 1 / this.numSteps;
|
| + if (this.position === 'start') {
|
| + fraction += stepSize;
|
| + } else if (this.position === 'middle') {
|
| + fraction += stepSize / 2;
|
| + }
|
| + return fraction - fraction % stepSize;
|
| + }
|
| +});
|
| +
|
| +var presetTimingFunctions = {
|
| + 'linear': null,
|
| + 'ease': new CubicBezierTimingFunction([0.25, 0.1, 0.25, 1.0]),
|
| + 'ease-in': new CubicBezierTimingFunction([0.42, 0, 1.0, 1.0]),
|
| + 'ease-out': new CubicBezierTimingFunction([0, 0, 0.58, 1.0]),
|
| + 'ease-in-out': new CubicBezierTimingFunction([0.42, 0, 0.58, 1.0]),
|
| + 'step-start': new StepTimingFunction(1, 'start'),
|
| + 'step-middle': new StepTimingFunction(1, 'middle'),
|
| + 'step-end': new StepTimingFunction(1, 'end')
|
| +};
|
| +
|
| +
|
| +
|
| +/** @constructor */
|
| +var PacedTimingFunction = function(pathEffect) {
|
| + ASSERT_ENABLED && assert(pathEffect instanceof MotionPathEffect);
|
| + this._pathEffect = pathEffect;
|
| + // Range is the portion of the effect over which we pace, normalized to
|
| + // [0, 1].
|
| + this._range = {min: 0, max: 1};
|
| +};
|
| +
|
| +PacedTimingFunction.prototype = createObject(TimingFunction.prototype, {
|
| + setRange: function(range) {
|
| + ASSERT_ENABLED && assert(range.min >= 0 && range.min <= 1);
|
| + ASSERT_ENABLED && assert(range.max >= 0 && range.max <= 1);
|
| + ASSERT_ENABLED && assert(range.min < range.max);
|
| + this._range = range;
|
| + },
|
| + scaleTime: function(fraction) {
|
| + var cumulativeLengths = this._pathEffect._cumulativeLengths;
|
| + var numSegments = cumulativeLengths.length - 1;
|
| + if (!cumulativeLengths[numSegments] || fraction <= 0) {
|
| + return this._range.min;
|
| + }
|
| + if (fraction >= 1) {
|
| + return this._range.max;
|
| + }
|
| + var minLength = this.lengthAtIndex(this._range.min * numSegments);
|
| + var maxLength = this.lengthAtIndex(this._range.max * numSegments);
|
| + var length = interp(minLength, maxLength, fraction);
|
| + var leftIndex = this.findLeftIndex(cumulativeLengths, length);
|
| + var leftLength = cumulativeLengths[leftIndex];
|
| + var segmentLength = cumulativeLengths[leftIndex + 1] - leftLength;
|
| + if (segmentLength > 0) {
|
| + return (leftIndex + (length - leftLength) / segmentLength) / numSegments;
|
| + }
|
| + return leftLength / cumulativeLengths.length;
|
| + },
|
| + findLeftIndex: function(array, value) {
|
| + var leftIndex = 0;
|
| + var rightIndex = array.length;
|
| + while (rightIndex - leftIndex > 1) {
|
| + var midIndex = (leftIndex + rightIndex) >> 1;
|
| + if (array[midIndex] <= value) {
|
| + leftIndex = midIndex;
|
| + } else {
|
| + rightIndex = midIndex;
|
| + }
|
| + }
|
| + return leftIndex;
|
| + },
|
| + lengthAtIndex: function(i) {
|
| + ASSERT_ENABLED &&
|
| + console.assert(i >= 0 && i <= cumulativeLengths.length - 1);
|
| + var leftIndex = Math.floor(i);
|
| + var startLength = this._pathEffect._cumulativeLengths[leftIndex];
|
| + var endLength = this._pathEffect._cumulativeLengths[leftIndex + 1];
|
| + var indexFraction = i % 1;
|
| + return interp(startLength, endLength, indexFraction);
|
| + }
|
| +});
|
| +
|
| +var interp = function(from, to, f, type) {
|
| + if (Array.isArray(from) || Array.isArray(to)) {
|
| + return interpArray(from, to, f, type);
|
| + }
|
| + var zero = (type && type.indexOf('scale') === 0) ? 1 : 0;
|
| + to = isDefinedAndNotNull(to) ? to : zero;
|
| + from = isDefinedAndNotNull(from) ? from : zero;
|
| +
|
| + return to * f + from * (1 - f);
|
| +};
|
| +
|
| +var interpArray = function(from, to, f, type) {
|
| + ASSERT_ENABLED && assert(
|
| + Array.isArray(from) || from === null,
|
| + 'From is not an array or null');
|
| + ASSERT_ENABLED && assert(
|
| + Array.isArray(to) || to === null,
|
| + 'To is not an array or null');
|
| + ASSERT_ENABLED && assert(
|
| + from === null || to === null || from.length === to.length,
|
| + 'Arrays differ in length ' + from + ' : ' + to);
|
| + var length = from ? from.length : to.length;
|
| +
|
| + var result = [];
|
| + for (var i = 0; i < length; i++) {
|
| + result[i] = interp(from ? from[i] : null, to ? to[i] : null, f, type);
|
| + }
|
| + return result;
|
| +};
|
| +
|
| +var typeWithKeywords = function(keywords, type) {
|
| + var isKeyword;
|
| + if (keywords.length === 1) {
|
| + var keyword = keywords[0];
|
| + isKeyword = function(value) {
|
| + return value === keyword;
|
| + };
|
| + } else {
|
| + isKeyword = function(value) {
|
| + return keywords.indexOf(value) >= 0;
|
| + };
|
| + }
|
| + return createObject(type, {
|
| + add: function(base, delta) {
|
| + if (isKeyword(base) || isKeyword(delta)) {
|
| + return delta;
|
| + }
|
| + return type.add(base, delta);
|
| + },
|
| + interpolate: function(from, to, f) {
|
| + if (isKeyword(from) || isKeyword(to)) {
|
| + return nonNumericType.interpolate(from, to, f);
|
| + }
|
| + return type.interpolate(from, to, f);
|
| + },
|
| + toCssValue: function(value, svgMode) {
|
| + return isKeyword(value) ? value : type.toCssValue(value, svgMode);
|
| + },
|
| + fromCssValue: function(value) {
|
| + return isKeyword(value) ? value : type.fromCssValue(value);
|
| + }
|
| + });
|
| +};
|
| +
|
| +var numberType = {
|
| + add: function(base, delta) {
|
| + // If base or delta are 'auto', we fall back to replacement.
|
| + if (base === 'auto' || delta === 'auto') {
|
| + return nonNumericType.add(base, delta);
|
| + }
|
| + return base + delta;
|
| + },
|
| + interpolate: function(from, to, f) {
|
| + // If from or to are 'auto', we fall back to step interpolation.
|
| + if (from === 'auto' || to === 'auto') {
|
| + return nonNumericType.interpolate(from, to);
|
| + }
|
| + return interp(from, to, f);
|
| + },
|
| + toCssValue: function(value) { return value + ''; },
|
| + fromCssValue: function(value) {
|
| + if (value === 'auto') {
|
| + return 'auto';
|
| + }
|
| + var result = Number(value);
|
| + return isNaN(result) ? undefined : result;
|
| + }
|
| +};
|
| +
|
| +var integerType = createObject(numberType, {
|
| + interpolate: function(from, to, f) {
|
| + // If from or to are 'auto', we fall back to step interpolation.
|
| + if (from === 'auto' || to === 'auto') {
|
| + return nonNumericType.interpolate(from, to);
|
| + }
|
| + return Math.floor(interp(from, to, f));
|
| + }
|
| +});
|
| +
|
| +var fontWeightType = {
|
| + add: function(base, delta) { return base + delta; },
|
| + interpolate: function(from, to, f) {
|
| + return interp(from, to, f);
|
| + },
|
| + toCssValue: function(value) {
|
| + value = Math.round(value / 100) * 100;
|
| + value = clamp(value, 100, 900);
|
| + if (value === 400) {
|
| + return 'normal';
|
| + }
|
| + if (value === 700) {
|
| + return 'bold';
|
| + }
|
| + return String(value);
|
| + },
|
| + fromCssValue: function(value) {
|
| + // TODO: support lighter / darker ?
|
| + var out = Number(value);
|
| + if (isNaN(out) || out < 100 || out > 900 || out % 100 !== 0) {
|
| + return undefined;
|
| + }
|
| + return out;
|
| + }
|
| +};
|
| +
|
| +// This regular expression is intentionally permissive, so that
|
| +// platform-prefixed versions of calc will still be accepted as
|
| +// input. While we are restrictive with the transform property
|
| +// name, we need to be able to read underlying calc values from
|
| +// computedStyle so can't easily restrict the input here.
|
| +var outerCalcRE = /^\s*(-webkit-)?calc\s*\(\s*([^)]*)\)/;
|
| +var valueRE = /^\s*(-?[0-9]+(\.[0-9])?[0-9]*)([a-zA-Z%]*)/;
|
| +var operatorRE = /^\s*([+-])/;
|
| +var autoRE = /^\s*auto/i;
|
| +var percentLengthType = {
|
| + zero: function() { return {}; },
|
| + add: function(base, delta) {
|
| + var out = {};
|
| + for (var value in base) {
|
| + out[value] = base[value] + (delta[value] || 0);
|
| + }
|
| + for (value in delta) {
|
| + if (value in base) {
|
| + continue;
|
| + }
|
| + out[value] = delta[value];
|
| + }
|
| + return out;
|
| + },
|
| + interpolate: function(from, to, f) {
|
| + var out = {};
|
| + for (var value in from) {
|
| + out[value] = interp(from[value], to[value], f);
|
| + }
|
| + for (var value in to) {
|
| + if (value in out) {
|
| + continue;
|
| + }
|
| + out[value] = interp(0, to[value], f);
|
| + }
|
| + return out;
|
| + },
|
| + toCssValue: function(value) {
|
| + var s = '';
|
| + var singleValue = true;
|
| + for (var item in value) {
|
| + if (s === '') {
|
| + s = value[item] + item;
|
| + } else if (singleValue) {
|
| + if (value[item] !== 0) {
|
| + s = features.calcFunction +
|
| + '(' + s + ' + ' + value[item] + item + ')';
|
| + singleValue = false;
|
| + }
|
| + } else if (value[item] !== 0) {
|
| + s = s.substring(0, s.length - 1) + ' + ' + value[item] + item + ')';
|
| + }
|
| + }
|
| + return s;
|
| + },
|
| + fromCssValue: function(value) {
|
| + var result = percentLengthType.consumeValueFromString(value);
|
| + if (result) {
|
| + return result.value;
|
| + }
|
| + return undefined;
|
| + },
|
| + consumeValueFromString: function(value) {
|
| + if (!isDefinedAndNotNull(value)) {
|
| + return undefined;
|
| + }
|
| + var autoMatch = autoRE.exec(value);
|
| + if (autoMatch) {
|
| + return {
|
| + value: { auto: true },
|
| + remaining: value.substring(autoMatch[0].length)
|
| + };
|
| + }
|
| + var out = {};
|
| + var calcMatch = outerCalcRE.exec(value);
|
| + if (!calcMatch) {
|
| + var singleValue = valueRE.exec(value);
|
| + if (singleValue && (singleValue.length === 4)) {
|
| + out[singleValue[3]] = Number(singleValue[1]);
|
| + return {
|
| + value: out,
|
| + remaining: value.substring(singleValue[0].length)
|
| + };
|
| + }
|
| + return undefined;
|
| + }
|
| + var remaining = value.substring(calcMatch[0].length);
|
| + var calcInnards = calcMatch[2];
|
| + var firstTime = true;
|
| + while (true) {
|
| + var reversed = false;
|
| + if (firstTime) {
|
| + firstTime = false;
|
| + } else {
|
| + var op = operatorRE.exec(calcInnards);
|
| + if (!op) {
|
| + return undefined;
|
| + }
|
| + if (op[1] === '-') {
|
| + reversed = true;
|
| + }
|
| + calcInnards = calcInnards.substring(op[0].length);
|
| + }
|
| + value = valueRE.exec(calcInnards);
|
| + if (!value) {
|
| + return undefined;
|
| + }
|
| + var valueUnit = value[3];
|
| + var valueNumber = Number(value[1]);
|
| + if (!isDefinedAndNotNull(out[valueUnit])) {
|
| + out[valueUnit] = 0;
|
| + }
|
| + if (reversed) {
|
| + out[valueUnit] -= valueNumber;
|
| + } else {
|
| + out[valueUnit] += valueNumber;
|
| + }
|
| + calcInnards = calcInnards.substring(value[0].length);
|
| + if (/\s*/.exec(calcInnards)[0].length === calcInnards.length) {
|
| + return {
|
| + value: out,
|
| + remaining: remaining
|
| + };
|
| + }
|
| + }
|
| + },
|
| + negate: function(value) {
|
| + var out = {};
|
| + for (var unit in value) {
|
| + out[unit] = -value[unit];
|
| + }
|
| + return out;
|
| + }
|
| +};
|
| +
|
| +var percentLengthAutoType = typeWithKeywords(['auto'], percentLengthType);
|
| +
|
| +var positionKeywordRE = /^\s*left|^\s*center|^\s*right|^\s*top|^\s*bottom/i;
|
| +var positionType = {
|
| + zero: function() { return [{ px: 0 }, { px: 0 }]; },
|
| + add: function(base, delta) {
|
| + return [
|
| + percentLengthType.add(base[0], delta[0]),
|
| + percentLengthType.add(base[1], delta[1])
|
| + ];
|
| + },
|
| + interpolate: function(from, to, f) {
|
| + return [
|
| + percentLengthType.interpolate(from[0], to[0], f),
|
| + percentLengthType.interpolate(from[1], to[1], f)
|
| + ];
|
| + },
|
| + toCssValue: function(value) {
|
| + return value.map(percentLengthType.toCssValue).join(' ');
|
| + },
|
| + fromCssValue: function(value) {
|
| + var tokens = positionType.consumeAllTokensFromString(value);
|
| + if (!tokens || tokens.length > 4) {
|
| + return undefined;
|
| + }
|
| +
|
| + if (tokens.length === 1) {
|
| + var token = tokens[0];
|
| + return (positionType.isHorizontalToken(token) ?
|
| + [token, 'center'] : ['center', token]).map(positionType.resolveToken);
|
| + }
|
| +
|
| + if (tokens.length === 2 &&
|
| + positionType.isHorizontalToken(tokens[0]) &&
|
| + positionType.isVerticalToken(tokens[1])) {
|
| + return tokens.map(positionType.resolveToken);
|
| + }
|
| +
|
| + if (tokens.filter(positionType.isKeyword).length !== 2) {
|
| + return undefined;
|
| + }
|
| +
|
| + var out = [undefined, undefined];
|
| + var center = false;
|
| + for (var i = 0; i < tokens.length; i++) {
|
| + var token = tokens[i];
|
| + if (!positionType.isKeyword(token)) {
|
| + return undefined;
|
| + }
|
| + if (token === 'center') {
|
| + if (center) {
|
| + return undefined;
|
| + }
|
| + center = true;
|
| + continue;
|
| + }
|
| + var axis = Number(positionType.isVerticalToken(token));
|
| + if (out[axis]) {
|
| + return undefined;
|
| + }
|
| + if (i === tokens.length - 1 || positionType.isKeyword(tokens[i + 1])) {
|
| + out[axis] = positionType.resolveToken(token);
|
| + continue;
|
| + }
|
| + var percentLength = tokens[++i];
|
| + if (token === 'bottom' || token === 'right') {
|
| + percentLength = percentLengthType.negate(percentLength);
|
| + percentLength['%'] = (percentLength['%'] || 0) + 100;
|
| + }
|
| + out[axis] = percentLength;
|
| + }
|
| + if (center) {
|
| + if (!out[0]) {
|
| + out[0] = positionType.resolveToken('center');
|
| + } else if (!out[1]) {
|
| + out[1] = positionType.resolveToken('center');
|
| + } else {
|
| + return undefined;
|
| + }
|
| + }
|
| + return out.every(isDefinedAndNotNull) ? out : undefined;
|
| + },
|
| + consumeAllTokensFromString: function(remaining) {
|
| + var tokens = [];
|
| + while (remaining.trim()) {
|
| + var result = positionType.consumeTokenFromString(remaining);
|
| + if (!result) {
|
| + return undefined;
|
| + }
|
| + tokens.push(result.value);
|
| + remaining = result.remaining;
|
| + }
|
| + return tokens;
|
| + },
|
| + consumeTokenFromString: function(value) {
|
| + var keywordMatch = positionKeywordRE.exec(value);
|
| + if (keywordMatch) {
|
| + return {
|
| + value: keywordMatch[0].trim().toLowerCase(),
|
| + remaining: value.substring(keywordMatch[0].length)
|
| + };
|
| + }
|
| + return percentLengthType.consumeValueFromString(value);
|
| + },
|
| + resolveToken: function(token) {
|
| + if (typeof token === 'string') {
|
| + return percentLengthType.fromCssValue({
|
| + left: '0%',
|
| + center: '50%',
|
| + right: '100%',
|
| + top: '0%',
|
| + bottom: '100%'
|
| + }[token]);
|
| + }
|
| + return token;
|
| + },
|
| + isHorizontalToken: function(token) {
|
| + if (typeof token === 'string') {
|
| + return token in { left: true, center: true, right: true };
|
| + }
|
| + return true;
|
| + },
|
| + isVerticalToken: function(token) {
|
| + if (typeof token === 'string') {
|
| + return token in { top: true, center: true, bottom: true };
|
| + }
|
| + return true;
|
| + },
|
| + isKeyword: function(token) {
|
| + return typeof token === 'string';
|
| + }
|
| +};
|
| +
|
| +// Spec: http://dev.w3.org/csswg/css-backgrounds/#background-position
|
| +var positionListType = {
|
| + zero: function() { return [positionType.zero()]; },
|
| + add: function(base, delta) {
|
| + var out = [];
|
| + var maxLength = Math.max(base.length, delta.length);
|
| + for (var i = 0; i < maxLength; i++) {
|
| + var basePosition = base[i] ? base[i] : positionType.zero();
|
| + var deltaPosition = delta[i] ? delta[i] : positionType.zero();
|
| + out.push(positionType.add(basePosition, deltaPosition));
|
| + }
|
| + return out;
|
| + },
|
| + interpolate: function(from, to, f) {
|
| + var out = [];
|
| + var maxLength = Math.max(from.length, to.length);
|
| + for (var i = 0; i < maxLength; i++) {
|
| + var fromPosition = from[i] ? from[i] : positionType.zero();
|
| + var toPosition = to[i] ? to[i] : positionType.zero();
|
| + out.push(positionType.interpolate(fromPosition, toPosition, f));
|
| + }
|
| + return out;
|
| + },
|
| + toCssValue: function(value) {
|
| + return value.map(positionType.toCssValue).join(', ');
|
| + },
|
| + fromCssValue: function(value) {
|
| + if (!isDefinedAndNotNull(value)) {
|
| + return undefined;
|
| + }
|
| + if (!value.trim()) {
|
| + return [positionType.fromCssValue('0% 0%')];
|
| + }
|
| + var positionValues = value.split(',');
|
| + var out = positionValues.map(positionType.fromCssValue);
|
| + return out.every(isDefinedAndNotNull) ? out : undefined;
|
| + }
|
| +};
|
| +
|
| +var rectangleRE = /rect\(([^,]+),([^,]+),([^,]+),([^)]+)\)/;
|
| +var rectangleType = {
|
| + add: function(base, delta) {
|
| + return {
|
| + top: percentLengthType.add(base.top, delta.top),
|
| + right: percentLengthType.add(base.right, delta.right),
|
| + bottom: percentLengthType.add(base.bottom, delta.bottom),
|
| + left: percentLengthType.add(base.left, delta.left)
|
| + };
|
| + },
|
| + interpolate: function(from, to, f) {
|
| + return {
|
| + top: percentLengthType.interpolate(from.top, to.top, f),
|
| + right: percentLengthType.interpolate(from.right, to.right, f),
|
| + bottom: percentLengthType.interpolate(from.bottom, to.bottom, f),
|
| + left: percentLengthType.interpolate(from.left, to.left, f)
|
| + };
|
| + },
|
| + toCssValue: function(value) {
|
| + return 'rect(' +
|
| + percentLengthType.toCssValue(value.top) + ',' +
|
| + percentLengthType.toCssValue(value.right) + ',' +
|
| + percentLengthType.toCssValue(value.bottom) + ',' +
|
| + percentLengthType.toCssValue(value.left) + ')';
|
| + },
|
| + fromCssValue: function(value) {
|
| + var match = rectangleRE.exec(value);
|
| + if (!match) {
|
| + return undefined;
|
| + }
|
| + var out = {
|
| + top: percentLengthType.fromCssValue(match[1]),
|
| + right: percentLengthType.fromCssValue(match[2]),
|
| + bottom: percentLengthType.fromCssValue(match[3]),
|
| + left: percentLengthType.fromCssValue(match[4])
|
| + };
|
| + if (out.top && out.right && out.bottom && out.left) {
|
| + return out;
|
| + }
|
| + return undefined;
|
| + }
|
| +};
|
| +
|
| +var originType = {
|
| + zero: function() { return [{'%': 0}, {'%': 0}, {px: 0}]; },
|
| + add: function(base, delta) {
|
| + return [
|
| + percentLengthType.add(base[0], delta[0]),
|
| + percentLengthType.add(base[1], delta[1]),
|
| + percentLengthType.add(base[2], delta[2])
|
| + ];
|
| + },
|
| + interpolate: function(from, to, f) {
|
| + return [
|
| + percentLengthType.interpolate(from[0], to[0], f),
|
| + percentLengthType.interpolate(from[1], to[1], f),
|
| + percentLengthType.interpolate(from[2], to[2], f)
|
| + ];
|
| + },
|
| + toCssValue: function(value) {
|
| + var result = percentLengthType.toCssValue(value[0]) + ' ' +
|
| + percentLengthType.toCssValue(value[1]);
|
| + // Return the third value if it is non-zero.
|
| + for (var unit in value[2]) {
|
| + if (value[2][unit] !== 0) {
|
| + return result + ' ' + percentLengthType.toCssValue(value[2]);
|
| + }
|
| + }
|
| + return result;
|
| + },
|
| + fromCssValue: function(value) {
|
| + var tokens = positionType.consumeAllTokensFromString(value);
|
| + if (!tokens) {
|
| + return undefined;
|
| + }
|
| + var out = ['center', 'center', {px: 0}];
|
| + switch (tokens.length) {
|
| + case 0:
|
| + return originType.zero();
|
| + case 1:
|
| + if (positionType.isHorizontalToken(tokens[0])) {
|
| + out[0] = tokens[0];
|
| + } else if (positionType.isVerticalToken(tokens[0])) {
|
| + out[1] = tokens[0];
|
| + } else {
|
| + return undefined;
|
| + }
|
| + return out.map(positionType.resolveToken);
|
| + case 3:
|
| + if (positionType.isKeyword(tokens[2])) {
|
| + return undefined;
|
| + }
|
| + out[2] = tokens[2];
|
| + case 2:
|
| + if (positionType.isHorizontalToken(tokens[0]) &&
|
| + positionType.isVerticalToken(tokens[1])) {
|
| + out[0] = tokens[0];
|
| + out[1] = tokens[1];
|
| + } else if (positionType.isVerticalToken(tokens[0]) &&
|
| + positionType.isHorizontalToken(tokens[1])) {
|
| + out[0] = tokens[1];
|
| + out[1] = tokens[0];
|
| + } else {
|
| + return undefined;
|
| + }
|
| + return out.map(positionType.resolveToken);
|
| + default:
|
| + return undefined;
|
| + }
|
| + }
|
| +};
|
| +
|
| +var shadowType = {
|
| + zero: function() {
|
| + return {
|
| + hOffset: lengthType.zero(),
|
| + vOffset: lengthType.zero()
|
| + };
|
| + },
|
| + _addSingle: function(base, delta) {
|
| + if (base && delta && base.inset !== delta.inset) {
|
| + return delta;
|
| + }
|
| + var result = {
|
| + inset: base ? base.inset : delta.inset,
|
| + hOffset: lengthType.add(
|
| + base ? base.hOffset : lengthType.zero(),
|
| + delta ? delta.hOffset : lengthType.zero()),
|
| + vOffset: lengthType.add(
|
| + base ? base.vOffset : lengthType.zero(),
|
| + delta ? delta.vOffset : lengthType.zero()),
|
| + blur: lengthType.add(
|
| + base && base.blur || lengthType.zero(),
|
| + delta && delta.blur || lengthType.zero())
|
| + };
|
| + if (base && base.spread || delta && delta.spread) {
|
| + result.spread = lengthType.add(
|
| + base && base.spread || lengthType.zero(),
|
| + delta && delta.spread || lengthType.zero());
|
| + }
|
| + if (base && base.color || delta && delta.color) {
|
| + result.color = colorType.add(
|
| + base && base.color || colorType.zero(),
|
| + delta && delta.color || colorType.zero());
|
| + }
|
| + return result;
|
| + },
|
| + add: function(base, delta) {
|
| + var result = [];
|
| + for (var i = 0; i < base.length || i < delta.length; i++) {
|
| + result.push(this._addSingle(base[i], delta[i]));
|
| + }
|
| + return result;
|
| + },
|
| + _interpolateSingle: function(from, to, f) {
|
| + if (from && to && from.inset !== to.inset) {
|
| + return f < 0.5 ? from : to;
|
| + }
|
| + var result = {
|
| + inset: from ? from.inset : to.inset,
|
| + hOffset: lengthType.interpolate(
|
| + from ? from.hOffset : lengthType.zero(),
|
| + to ? to.hOffset : lengthType.zero(), f),
|
| + vOffset: lengthType.interpolate(
|
| + from ? from.vOffset : lengthType.zero(),
|
| + to ? to.vOffset : lengthType.zero(), f),
|
| + blur: lengthType.interpolate(
|
| + from && from.blur || lengthType.zero(),
|
| + to && to.blur || lengthType.zero(), f)
|
| + };
|
| + if (from && from.spread || to && to.spread) {
|
| + result.spread = lengthType.interpolate(
|
| + from && from.spread || lengthType.zero(),
|
| + to && to.spread || lengthType.zero(), f);
|
| + }
|
| + if (from && from.color || to && to.color) {
|
| + result.color = colorType.interpolate(
|
| + from && from.color || colorType.zero(),
|
| + to && to.color || colorType.zero(), f);
|
| + }
|
| + return result;
|
| + },
|
| + interpolate: function(from, to, f) {
|
| + var result = [];
|
| + for (var i = 0; i < from.length || i < to.length; i++) {
|
| + result.push(this._interpolateSingle(from[i], to[i], f));
|
| + }
|
| + return result;
|
| + },
|
| + _toCssValueSingle: function(value) {
|
| + return (value.inset ? 'inset ' : '') +
|
| + lengthType.toCssValue(value.hOffset) + ' ' +
|
| + lengthType.toCssValue(value.vOffset) + ' ' +
|
| + lengthType.toCssValue(value.blur) +
|
| + (value.spread ? ' ' + lengthType.toCssValue(value.spread) : '') +
|
| + (value.color ? ' ' + colorType.toCssValue(value.color) : '');
|
| + },
|
| + toCssValue: function(value) {
|
| + return value.map(this._toCssValueSingle).join(', ');
|
| + },
|
| + fromCssValue: function(value) {
|
| + var shadowRE = /(([^(,]+(\([^)]*\))?)+)/g;
|
| + var match;
|
| + var shadows = [];
|
| + while ((match = shadowRE.exec(value)) !== null) {
|
| + shadows.push(match[0]);
|
| + }
|
| +
|
| + var result = shadows.map(function(value) {
|
| + if (value === 'none') {
|
| + return shadowType.zero();
|
| + }
|
| + value = value.replace(/^\s+|\s+$/g, '');
|
| +
|
| + var partsRE = /([^ (]+(\([^)]*\))?)/g;
|
| + var parts = [];
|
| + while ((match = partsRE.exec(value)) !== null) {
|
| + parts.push(match[0]);
|
| + }
|
| +
|
| + if (parts.length < 2 || parts.length > 7) {
|
| + return undefined;
|
| + }
|
| + var result = {
|
| + inset: false
|
| + };
|
| +
|
| + var lengths = [];
|
| + while (parts.length) {
|
| + var part = parts.shift();
|
| +
|
| + var length = lengthType.fromCssValue(part);
|
| + if (length) {
|
| + lengths.push(length);
|
| + continue;
|
| + }
|
| +
|
| + var color = colorType.fromCssValue(part);
|
| + if (color) {
|
| + result.color = color;
|
| + }
|
| +
|
| + if (part === 'inset') {
|
| + result.inset = true;
|
| + }
|
| + }
|
| +
|
| + if (lengths.length < 2 || lengths.length > 4) {
|
| + return undefined;
|
| + }
|
| + result.hOffset = lengths[0];
|
| + result.vOffset = lengths[1];
|
| + if (lengths.length > 2) {
|
| + result.blur = lengths[2];
|
| + }
|
| + if (lengths.length > 3) {
|
| + result.spread = lengths[3];
|
| + }
|
| + return result;
|
| + });
|
| +
|
| + return result.every(isDefined) ? result : undefined;
|
| + }
|
| +};
|
| +
|
| +var nonNumericType = {
|
| + add: function(base, delta) {
|
| + return isDefined(delta) ? delta : base;
|
| + },
|
| + interpolate: function(from, to, f) {
|
| + return f < 0.5 ? from : to;
|
| + },
|
| + toCssValue: function(value) {
|
| + return value;
|
| + },
|
| + fromCssValue: function(value) {
|
| + return value;
|
| + }
|
| +};
|
| +
|
| +var visibilityType = createObject(nonNumericType, {
|
| + interpolate: function(from, to, f) {
|
| + if (from !== 'visible' && to !== 'visible') {
|
| + return nonNumericType.interpolate(from, to, f);
|
| + }
|
| + if (f <= 0) {
|
| + return from;
|
| + }
|
| + if (f >= 1) {
|
| + return to;
|
| + }
|
| + return 'visible';
|
| + },
|
| + fromCssValue: function(value) {
|
| + if (['visible', 'hidden', 'collapse'].indexOf(value) !== -1) {
|
| + return value;
|
| + }
|
| + return undefined;
|
| + }
|
| +});
|
| +
|
| +var lengthType = percentLengthType;
|
| +var lengthAutoType = typeWithKeywords(['auto'], lengthType);
|
| +
|
| +var colorRE = new RegExp(
|
| + '(hsla?|rgba?)\\(' +
|
| + '([\\-0-9]+%?),?\\s*' +
|
| + '([\\-0-9]+%?),?\\s*' +
|
| + '([\\-0-9]+%?)(?:,?\\s*([\\-0-9\\.]+%?))?' +
|
| + '\\)');
|
| +var colorHashRE = new RegExp(
|
| + '#([0-9A-Fa-f][0-9A-Fa-f]?)' +
|
| + '([0-9A-Fa-f][0-9A-Fa-f]?)' +
|
| + '([0-9A-Fa-f][0-9A-Fa-f]?)');
|
| +
|
| +function hsl2rgb(h, s, l) {
|
| + // Cribbed from http://dev.w3.org/csswg/css-color/#hsl-color
|
| + // Wrap to 0->360 degrees (IE -10 === 350) then normalize
|
| + h = (((h % 360) + 360) % 360) / 360;
|
| + s = s / 100;
|
| + l = l / 100;
|
| + function hue2rgb(m1, m2, h) {
|
| + if (h < 0) {
|
| + h += 1;
|
| + }
|
| + if (h > 1) {
|
| + h -= 1;
|
| + }
|
| + if (h * 6 < 1) {
|
| + return m1 + (m2 - m1) * h * 6;
|
| + }
|
| + if (h * 2 < 1) {
|
| + return m2;
|
| + }
|
| + if (h * 3 < 2) {
|
| + return m1 + (m2 - m1) * (2 / 3 - h) * 6;
|
| + }
|
| + return m1;
|
| + }
|
| + var m2;
|
| + if (l <= 0.5) {
|
| + m2 = l * (s + 1);
|
| + } else {
|
| + m2 = l + s - l * s;
|
| + }
|
| +
|
| + var m1 = l * 2 - m2;
|
| + var r = Math.ceil(hue2rgb(m1, m2, h + 1 / 3) * 255);
|
| + var g = Math.ceil(hue2rgb(m1, m2, h) * 255);
|
| + var b = Math.ceil(hue2rgb(m1, m2, h - 1 / 3) * 255);
|
| + return [r, g, b];
|
| +}
|
| +
|
| +var namedColors = {
|
| + aliceblue: [240, 248, 255, 1],
|
| + antiquewhite: [250, 235, 215, 1],
|
| + aqua: [0, 255, 255, 1],
|
| + aquamarine: [127, 255, 212, 1],
|
| + azure: [240, 255, 255, 1],
|
| + beige: [245, 245, 220, 1],
|
| + bisque: [255, 228, 196, 1],
|
| + black: [0, 0, 0, 1],
|
| + blanchedalmond: [255, 235, 205, 1],
|
| + blue: [0, 0, 255, 1],
|
| + blueviolet: [138, 43, 226, 1],
|
| + brown: [165, 42, 42, 1],
|
| + burlywood: [222, 184, 135, 1],
|
| + cadetblue: [95, 158, 160, 1],
|
| + chartreuse: [127, 255, 0, 1],
|
| + chocolate: [210, 105, 30, 1],
|
| + coral: [255, 127, 80, 1],
|
| + cornflowerblue: [100, 149, 237, 1],
|
| + cornsilk: [255, 248, 220, 1],
|
| + crimson: [220, 20, 60, 1],
|
| + cyan: [0, 255, 255, 1],
|
| + darkblue: [0, 0, 139, 1],
|
| + darkcyan: [0, 139, 139, 1],
|
| + darkgoldenrod: [184, 134, 11, 1],
|
| + darkgray: [169, 169, 169, 1],
|
| + darkgreen: [0, 100, 0, 1],
|
| + darkgrey: [169, 169, 169, 1],
|
| + darkkhaki: [189, 183, 107, 1],
|
| + darkmagenta: [139, 0, 139, 1],
|
| + darkolivegreen: [85, 107, 47, 1],
|
| + darkorange: [255, 140, 0, 1],
|
| + darkorchid: [153, 50, 204, 1],
|
| + darkred: [139, 0, 0, 1],
|
| + darksalmon: [233, 150, 122, 1],
|
| + darkseagreen: [143, 188, 143, 1],
|
| + darkslateblue: [72, 61, 139, 1],
|
| + darkslategray: [47, 79, 79, 1],
|
| + darkslategrey: [47, 79, 79, 1],
|
| + darkturquoise: [0, 206, 209, 1],
|
| + darkviolet: [148, 0, 211, 1],
|
| + deeppink: [255, 20, 147, 1],
|
| + deepskyblue: [0, 191, 255, 1],
|
| + dimgray: [105, 105, 105, 1],
|
| + dimgrey: [105, 105, 105, 1],
|
| + dodgerblue: [30, 144, 255, 1],
|
| + firebrick: [178, 34, 34, 1],
|
| + floralwhite: [255, 250, 240, 1],
|
| + forestgreen: [34, 139, 34, 1],
|
| + fuchsia: [255, 0, 255, 1],
|
| + gainsboro: [220, 220, 220, 1],
|
| + ghostwhite: [248, 248, 255, 1],
|
| + gold: [255, 215, 0, 1],
|
| + goldenrod: [218, 165, 32, 1],
|
| + gray: [128, 128, 128, 1],
|
| + green: [0, 128, 0, 1],
|
| + greenyellow: [173, 255, 47, 1],
|
| + grey: [128, 128, 128, 1],
|
| + honeydew: [240, 255, 240, 1],
|
| + hotpink: [255, 105, 180, 1],
|
| + indianred: [205, 92, 92, 1],
|
| + indigo: [75, 0, 130, 1],
|
| + ivory: [255, 255, 240, 1],
|
| + khaki: [240, 230, 140, 1],
|
| + lavender: [230, 230, 250, 1],
|
| + lavenderblush: [255, 240, 245, 1],
|
| + lawngreen: [124, 252, 0, 1],
|
| + lemonchiffon: [255, 250, 205, 1],
|
| + lightblue: [173, 216, 230, 1],
|
| + lightcoral: [240, 128, 128, 1],
|
| + lightcyan: [224, 255, 255, 1],
|
| + lightgoldenrodyellow: [250, 250, 210, 1],
|
| + lightgray: [211, 211, 211, 1],
|
| + lightgreen: [144, 238, 144, 1],
|
| + lightgrey: [211, 211, 211, 1],
|
| + lightpink: [255, 182, 193, 1],
|
| + lightsalmon: [255, 160, 122, 1],
|
| + lightseagreen: [32, 178, 170, 1],
|
| + lightskyblue: [135, 206, 250, 1],
|
| + lightslategray: [119, 136, 153, 1],
|
| + lightslategrey: [119, 136, 153, 1],
|
| + lightsteelblue: [176, 196, 222, 1],
|
| + lightyellow: [255, 255, 224, 1],
|
| + lime: [0, 255, 0, 1],
|
| + limegreen: [50, 205, 50, 1],
|
| + linen: [250, 240, 230, 1],
|
| + magenta: [255, 0, 255, 1],
|
| + maroon: [128, 0, 0, 1],
|
| + mediumaquamarine: [102, 205, 170, 1],
|
| + mediumblue: [0, 0, 205, 1],
|
| + mediumorchid: [186, 85, 211, 1],
|
| + mediumpurple: [147, 112, 219, 1],
|
| + mediumseagreen: [60, 179, 113, 1],
|
| + mediumslateblue: [123, 104, 238, 1],
|
| + mediumspringgreen: [0, 250, 154, 1],
|
| + mediumturquoise: [72, 209, 204, 1],
|
| + mediumvioletred: [199, 21, 133, 1],
|
| + midnightblue: [25, 25, 112, 1],
|
| + mintcream: [245, 255, 250, 1],
|
| + mistyrose: [255, 228, 225, 1],
|
| + moccasin: [255, 228, 181, 1],
|
| + navajowhite: [255, 222, 173, 1],
|
| + navy: [0, 0, 128, 1],
|
| + oldlace: [253, 245, 230, 1],
|
| + olive: [128, 128, 0, 1],
|
| + olivedrab: [107, 142, 35, 1],
|
| + orange: [255, 165, 0, 1],
|
| + orangered: [255, 69, 0, 1],
|
| + orchid: [218, 112, 214, 1],
|
| + palegoldenrod: [238, 232, 170, 1],
|
| + palegreen: [152, 251, 152, 1],
|
| + paleturquoise: [175, 238, 238, 1],
|
| + palevioletred: [219, 112, 147, 1],
|
| + papayawhip: [255, 239, 213, 1],
|
| + peachpuff: [255, 218, 185, 1],
|
| + peru: [205, 133, 63, 1],
|
| + pink: [255, 192, 203, 1],
|
| + plum: [221, 160, 221, 1],
|
| + powderblue: [176, 224, 230, 1],
|
| + purple: [128, 0, 128, 1],
|
| + red: [255, 0, 0, 1],
|
| + rosybrown: [188, 143, 143, 1],
|
| + royalblue: [65, 105, 225, 1],
|
| + saddlebrown: [139, 69, 19, 1],
|
| + salmon: [250, 128, 114, 1],
|
| + sandybrown: [244, 164, 96, 1],
|
| + seagreen: [46, 139, 87, 1],
|
| + seashell: [255, 245, 238, 1],
|
| + sienna: [160, 82, 45, 1],
|
| + silver: [192, 192, 192, 1],
|
| + skyblue: [135, 206, 235, 1],
|
| + slateblue: [106, 90, 205, 1],
|
| + slategray: [112, 128, 144, 1],
|
| + slategrey: [112, 128, 144, 1],
|
| + snow: [255, 250, 250, 1],
|
| + springgreen: [0, 255, 127, 1],
|
| + steelblue: [70, 130, 180, 1],
|
| + tan: [210, 180, 140, 1],
|
| + teal: [0, 128, 128, 1],
|
| + thistle: [216, 191, 216, 1],
|
| + tomato: [255, 99, 71, 1],
|
| + transparent: [0, 0, 0, 0],
|
| + turquoise: [64, 224, 208, 1],
|
| + violet: [238, 130, 238, 1],
|
| + wheat: [245, 222, 179, 1],
|
| + white: [255, 255, 255, 1],
|
| + whitesmoke: [245, 245, 245, 1],
|
| + yellow: [255, 255, 0, 1],
|
| + yellowgreen: [154, 205, 50, 1]
|
| +};
|
| +
|
| +var colorType = typeWithKeywords(['currentColor'], {
|
| + zero: function() { return [0, 0, 0, 0]; },
|
| + _premultiply: function(value) {
|
| + var alpha = value[3];
|
| + return [value[0] * alpha, value[1] * alpha, value[2] * alpha];
|
| + },
|
| + add: function(base, delta) {
|
| + var alpha = Math.min(base[3] + delta[3], 1);
|
| + if (alpha === 0) {
|
| + return [0, 0, 0, 0];
|
| + }
|
| + base = this._premultiply(base);
|
| + delta = this._premultiply(delta);
|
| + return [(base[0] + delta[0]) / alpha, (base[1] + delta[1]) / alpha,
|
| + (base[2] + delta[2]) / alpha, alpha];
|
| + },
|
| + interpolate: function(from, to, f) {
|
| + var alpha = clamp(interp(from[3], to[3], f), 0, 1);
|
| + if (alpha === 0) {
|
| + return [0, 0, 0, 0];
|
| + }
|
| + from = this._premultiply(from);
|
| + to = this._premultiply(to);
|
| + return [interp(from[0], to[0], f) / alpha,
|
| + interp(from[1], to[1], f) / alpha,
|
| + interp(from[2], to[2], f) / alpha, alpha];
|
| + },
|
| + toCssValue: function(value) {
|
| + return 'rgba(' + Math.round(value[0]) + ', ' + Math.round(value[1]) +
|
| + ', ' + Math.round(value[2]) + ', ' + value[3] + ')';
|
| + },
|
| + fromCssValue: function(value) {
|
| + // http://dev.w3.org/csswg/css-color/#color
|
| + var out = [];
|
| +
|
| + var regexResult = colorHashRE.exec(value);
|
| + if (regexResult) {
|
| + if (value.length !== 4 && value.length !== 7) {
|
| + return undefined;
|
| + }
|
| +
|
| + var out = [];
|
| + regexResult.shift();
|
| + for (var i = 0; i < 3; i++) {
|
| + if (regexResult[i].length === 1) {
|
| + regexResult[i] = regexResult[i] + regexResult[i];
|
| + }
|
| + var v = Math.max(Math.min(parseInt(regexResult[i], 16), 255), 0);
|
| + out[i] = v;
|
| + }
|
| + out.push(1.0);
|
| + }
|
| +
|
| + var regexResult = colorRE.exec(value);
|
| + if (regexResult) {
|
| + regexResult.shift();
|
| + var type = regexResult.shift().substr(0, 3);
|
| + for (var i = 0; i < 3; i++) {
|
| + var m = 1;
|
| + if (regexResult[i][regexResult[i].length - 1] === '%') {
|
| + regexResult[i] = regexResult[i].substr(0, regexResult[i].length - 1);
|
| + m = 255.0 / 100.0;
|
| + }
|
| + if (type === 'rgb') {
|
| + out[i] = clamp(Math.round(parseInt(regexResult[i], 10) * m), 0, 255);
|
| + } else {
|
| + out[i] = parseInt(regexResult[i], 10);
|
| + }
|
| + }
|
| +
|
| + // Convert hsl values to rgb value
|
| + if (type === 'hsl') {
|
| + out = hsl2rgb.apply(null, out);
|
| + }
|
| +
|
| + if (typeof regexResult[3] !== 'undefined') {
|
| + out[3] = Math.max(Math.min(parseFloat(regexResult[3]), 1.0), 0.0);
|
| + } else {
|
| + out.push(1.0);
|
| + }
|
| + }
|
| +
|
| + if (out.some(isNaN)) {
|
| + return undefined;
|
| + }
|
| + if (out.length > 0) {
|
| + return out;
|
| + }
|
| + return namedColors[value];
|
| + }
|
| +});
|
| +
|
| +var convertToDeg = function(num, type) {
|
| + switch (type) {
|
| + case 'grad':
|
| + return num / 400 * 360;
|
| + case 'rad':
|
| + return num / 2 / Math.PI * 360;
|
| + case 'turn':
|
| + return num * 360;
|
| + default:
|
| + return num;
|
| + }
|
| +};
|
| +
|
| +var extractValue = function(values, pos, hasUnits) {
|
| + var value = Number(values[pos]);
|
| + if (!hasUnits) {
|
| + return value;
|
| + }
|
| + var type = values[pos + 1];
|
| + if (type === '') { type = 'px'; }
|
| + var result = {};
|
| + result[type] = value;
|
| + return result;
|
| +};
|
| +
|
| +var extractValues = function(values, numValues, hasOptionalValue,
|
| + hasUnits) {
|
| + var result = [];
|
| + for (var i = 0; i < numValues; i++) {
|
| + result.push(extractValue(values, 1 + 2 * i, hasUnits));
|
| + }
|
| + if (hasOptionalValue && values[1 + 2 * numValues]) {
|
| + result.push(extractValue(values, 1 + 2 * numValues, hasUnits));
|
| + }
|
| + return result;
|
| +};
|
| +
|
| +var SPACES = '\\s*';
|
| +var NUMBER = '[+-]?(?:\\d+|\\d*\\.\\d+)';
|
| +var RAW_OPEN_BRACKET = '\\(';
|
| +var RAW_CLOSE_BRACKET = '\\)';
|
| +var RAW_COMMA = ',';
|
| +var UNIT = '[a-zA-Z%]*';
|
| +var START = '^';
|
| +
|
| +function capture(x) { return '(' + x + ')'; }
|
| +function optional(x) { return '(?:' + x + ')?'; }
|
| +
|
| +var OPEN_BRACKET = [SPACES, RAW_OPEN_BRACKET, SPACES].join('');
|
| +var CLOSE_BRACKET = [SPACES, RAW_CLOSE_BRACKET, SPACES].join('');
|
| +var COMMA = [SPACES, RAW_COMMA, SPACES].join('');
|
| +var UNIT_NUMBER = [capture(NUMBER), capture(UNIT)].join('');
|
| +
|
| +function transformRE(name, numParms, hasOptionalParm) {
|
| + var tokenList = [START, SPACES, name, OPEN_BRACKET];
|
| + for (var i = 0; i < numParms - 1; i++) {
|
| + tokenList.push(UNIT_NUMBER);
|
| + tokenList.push(COMMA);
|
| + }
|
| + tokenList.push(UNIT_NUMBER);
|
| + if (hasOptionalParm) {
|
| + tokenList.push(optional([COMMA, UNIT_NUMBER].join('')));
|
| + }
|
| + tokenList.push(CLOSE_BRACKET);
|
| + return new RegExp(tokenList.join(''));
|
| +}
|
| +
|
| +function buildMatcher(name, numValues, hasOptionalValue, hasUnits,
|
| + baseValue) {
|
| + var baseName = name;
|
| + if (baseValue) {
|
| + if (name[name.length - 1] === 'X' || name[name.length - 1] === 'Y') {
|
| + baseName = name.substring(0, name.length - 1);
|
| + } else if (name[name.length - 1] === 'Z') {
|
| + baseName = name.substring(0, name.length - 1) + '3d';
|
| + }
|
| + }
|
| +
|
| + var f = function(x) {
|
| + var r = extractValues(x, numValues, hasOptionalValue, hasUnits);
|
| + if (baseValue !== undefined) {
|
| + if (name[name.length - 1] === 'X') {
|
| + r.push(baseValue);
|
| + } else if (name[name.length - 1] === 'Y') {
|
| + r = [baseValue].concat(r);
|
| + } else if (name[name.length - 1] === 'Z') {
|
| + r = [baseValue, baseValue].concat(r);
|
| + } else if (hasOptionalValue) {
|
| + while (r.length < 2) {
|
| + if (baseValue === 'copy') {
|
| + r.push(r[0]);
|
| + } else {
|
| + r.push(baseValue);
|
| + }
|
| + }
|
| + }
|
| + }
|
| + return r;
|
| + };
|
| + return [transformRE(name, numValues, hasOptionalValue), f, baseName];
|
| +}
|
| +
|
| +function buildRotationMatcher(name, numValues, hasOptionalValue,
|
| + baseValue) {
|
| + var m = buildMatcher(name, numValues, hasOptionalValue, true, baseValue);
|
| +
|
| + var f = function(x) {
|
| + var r = m[1](x);
|
| + return r.map(function(v) {
|
| + var result = 0;
|
| + for (var type in v) {
|
| + result += convertToDeg(v[type], type);
|
| + }
|
| + return result;
|
| + });
|
| + };
|
| + return [m[0], f, m[2]];
|
| +}
|
| +
|
| +function build3DRotationMatcher() {
|
| + var m = buildMatcher('rotate3d', 4, false, true);
|
| + var f = function(x) {
|
| + var r = m[1](x);
|
| + var out = [];
|
| + for (var i = 0; i < 3; i++) {
|
| + out.push(r[i].px);
|
| + }
|
| + var angle = 0;
|
| + for (var unit in r[3]) {
|
| + angle += convertToDeg(r[3][unit], unit);
|
| + }
|
| + out.push(angle);
|
| + return out;
|
| + };
|
| + return [m[0], f, m[2]];
|
| +}
|
| +
|
| +var transformREs = [
|
| + buildRotationMatcher('rotate', 1, false),
|
| + buildRotationMatcher('rotateX', 1, false),
|
| + buildRotationMatcher('rotateY', 1, false),
|
| + buildRotationMatcher('rotateZ', 1, false),
|
| + build3DRotationMatcher(),
|
| + buildRotationMatcher('skew', 1, true, 0),
|
| + buildRotationMatcher('skewX', 1, false),
|
| + buildRotationMatcher('skewY', 1, false),
|
| + buildMatcher('translateX', 1, false, true, {px: 0}),
|
| + buildMatcher('translateY', 1, false, true, {px: 0}),
|
| + buildMatcher('translateZ', 1, false, true, {px: 0}),
|
| + buildMatcher('translate', 1, true, true, {px: 0}),
|
| + buildMatcher('translate3d', 3, false, true),
|
| + buildMatcher('scale', 1, true, false, 'copy'),
|
| + buildMatcher('scaleX', 1, false, false, 1),
|
| + buildMatcher('scaleY', 1, false, false, 1),
|
| + buildMatcher('scaleZ', 1, false, false, 1),
|
| + buildMatcher('scale3d', 3, false, false),
|
| + buildMatcher('perspective', 1, false, true),
|
| + buildMatcher('matrix', 6, false, false),
|
| + buildMatcher('matrix3d', 16, false, false)
|
| +];
|
| +
|
| +var decomposeMatrix = (function() {
|
| + // this is only ever used on the perspective matrix, which has 0, 0, 0, 1 as
|
| + // last column
|
| + function determinant(m) {
|
| + return m[0][0] * m[1][1] * m[2][2] +
|
| + m[1][0] * m[2][1] * m[0][2] +
|
| + m[2][0] * m[0][1] * m[1][2] -
|
| + m[0][2] * m[1][1] * m[2][0] -
|
| + m[1][2] * m[2][1] * m[0][0] -
|
| + m[2][2] * m[0][1] * m[1][0];
|
| + }
|
| +
|
| + // from Wikipedia:
|
| + //
|
| + // [A B]^-1 = [A^-1 + A^-1B(D - CA^-1B)^-1CA^-1 -A^-1B(D - CA^-1B)^-1]
|
| + // [C D] [-(D - CA^-1B)^-1CA^-1 (D - CA^-1B)^-1 ]
|
| + //
|
| + // Therefore
|
| + //
|
| + // [A [0]]^-1 = [A^-1 [0]]
|
| + // [C 1 ] [ -CA^-1 1 ]
|
| + function inverse(m) {
|
| + var iDet = 1 / determinant(m);
|
| + var a = m[0][0], b = m[0][1], c = m[0][2];
|
| + var d = m[1][0], e = m[1][1], f = m[1][2];
|
| + var g = m[2][0], h = m[2][1], k = m[2][2];
|
| + var Ainv = [
|
| + [(e * k - f * h) * iDet, (c * h - b * k) * iDet,
|
| + (b * f - c * e) * iDet, 0],
|
| + [(f * g - d * k) * iDet, (a * k - c * g) * iDet,
|
| + (c * d - a * f) * iDet, 0],
|
| + [(d * h - e * g) * iDet, (g * b - a * h) * iDet,
|
| + (a * e - b * d) * iDet, 0]
|
| + ];
|
| + var lastRow = [];
|
| + for (var i = 0; i < 3; i++) {
|
| + var val = 0;
|
| + for (var j = 0; j < 3; j++) {
|
| + val += m[3][j] * Ainv[j][i];
|
| + }
|
| + lastRow.push(val);
|
| + }
|
| + lastRow.push(1);
|
| + Ainv.push(lastRow);
|
| + return Ainv;
|
| + }
|
| +
|
| + function transposeMatrix4(m) {
|
| + return [[m[0][0], m[1][0], m[2][0], m[3][0]],
|
| + [m[0][1], m[1][1], m[2][1], m[3][1]],
|
| + [m[0][2], m[1][2], m[2][2], m[3][2]],
|
| + [m[0][3], m[1][3], m[2][3], m[3][3]]];
|
| + }
|
| +
|
| + function multVecMatrix(v, m) {
|
| + var result = [];
|
| + for (var i = 0; i < 4; i++) {
|
| + var val = 0;
|
| + for (var j = 0; j < 4; j++) {
|
| + val += v[j] * m[j][i];
|
| + }
|
| + result.push(val);
|
| + }
|
| + return result;
|
| + }
|
| +
|
| + function normalize(v) {
|
| + var len = length(v);
|
| + return [v[0] / len, v[1] / len, v[2] / len];
|
| + }
|
| +
|
| + function length(v) {
|
| + return Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
|
| + }
|
| +
|
| + function combine(v1, v2, v1s, v2s) {
|
| + return [v1s * v1[0] + v2s * v2[0], v1s * v1[1] + v2s * v2[1],
|
| + v1s * v1[2] + v2s * v2[2]];
|
| + }
|
| +
|
| + function cross(v1, v2) {
|
| + return [v1[1] * v2[2] - v1[2] * v2[1],
|
| + v1[2] * v2[0] - v1[0] * v2[2],
|
| + v1[0] * v2[1] - v1[1] * v2[0]];
|
| + }
|
| +
|
| + // TODO: Implement 2D matrix decomposition.
|
| + // http://dev.w3.org/csswg/css-transforms/#decomposing-a-2d-matrix
|
| + function decomposeMatrix(matrix) {
|
| + var m3d = [
|
| + matrix.slice(0, 4),
|
| + matrix.slice(4, 8),
|
| + matrix.slice(8, 12),
|
| + matrix.slice(12, 16)
|
| + ];
|
| +
|
| + // skip normalization step as m3d[3][3] should always be 1
|
| + if (m3d[3][3] !== 1) {
|
| + throw 'attempt to decompose non-normalized matrix';
|
| + }
|
| +
|
| + var perspectiveMatrix = m3d.concat(); // copy m3d
|
| + for (var i = 0; i < 3; i++) {
|
| + perspectiveMatrix[i][3] = 0;
|
| + }
|
| +
|
| + if (determinant(perspectiveMatrix) === 0) {
|
| + return false;
|
| + }
|
| +
|
| + var rhs = [];
|
| +
|
| + var perspective;
|
| + if (m3d[0][3] !== 0 || m3d[1][3] !== 0 || m3d[2][3] !== 0) {
|
| + rhs.push(m3d[0][3]);
|
| + rhs.push(m3d[1][3]);
|
| + rhs.push(m3d[2][3]);
|
| + rhs.push(m3d[3][3]);
|
| +
|
| + var inversePerspectiveMatrix = inverse(perspectiveMatrix);
|
| + var transposedInversePerspectiveMatrix =
|
| + transposeMatrix4(inversePerspectiveMatrix);
|
| + perspective = multVecMatrix(rhs, transposedInversePerspectiveMatrix);
|
| + } else {
|
| + perspective = [0, 0, 0, 1];
|
| + }
|
| +
|
| + var translate = m3d[3].slice(0, 3);
|
| +
|
| + var row = [];
|
| + row.push(m3d[0].slice(0, 3));
|
| + var scale = [];
|
| + scale.push(length(row[0]));
|
| + row[0] = normalize(row[0]);
|
| +
|
| + var skew = [];
|
| + row.push(m3d[1].slice(0, 3));
|
| + skew.push(dot(row[0], row[1]));
|
| + row[1] = combine(row[1], row[0], 1.0, -skew[0]);
|
| +
|
| + scale.push(length(row[1]));
|
| + row[1] = normalize(row[1]);
|
| + skew[0] /= scale[1];
|
| +
|
| + row.push(m3d[2].slice(0, 3));
|
| + skew.push(dot(row[0], row[2]));
|
| + row[2] = combine(row[2], row[0], 1.0, -skew[1]);
|
| + skew.push(dot(row[1], row[2]));
|
| + row[2] = combine(row[2], row[1], 1.0, -skew[2]);
|
| +
|
| + scale.push(length(row[2]));
|
| + row[2] = normalize(row[2]);
|
| + skew[1] /= scale[2];
|
| + skew[2] /= scale[2];
|
| +
|
| + var pdum3 = cross(row[1], row[2]);
|
| + if (dot(row[0], pdum3) < 0) {
|
| + for (var i = 0; i < 3; i++) {
|
| + scale[i] *= -1;
|
| + row[i][0] *= -1;
|
| + row[i][1] *= -1;
|
| + row[i][2] *= -1;
|
| + }
|
| + }
|
| +
|
| + var t = row[0][0] + row[1][1] + row[2][2] + 1;
|
| + var s;
|
| + var quaternion;
|
| +
|
| + if (t > 1e-4) {
|
| + s = 0.5 / Math.sqrt(t);
|
| + quaternion = [
|
| + (row[2][1] - row[1][2]) * s,
|
| + (row[0][2] - row[2][0]) * s,
|
| + (row[1][0] - row[0][1]) * s,
|
| + 0.25 / s
|
| + ];
|
| + } else if (row[0][0] > row[1][1] && row[0][0] > row[2][2]) {
|
| + s = Math.sqrt(1 + row[0][0] - row[1][1] - row[2][2]) * 2.0;
|
| + quaternion = [
|
| + 0.25 * s,
|
| + (row[0][1] + row[1][0]) / s,
|
| + (row[0][2] + row[2][0]) / s,
|
| + (row[2][1] - row[1][2]) / s
|
| + ];
|
| + } else if (row[1][1] > row[2][2]) {
|
| + s = Math.sqrt(1.0 + row[1][1] - row[0][0] - row[2][2]) * 2.0;
|
| + quaternion = [
|
| + (row[0][1] + row[1][0]) / s,
|
| + 0.25 * s,
|
| + (row[1][2] + row[2][1]) / s,
|
| + (row[0][2] - row[2][0]) / s
|
| + ];
|
| + } else {
|
| + s = Math.sqrt(1.0 + row[2][2] - row[0][0] - row[1][1]) * 2.0;
|
| + quaternion = [
|
| + (row[0][2] + row[2][0]) / s,
|
| + (row[1][2] + row[2][1]) / s,
|
| + 0.25 * s,
|
| + (row[1][0] - row[0][1]) / s
|
| + ];
|
| + }
|
| +
|
| + return {
|
| + translate: translate, scale: scale, skew: skew,
|
| + quaternion: quaternion, perspective: perspective
|
| + };
|
| + }
|
| + return decomposeMatrix;
|
| +})();
|
| +
|
| +function dot(v1, v2) {
|
| + var result = 0;
|
| + for (var i = 0; i < v1.length; i++) {
|
| + result += v1[i] * v2[i];
|
| + }
|
| + return result;
|
| +}
|
| +
|
| +function multiplyMatrices(a, b) {
|
| + return [
|
| + a[0] * b[0] + a[4] * b[1] + a[8] * b[2] + a[12] * b[3],
|
| + a[1] * b[0] + a[5] * b[1] + a[9] * b[2] + a[13] * b[3],
|
| + a[2] * b[0] + a[6] * b[1] + a[10] * b[2] + a[14] * b[3],
|
| + a[3] * b[0] + a[7] * b[1] + a[11] * b[2] + a[15] * b[3],
|
| +
|
| + a[0] * b[4] + a[4] * b[5] + a[8] * b[6] + a[12] * b[7],
|
| + a[1] * b[4] + a[5] * b[5] + a[9] * b[6] + a[13] * b[7],
|
| + a[2] * b[4] + a[6] * b[5] + a[10] * b[6] + a[14] * b[7],
|
| + a[3] * b[4] + a[7] * b[5] + a[11] * b[6] + a[15] * b[7],
|
| +
|
| + a[0] * b[8] + a[4] * b[9] + a[8] * b[10] + a[12] * b[11],
|
| + a[1] * b[8] + a[5] * b[9] + a[9] * b[10] + a[13] * b[11],
|
| + a[2] * b[8] + a[6] * b[9] + a[10] * b[10] + a[14] * b[11],
|
| + a[3] * b[8] + a[7] * b[9] + a[11] * b[10] + a[15] * b[11],
|
| +
|
| + a[0] * b[12] + a[4] * b[13] + a[8] * b[14] + a[12] * b[15],
|
| + a[1] * b[12] + a[5] * b[13] + a[9] * b[14] + a[13] * b[15],
|
| + a[2] * b[12] + a[6] * b[13] + a[10] * b[14] + a[14] * b[15],
|
| + a[3] * b[12] + a[7] * b[13] + a[11] * b[14] + a[15] * b[15]
|
| + ];
|
| +}
|
| +
|
| +function convertItemToMatrix(item) {
|
| + switch (item.t) {
|
| + case 'rotateX':
|
| + var angle = item.d * Math.PI / 180;
|
| + return [1, 0, 0, 0,
|
| + 0, Math.cos(angle), Math.sin(angle), 0,
|
| + 0, -Math.sin(angle), Math.cos(angle), 0,
|
| + 0, 0, 0, 1];
|
| + case 'rotateY':
|
| + var angle = item.d * Math.PI / 180;
|
| + return [Math.cos(angle), 0, -Math.sin(angle), 0,
|
| + 0, 1, 0, 0,
|
| + Math.sin(angle), 0, Math.cos(angle), 0,
|
| + 0, 0, 0, 1];
|
| + case 'rotate':
|
| + case 'rotateZ':
|
| + var angle = item.d * Math.PI / 180;
|
| + return [Math.cos(angle), Math.sin(angle), 0, 0,
|
| + -Math.sin(angle), Math.cos(angle), 0, 0,
|
| + 0, 0, 1, 0,
|
| + 0, 0, 0, 1];
|
| + case 'rotate3d':
|
| + var x = item.d[0];
|
| + var y = item.d[1];
|
| + var z = item.d[2];
|
| + var sqrLength = x * x + y * y + z * z;
|
| + if (sqrLength === 0) {
|
| + x = 1;
|
| + y = 0;
|
| + z = 0;
|
| + } else if (sqrLength !== 1) {
|
| + var length = Math.sqrt(sqrLength);
|
| + x /= length;
|
| + y /= length;
|
| + z /= length;
|
| + }
|
| + var s = Math.sin(item.d[3] * Math.PI / 360);
|
| + var sc = s * Math.cos(item.d[3] * Math.PI / 360);
|
| + var sq = s * s;
|
| + return [
|
| + 1 - 2 * (y * y + z * z) * sq,
|
| + 2 * (x * y * sq + z * sc),
|
| + 2 * (x * z * sq - y * sc),
|
| + 0,
|
| +
|
| + 2 * (x * y * sq - z * sc),
|
| + 1 - 2 * (x * x + z * z) * sq,
|
| + 2 * (y * z * sq + x * sc),
|
| + 0,
|
| +
|
| + 2 * (x * z * sq + y * sc),
|
| + 2 * (y * z * sq - x * sc),
|
| + 1 - 2 * (x * x + y * y) * sq,
|
| + 0,
|
| +
|
| + 0, 0, 0, 1
|
| + ];
|
| + case 'scale':
|
| + return [item.d[0], 0, 0, 0,
|
| + 0, item.d[1], 0, 0,
|
| + 0, 0, 1, 0,
|
| + 0, 0, 0, 1];
|
| + case 'scale3d':
|
| + return [item.d[0], 0, 0, 0,
|
| + 0, item.d[1], 0, 0,
|
| + 0, 0, item.d[2], 0,
|
| + 0, 0, 0, 1];
|
| + case 'skew':
|
| + return [1, Math.tan(item.d[1] * Math.PI / 180), 0, 0,
|
| + Math.tan(item.d[0] * Math.PI / 180), 1, 0, 0,
|
| + 0, 0, 1, 0,
|
| + 0, 0, 0, 1];
|
| + case 'skewX':
|
| + return [1, 0, 0, 0,
|
| + Math.tan(item.d * Math.PI / 180), 1, 0, 0,
|
| + 0, 0, 1, 0,
|
| + 0, 0, 0, 1];
|
| + case 'skewY':
|
| + return [1, Math.tan(item.d * Math.PI / 180), 0, 0,
|
| + 0, 1, 0, 0,
|
| + 0, 0, 1, 0,
|
| + 0, 0, 0, 1];
|
| + // TODO: Work out what to do with non-px values.
|
| + case 'translate':
|
| + return [1, 0, 0, 0,
|
| + 0, 1, 0, 0,
|
| + 0, 0, 1, 0,
|
| + item.d[0].px, item.d[1].px, 0, 1];
|
| + case 'translate3d':
|
| + return [1, 0, 0, 0,
|
| + 0, 1, 0, 0,
|
| + 0, 0, 1, 0,
|
| + item.d[0].px, item.d[1].px, item.d[2].px, 1];
|
| + case 'perspective':
|
| + return [
|
| + 1, 0, 0, 0,
|
| + 0, 1, 0, 0,
|
| + 0, 0, 1, -1 / item.d.px,
|
| + 0, 0, 0, 1];
|
| + case 'matrix':
|
| + return [item.d[0], item.d[1], 0, 0,
|
| + item.d[2], item.d[3], 0, 0,
|
| + 0, 0, 1, 0,
|
| + item.d[4], item.d[5], 0, 1];
|
| + case 'matrix3d':
|
| + return item.d;
|
| + default:
|
| + ASSERT_ENABLED && assert(false, 'Transform item type ' + item.t +
|
| + ' conversion to matrix not yet implemented.');
|
| + }
|
| +}
|
| +
|
| +function convertToMatrix(transformList) {
|
| + if (transformList.length === 0) {
|
| + return [1, 0, 0, 0,
|
| + 0, 1, 0, 0,
|
| + 0, 0, 1, 0,
|
| + 0, 0, 0, 1];
|
| + }
|
| + return transformList.map(convertItemToMatrix).reduce(multiplyMatrices);
|
| +}
|
| +
|
| +var composeMatrix = (function() {
|
| + function multiply(a, b) {
|
| + var result = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]];
|
| + for (var i = 0; i < 4; i++) {
|
| + for (var j = 0; j < 4; j++) {
|
| + for (var k = 0; k < 4; k++) {
|
| + result[i][j] += b[i][k] * a[k][j];
|
| + }
|
| + }
|
| + }
|
| + return result;
|
| + }
|
| +
|
| + function is2D(m) {
|
| + return (
|
| + m[0][2] == 0 &&
|
| + m[0][3] == 0 &&
|
| + m[1][2] == 0 &&
|
| + m[1][3] == 0 &&
|
| + m[2][0] == 0 &&
|
| + m[2][1] == 0 &&
|
| + m[2][2] == 1 &&
|
| + m[2][3] == 0 &&
|
| + m[3][2] == 0 &&
|
| + m[3][3] == 1);
|
| + }
|
| +
|
| + function composeMatrix(translate, scale, skew, quat, perspective) {
|
| + var matrix = [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]];
|
| +
|
| + for (var i = 0; i < 4; i++) {
|
| + matrix[i][3] = perspective[i];
|
| + }
|
| +
|
| + for (var i = 0; i < 3; i++) {
|
| + for (var j = 0; j < 3; j++) {
|
| + matrix[3][i] += translate[j] * matrix[j][i];
|
| + }
|
| + }
|
| +
|
| + var x = quat[0], y = quat[1], z = quat[2], w = quat[3];
|
| +
|
| + var rotMatrix = [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]];
|
| +
|
| + rotMatrix[0][0] = 1 - 2 * (y * y + z * z);
|
| + rotMatrix[0][1] = 2 * (x * y - z * w);
|
| + rotMatrix[0][2] = 2 * (x * z + y * w);
|
| + rotMatrix[1][0] = 2 * (x * y + z * w);
|
| + rotMatrix[1][1] = 1 - 2 * (x * x + z * z);
|
| + rotMatrix[1][2] = 2 * (y * z - x * w);
|
| + rotMatrix[2][0] = 2 * (x * z - y * w);
|
| + rotMatrix[2][1] = 2 * (y * z + x * w);
|
| + rotMatrix[2][2] = 1 - 2 * (x * x + y * y);
|
| +
|
| + matrix = multiply(matrix, rotMatrix);
|
| +
|
| + var temp = [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]];
|
| + if (skew[2]) {
|
| + temp[2][1] = skew[2];
|
| + matrix = multiply(matrix, temp);
|
| + }
|
| +
|
| + if (skew[1]) {
|
| + temp[2][1] = 0;
|
| + temp[2][0] = skew[0];
|
| + matrix = multiply(matrix, temp);
|
| + }
|
| +
|
| + if (skew[0]) {
|
| + temp[2][0] = 0;
|
| + temp[1][0] = skew[0];
|
| + matrix = multiply(matrix, temp);
|
| + }
|
| +
|
| + for (var i = 0; i < 3; i++) {
|
| + for (var j = 0; j < 3; j++) {
|
| + matrix[i][j] *= scale[i];
|
| + }
|
| + }
|
| +
|
| + if (is2D(matrix)) {
|
| + return {
|
| + t: 'matrix',
|
| + d: [matrix[0][0], matrix[0][1], matrix[1][0], matrix[1][1],
|
| + matrix[3][0], matrix[3][1]]
|
| + };
|
| + }
|
| + return {
|
| + t: 'matrix3d',
|
| + d: matrix[0].concat(matrix[1], matrix[2], matrix[3])
|
| + };
|
| + }
|
| + return composeMatrix;
|
| +})();
|
| +
|
| +function interpolateDecomposedTransformsWithMatrices(fromM, toM, f) {
|
| + var product = dot(fromM.quaternion, toM.quaternion);
|
| + product = clamp(product, -1.0, 1.0);
|
| +
|
| + var quat = [];
|
| + if (product === 1.0) {
|
| + quat = fromM.quaternion;
|
| + } else {
|
| + var theta = Math.acos(product);
|
| + var w = Math.sin(f * theta) * 1 / Math.sqrt(1 - product * product);
|
| +
|
| + for (var i = 0; i < 4; i++) {
|
| + quat.push(fromM.quaternion[i] * (Math.cos(f * theta) - product * w) +
|
| + toM.quaternion[i] * w);
|
| + }
|
| + }
|
| +
|
| + var translate = interp(fromM.translate, toM.translate, f);
|
| + var scale = interp(fromM.scale, toM.scale, f);
|
| + var skew = interp(fromM.skew, toM.skew, f);
|
| + var perspective = interp(fromM.perspective, toM.perspective, f);
|
| +
|
| + return composeMatrix(translate, scale, skew, quat, perspective);
|
| +}
|
| +
|
| +function interpTransformValue(from, to, f) {
|
| + var type = from.t ? from.t : to.t;
|
| + switch (type) {
|
| + case 'matrix':
|
| + case 'matrix3d':
|
| + ASSERT_ENABLED && assert(false,
|
| + 'Must use matrix decomposition when interpolating raw matrices');
|
| + // Transforms with unitless parameters.
|
| + case 'rotate':
|
| + case 'rotateX':
|
| + case 'rotateY':
|
| + case 'rotateZ':
|
| + case 'rotate3d':
|
| + case 'scale':
|
| + case 'scaleX':
|
| + case 'scaleY':
|
| + case 'scaleZ':
|
| + case 'scale3d':
|
| + case 'skew':
|
| + case 'skewX':
|
| + case 'skewY':
|
| + return {t: type, d: interp(from.d, to.d, f, type)};
|
| + default:
|
| + // Transforms with lengthType parameters.
|
| + var result = [];
|
| + var maxVal;
|
| + if (from.d && to.d) {
|
| + maxVal = Math.max(from.d.length, to.d.length);
|
| + } else if (from.d) {
|
| + maxVal = from.d.length;
|
| + } else {
|
| + maxVal = to.d.length;
|
| + }
|
| + for (var j = 0; j < maxVal; j++) {
|
| + var fromVal = from.d ? from.d[j] : {};
|
| + var toVal = to.d ? to.d[j] : {};
|
| + result.push(lengthType.interpolate(fromVal, toVal, f));
|
| + }
|
| + return {t: type, d: result};
|
| + }
|
| +}
|
| +
|
| +function isMatrix(item) {
|
| + return item.t[0] === 'm';
|
| +}
|
| +
|
| +// The CSSWG decided to disallow scientific notation in CSS property strings
|
| +// (see http://lists.w3.org/Archives/Public/www-style/2010Feb/0050.html).
|
| +// We need this function to hakonitize all numbers before adding them to
|
| +// property strings.
|
| +// TODO: Apply this function to all property strings
|
| +function n(num) {
|
| + return Number(num).toFixed(4);
|
| +}
|
| +
|
| +var transformType = {
|
| + add: function(base, delta) { return base.concat(delta); },
|
| + interpolate: function(from, to, f) {
|
| + var out = [];
|
| + for (var i = 0; i < Math.min(from.length, to.length); i++) {
|
| + if (from[i].t !== to[i].t || isMatrix(from[i])) {
|
| + break;
|
| + }
|
| + out.push(interpTransformValue(from[i], to[i], f));
|
| + }
|
| +
|
| + if (i < Math.min(from.length, to.length) ||
|
| + from.some(isMatrix) || to.some(isMatrix)) {
|
| + if (from.decompositionPair !== to) {
|
| + from.decompositionPair = to;
|
| + from.decomposition = decomposeMatrix(convertToMatrix(from.slice(i)));
|
| + }
|
| + if (to.decompositionPair !== from) {
|
| + to.decompositionPair = from;
|
| + to.decomposition = decomposeMatrix(convertToMatrix(to.slice(i)));
|
| + }
|
| + out.push(interpolateDecomposedTransformsWithMatrices(
|
| + from.decomposition, to.decomposition, f));
|
| + return out;
|
| + }
|
| +
|
| + for (; i < from.length; i++) {
|
| + out.push(interpTransformValue(from[i], {t: null, d: null}, f));
|
| + }
|
| + for (; i < to.length; i++) {
|
| + out.push(interpTransformValue({t: null, d: null}, to[i], f));
|
| + }
|
| + return out;
|
| + },
|
| + toCssValue: function(value, svgMode) {
|
| + // TODO: fix this :)
|
| + var out = '';
|
| + for (var i = 0; i < value.length; i++) {
|
| + ASSERT_ENABLED && assert(
|
| + value[i].t, 'transform type should be resolved by now');
|
| + switch (value[i].t) {
|
| + case 'rotate':
|
| + case 'rotateX':
|
| + case 'rotateY':
|
| + case 'rotateZ':
|
| + case 'skewX':
|
| + case 'skewY':
|
| + var unit = svgMode ? '' : 'deg';
|
| + out += value[i].t + '(' + value[i].d + unit + ') ';
|
| + break;
|
| + case 'skew':
|
| + var unit = svgMode ? '' : 'deg';
|
| + out += value[i].t + '(' + value[i].d[0] + unit;
|
| + if (value[i].d[1] === 0) {
|
| + out += ') ';
|
| + } else {
|
| + out += ', ' + value[i].d[1] + unit + ') ';
|
| + }
|
| + break;
|
| + case 'rotate3d':
|
| + var unit = svgMode ? '' : 'deg';
|
| + out += value[i].t + '(' + value[i].d[0] + ', ' + value[i].d[1] +
|
| + ', ' + value[i].d[2] + ', ' + value[i].d[3] + unit + ') ';
|
| + break;
|
| + case 'translateX':
|
| + case 'translateY':
|
| + case 'translateZ':
|
| + case 'perspective':
|
| + out += value[i].t + '(' + lengthType.toCssValue(value[i].d[0]) +
|
| + ') ';
|
| + break;
|
| + case 'translate':
|
| + if (svgMode) {
|
| + if (value[i].d[1] === undefined) {
|
| + out += value[i].t + '(' + value[i].d[0].px + ') ';
|
| + } else {
|
| + out += (
|
| + value[i].t + '(' + value[i].d[0].px + ', ' +
|
| + value[i].d[1].px + ') ');
|
| + }
|
| + break;
|
| + }
|
| + if (value[i].d[1] === undefined) {
|
| + out += value[i].t + '(' + lengthType.toCssValue(value[i].d[0]) +
|
| + ') ';
|
| + } else {
|
| + out += value[i].t + '(' + lengthType.toCssValue(value[i].d[0]) +
|
| + ', ' + lengthType.toCssValue(value[i].d[1]) + ') ';
|
| + }
|
| + break;
|
| + case 'translate3d':
|
| + var values = value[i].d.map(lengthType.toCssValue);
|
| + out += value[i].t + '(' + values[0] + ', ' + values[1] +
|
| + ', ' + values[2] + ') ';
|
| + break;
|
| + case 'scale':
|
| + if (value[i].d[0] === value[i].d[1]) {
|
| + out += value[i].t + '(' + value[i].d[0] + ') ';
|
| + } else {
|
| + out += value[i].t + '(' + value[i].d[0] + ', ' + value[i].d[1] +
|
| + ') ';
|
| + }
|
| + break;
|
| + case 'scaleX':
|
| + case 'scaleY':
|
| + case 'scaleZ':
|
| + out += value[i].t + '(' + value[i].d[0] + ') ';
|
| + break;
|
| + case 'scale3d':
|
| + out += value[i].t + '(' + value[i].d[0] + ', ' +
|
| + value[i].d[1] + ', ' + value[i].d[2] + ') ';
|
| + break;
|
| + case 'matrix':
|
| + case 'matrix3d':
|
| + out += value[i].t + '(' + value[i].d.map(n).join(', ') + ') ';
|
| + break;
|
| + }
|
| + }
|
| + return out.substring(0, out.length - 1);
|
| + },
|
| + fromCssValue: function(value) {
|
| + // TODO: fix this :)
|
| + if (value === undefined) {
|
| + return undefined;
|
| + }
|
| + var result = [];
|
| + while (value.length > 0) {
|
| + var r;
|
| + for (var i = 0; i < transformREs.length; i++) {
|
| + var reSpec = transformREs[i];
|
| + r = reSpec[0].exec(value);
|
| + if (r) {
|
| + result.push({t: reSpec[2], d: reSpec[1](r)});
|
| + value = value.substring(r[0].length);
|
| + break;
|
| + }
|
| + }
|
| + if (!isDefinedAndNotNull(r)) {
|
| + return result;
|
| + }
|
| + }
|
| + return result;
|
| + }
|
| +};
|
| +
|
| +var pathType = {
|
| + // Properties ...
|
| + // - path: The target path element
|
| + // - points: The absolute points to set on the path
|
| + // - cachedCumulativeLengths: The lengths at the end of each segment
|
| + add: function() { throw 'Addition not supported for path attribute' },
|
| + cumulativeLengths: function(value) {
|
| + if (isDefinedAndNotNull(value.cachedCumulativeLengths))
|
| + return value.cachedCumulativeLengths;
|
| + var path = value.path.cloneNode(true);
|
| + var cumulativeLengths = [];
|
| + while (path.pathSegList.numberOfItems > 0) {
|
| + // TODO: It would be good to skip moves here and when generating points.
|
| + cumulativeLengths.unshift(path.getTotalLength());
|
| + path.pathSegList.removeItem(path.pathSegList.numberOfItems - 1);
|
| + }
|
| + value.cachedCumulativeLengths = cumulativeLengths;
|
| + return value.cachedCumulativeLengths;
|
| + },
|
| + appendFractions: function(fractions, cumulativeLengths) {
|
| + ASSERT_ENABLED && assert(cumulativeLengths[0] === 0);
|
| + var totalLength = cumulativeLengths[cumulativeLengths.length - 1];
|
| + for (var i = 1; i < cumulativeLengths.length - 1; ++i)
|
| + fractions.push(cumulativeLengths[i] / totalLength);
|
| + },
|
| + interpolate: function(from, to, f) {
|
| + // FIXME: Handle non-linear path segments.
|
| + // Get the fractions at which we need to sample.
|
| + var sampleFractions = [0, 1];
|
| + pathType.appendFractions(sampleFractions, pathType.cumulativeLengths(from));
|
| + pathType.appendFractions(sampleFractions, pathType.cumulativeLengths(to));
|
| + sampleFractions.sort();
|
| + ASSERT_ENABLED && assert(sampleFractions[0] === 0);
|
| + ASSERT_ENABLED && assert(sampleFractions[sampleFractions.length - 1] === 1);
|
| +
|
| + // FIXME: Cache the 'from' and 'to' points.
|
| + var fromTotalLength = from.path.getTotalLength();
|
| + var toTotalLength = to.path.getTotalLength();
|
| + var points = [];
|
| + for (var i = 0; i < sampleFractions.length; ++i) {
|
| + var fromPoint = from.path.getPointAtLength(
|
| + fromTotalLength * sampleFractions[i]);
|
| + var toPoint = to.path.getPointAtLength(
|
| + toTotalLength * sampleFractions[i]);
|
| + points.push({
|
| + x: interp(fromPoint.x, toPoint.x, f),
|
| + y: interp(fromPoint.y, toPoint.y, f)
|
| + });
|
| + }
|
| + return {points: points};
|
| + },
|
| + pointToString: function(point) {
|
| + return point.x + ',' + point.y;
|
| + },
|
| + toCssValue: function(value, svgMode) {
|
| + // FIXME: It would be good to use PathSegList API on the target directly,
|
| + // rather than generating this string, but that would require a hack to
|
| + // setValue().
|
| + ASSERT_ENABLED && assert(svgMode,
|
| + 'Path type should only be used with SVG \'d\' attribute');
|
| + if (value.path)
|
| + return value.path.getAttribute('d');
|
| + var ret = 'M' + pathType.pointToString(value.points[0]);
|
| + for (var i = 1; i < value.points.length; ++i)
|
| + ret += 'L' + pathType.pointToString(value.points[i]);
|
| + return ret;
|
| + },
|
| + fromCssValue: function(value) {
|
| + var path = document.createElementNS('http://www.w3.org/2000/svg', 'path');
|
| + if (value)
|
| + path.setAttribute('d', value);
|
| + return {path: path};
|
| + }
|
| +};
|
| +
|
| +var propertyTypes = {
|
| + backgroundColor: colorType,
|
| + backgroundPosition: positionListType,
|
| + borderBottomColor: colorType,
|
| + borderBottomLeftRadius: percentLengthType,
|
| + borderBottomRightRadius: percentLengthType,
|
| + borderBottomWidth: lengthType,
|
| + borderLeftColor: colorType,
|
| + borderLeftWidth: lengthType,
|
| + borderRightColor: colorType,
|
| + borderRightWidth: lengthType,
|
| + borderSpacing: lengthType,
|
| + borderTopColor: colorType,
|
| + borderTopLeftRadius: percentLengthType,
|
| + borderTopRightRadius: percentLengthType,
|
| + borderTopWidth: lengthType,
|
| + bottom: percentLengthAutoType,
|
| + boxShadow: shadowType,
|
| + clip: typeWithKeywords(['auto'], rectangleType),
|
| + color: colorType,
|
| + cx: lengthType,
|
| + cy: lengthType,
|
| + d: pathType,
|
| + dx: lengthType,
|
| + dy: lengthType,
|
| + fill: colorType,
|
| + floodColor: colorType,
|
| +
|
| + // TODO: Handle these keywords properly.
|
| + fontSize: typeWithKeywords(['smaller', 'larger'], percentLengthType),
|
| + fontWeight: typeWithKeywords(['lighter', 'bolder'], fontWeightType),
|
| +
|
| + height: percentLengthAutoType,
|
| + left: percentLengthAutoType,
|
| + letterSpacing: typeWithKeywords(['normal'], lengthType),
|
| + lightingColor: colorType,
|
| + lineHeight: percentLengthType, // TODO: Should support numberType as well.
|
| + marginBottom: lengthAutoType,
|
| + marginLeft: lengthAutoType,
|
| + marginRight: lengthAutoType,
|
| + marginTop: lengthAutoType,
|
| + maxHeight: typeWithKeywords(
|
| + ['none', 'max-content', 'min-content', 'fill-available', 'fit-content'],
|
| + percentLengthType),
|
| + maxWidth: typeWithKeywords(
|
| + ['none', 'max-content', 'min-content', 'fill-available', 'fit-content'],
|
| + percentLengthType),
|
| + minHeight: typeWithKeywords(
|
| + ['max-content', 'min-content', 'fill-available', 'fit-content'],
|
| + percentLengthType),
|
| + minWidth: typeWithKeywords(
|
| + ['max-content', 'min-content', 'fill-available', 'fit-content'],
|
| + percentLengthType),
|
| + opacity: numberType,
|
| + outlineColor: typeWithKeywords(['invert'], colorType),
|
| + outlineOffset: lengthType,
|
| + outlineWidth: lengthType,
|
| + paddingBottom: lengthType,
|
| + paddingLeft: lengthType,
|
| + paddingRight: lengthType,
|
| + paddingTop: lengthType,
|
| + perspective: typeWithKeywords(['none'], lengthType),
|
| + perspectiveOrigin: originType,
|
| + r: lengthType,
|
| + right: percentLengthAutoType,
|
| + stopColor: colorType,
|
| + stroke: colorType,
|
| + textIndent: typeWithKeywords(['each-line', 'hanging'], percentLengthType),
|
| + textShadow: shadowType,
|
| + top: percentLengthAutoType,
|
| + transform: transformType,
|
| + transformOrigin: originType,
|
| + verticalAlign: typeWithKeywords([
|
| + 'baseline',
|
| + 'sub',
|
| + 'super',
|
| + 'text-top',
|
| + 'text-bottom',
|
| + 'middle',
|
| + 'top',
|
| + 'bottom'
|
| + ], percentLengthType),
|
| + visibility: visibilityType,
|
| + width: typeWithKeywords([
|
| + 'border-box',
|
| + 'content-box',
|
| + 'auto',
|
| + 'max-content',
|
| + 'min-content',
|
| + 'available',
|
| + 'fit-content'
|
| + ], percentLengthType),
|
| + wordSpacing: typeWithKeywords(['normal'], percentLengthType),
|
| + x: lengthType,
|
| + y: lengthType,
|
| + zIndex: typeWithKeywords(['auto'], integerType)
|
| +};
|
| +
|
| +var svgProperties = {
|
| + 'cx': 1,
|
| + 'cy': 1,
|
| + 'd': 1,
|
| + 'dx': 1,
|
| + 'dy': 1,
|
| + 'fill': 1,
|
| + 'floodColor': 1,
|
| + 'height': 1,
|
| + 'lightingColor': 1,
|
| + 'r': 1,
|
| + 'stopColor': 1,
|
| + 'stroke': 1,
|
| + 'width': 1,
|
| + 'x': 1,
|
| + 'y': 1
|
| +};
|
| +
|
| +var borderWidthAliases = {
|
| + initial: '3px',
|
| + thin: '1px',
|
| + medium: '3px',
|
| + thick: '5px'
|
| +};
|
| +
|
| +var propertyValueAliases = {
|
| + backgroundColor: { initial: 'transparent' },
|
| + backgroundPosition: { initial: '0% 0%' },
|
| + borderBottomColor: { initial: 'currentColor' },
|
| + borderBottomLeftRadius: { initial: '0px' },
|
| + borderBottomRightRadius: { initial: '0px' },
|
| + borderBottomWidth: borderWidthAliases,
|
| + borderLeftColor: { initial: 'currentColor' },
|
| + borderLeftWidth: borderWidthAliases,
|
| + borderRightColor: { initial: 'currentColor' },
|
| + borderRightWidth: borderWidthAliases,
|
| + // Spec says this should be 0 but in practise it is 2px.
|
| + borderSpacing: { initial: '2px' },
|
| + borderTopColor: { initial: 'currentColor' },
|
| + borderTopLeftRadius: { initial: '0px' },
|
| + borderTopRightRadius: { initial: '0px' },
|
| + borderTopWidth: borderWidthAliases,
|
| + bottom: { initial: 'auto' },
|
| + clip: { initial: 'rect(0px, 0px, 0px, 0px)' },
|
| + color: { initial: 'black' }, // Depends on user agent.
|
| + fontSize: {
|
| + initial: '100%',
|
| + 'xx-small': '60%',
|
| + 'x-small': '75%',
|
| + 'small': '89%',
|
| + 'medium': '100%',
|
| + 'large': '120%',
|
| + 'x-large': '150%',
|
| + 'xx-large': '200%'
|
| + },
|
| + fontWeight: {
|
| + initial: '400',
|
| + normal: '400',
|
| + bold: '700'
|
| + },
|
| + height: { initial: 'auto' },
|
| + left: { initial: 'auto' },
|
| + letterSpacing: { initial: 'normal' },
|
| + lineHeight: {
|
| + initial: '120%',
|
| + normal: '120%'
|
| + },
|
| + marginBottom: { initial: '0px' },
|
| + marginLeft: { initial: '0px' },
|
| + marginRight: { initial: '0px' },
|
| + marginTop: { initial: '0px' },
|
| + maxHeight: { initial: 'none' },
|
| + maxWidth: { initial: 'none' },
|
| + minHeight: { initial: '0px' },
|
| + minWidth: { initial: '0px' },
|
| + opacity: { initial: '1.0' },
|
| + outlineColor: { initial: 'invert' },
|
| + outlineOffset: { initial: '0px' },
|
| + outlineWidth: borderWidthAliases,
|
| + paddingBottom: { initial: '0px' },
|
| + paddingLeft: { initial: '0px' },
|
| + paddingRight: { initial: '0px' },
|
| + paddingTop: { initial: '0px' },
|
| + right: { initial: 'auto' },
|
| + textIndent: { initial: '0px' },
|
| + textShadow: {
|
| + initial: '0px 0px 0px transparent',
|
| + none: '0px 0px 0px transparent'
|
| + },
|
| + top: { initial: 'auto' },
|
| + transform: {
|
| + initial: '',
|
| + none: ''
|
| + },
|
| + verticalAlign: { initial: '0px' },
|
| + visibility: { initial: 'visible' },
|
| + width: { initial: 'auto' },
|
| + wordSpacing: { initial: 'normal' },
|
| + zIndex: { initial: 'auto' }
|
| +};
|
| +
|
| +var propertyIsSVGAttrib = function(property, target) {
|
| + return target.namespaceURI === 'http://www.w3.org/2000/svg' &&
|
| + property in svgProperties;
|
| +};
|
| +
|
| +var getType = function(property) {
|
| + return propertyTypes[property] || nonNumericType;
|
| +};
|
| +
|
| +var add = function(property, base, delta) {
|
| + if (delta === rawNeutralValue) {
|
| + return base;
|
| + }
|
| + if (base === 'inherit' || delta === 'inherit') {
|
| + return nonNumericType.add(base, delta);
|
| + }
|
| + return getType(property).add(base, delta);
|
| +};
|
| +
|
| +
|
| +/**
|
| + * Interpolate the given property name (f*100)% of the way from 'from' to 'to'.
|
| + * 'from' and 'to' are both raw values already converted from CSS value
|
| + * strings. Requires the target element to be able to determine whether the
|
| + * given property is an SVG attribute or not, as this impacts the conversion of
|
| + * the interpolated value back into a CSS value string for transform
|
| + * translations.
|
| + *
|
| + * e.g. interpolate('transform', elem, 'rotate(40deg)', 'rotate(50deg)', 0.3);
|
| + * will return 'rotate(43deg)'.
|
| + */
|
| +var interpolate = function(property, from, to, f) {
|
| + ASSERT_ENABLED && assert(
|
| + isDefinedAndNotNull(from) && isDefinedAndNotNull(to),
|
| + 'Both to and from values should be specified for interpolation');
|
| + if (from === 'inherit' || to === 'inherit') {
|
| + return nonNumericType.interpolate(from, to, f);
|
| + }
|
| + if (f === 0) {
|
| + return from;
|
| + }
|
| + if (f === 1) {
|
| + return to;
|
| + }
|
| + return getType(property).interpolate(from, to, f);
|
| +};
|
| +
|
| +
|
| +/**
|
| + * Convert the provided interpolable value for the provided property to a CSS
|
| + * value string. Note that SVG transforms do not require units for translate
|
| + * or rotate values while CSS properties require 'px' or 'deg' units.
|
| + */
|
| +var toCssValue = function(property, value, svgMode) {
|
| + if (value === 'inherit') {
|
| + return value;
|
| + }
|
| + return getType(property).toCssValue(value, svgMode);
|
| +};
|
| +
|
| +var fromCssValue = function(property, value) {
|
| + if (value === cssNeutralValue) {
|
| + return rawNeutralValue;
|
| + }
|
| + if (value === 'inherit') {
|
| + return value;
|
| + }
|
| + if (property in propertyValueAliases &&
|
| + value in propertyValueAliases[property]) {
|
| + value = propertyValueAliases[property][value];
|
| + }
|
| + var result = getType(property).fromCssValue(value);
|
| + // Currently we'll hit this assert if input to the API is bad. To avoid this,
|
| + // we should eliminate invalid values when normalizing the list of keyframes.
|
| + // See the TODO in isSupportedPropertyValue().
|
| + ASSERT_ENABLED && assert(isDefinedAndNotNull(result),
|
| + 'Invalid property value "' + value + '" for property "' + property + '"');
|
| + return result;
|
| +};
|
| +
|
| +// Sentinel values
|
| +var cssNeutralValue = {};
|
| +var rawNeutralValue = {};
|
| +
|
| +
|
| +
|
| +/** @constructor */
|
| +var CompositableValue = function() {
|
| +};
|
| +
|
| +CompositableValue.prototype = {
|
| + compositeOnto: abstractMethod,
|
| + // This is purely an optimization.
|
| + dependsOnUnderlyingValue: function() {
|
| + return true;
|
| + }
|
| +};
|
| +
|
| +
|
| +
|
| +/** @constructor */
|
| +var AddReplaceCompositableValue = function(value, composite) {
|
| + this.value = value;
|
| + this.composite = composite;
|
| + ASSERT_ENABLED && assert(
|
| + !(this.value === cssNeutralValue && this.composite === 'replace'),
|
| + 'Should never replace-composite the neutral value');
|
| +};
|
| +
|
| +AddReplaceCompositableValue.prototype = createObject(
|
| + CompositableValue.prototype, {
|
| + compositeOnto: function(property, underlyingValue) {
|
| + switch (this.composite) {
|
| + case 'replace':
|
| + return this.value;
|
| + case 'add':
|
| + return add(property, underlyingValue, this.value);
|
| + default:
|
| + ASSERT_ENABLED && assert(
|
| + false, 'Invalid composite operation ' + this.composite);
|
| + }
|
| + },
|
| + dependsOnUnderlyingValue: function() {
|
| + return this.composite === 'add';
|
| + }
|
| + });
|
| +
|
| +
|
| +
|
| +/** @constructor */
|
| +var BlendedCompositableValue = function(startValue, endValue, fraction) {
|
| + this.startValue = startValue;
|
| + this.endValue = endValue;
|
| + this.fraction = fraction;
|
| +};
|
| +
|
| +BlendedCompositableValue.prototype = createObject(
|
| + CompositableValue.prototype, {
|
| + compositeOnto: function(property, underlyingValue) {
|
| + return interpolate(property,
|
| + this.startValue.compositeOnto(property, underlyingValue),
|
| + this.endValue.compositeOnto(property, underlyingValue),
|
| + this.fraction);
|
| + },
|
| + dependsOnUnderlyingValue: function() {
|
| + // Travis crashes here randomly in Chrome beta and unstable,
|
| + // this try catch is to help debug the problem.
|
| + try {
|
| + return this.startValue.dependsOnUnderlyingValue() ||
|
| + this.endValue.dependsOnUnderlyingValue();
|
| + }
|
| + catch (error) {
|
| + throw new Error(
|
| + error + '\n JSON.stringify(this) = ' + JSON.stringify(this));
|
| + }
|
| + }
|
| + });
|
| +
|
| +/** @constructor */
|
| +var CompositedPropertyMap = function(target) {
|
| + this.properties = {};
|
| + this.baseValues = {};
|
| + this.target = target;
|
| +};
|
| +
|
| +CompositedPropertyMap.prototype = {
|
| + addValue: function(property, animValue) {
|
| + if (!(property in this.properties)) {
|
| + this.properties[property] = [];
|
| + }
|
| + if (!(animValue instanceof CompositableValue)) {
|
| + throw new TypeError('expected CompositableValue');
|
| + }
|
| + this.properties[property].push(animValue);
|
| + },
|
| + stackDependsOnUnderlyingValue: function(stack) {
|
| + for (var i = 0; i < stack.length; i++) {
|
| + if (!stack[i].dependsOnUnderlyingValue()) {
|
| + return false;
|
| + }
|
| + }
|
| + return true;
|
| + },
|
| + clear: function() {
|
| + for (var property in this.properties) {
|
| + if (this.stackDependsOnUnderlyingValue(this.properties[property])) {
|
| + clearValue(this.target, property);
|
| + }
|
| + }
|
| + },
|
| + captureBaseValues: function() {
|
| + for (var property in this.properties) {
|
| + var stack = this.properties[property];
|
| + if (stack.length > 0 && this.stackDependsOnUnderlyingValue(stack)) {
|
| + var baseValue = fromCssValue(property, getValue(this.target, property));
|
| + // TODO: Decide what to do with elements not in the DOM.
|
| + ASSERT_ENABLED && assert(
|
| + isDefinedAndNotNull(baseValue) && baseValue !== '',
|
| + 'Base value should always be set. ' +
|
| + 'Is the target element in the DOM?');
|
| + this.baseValues[property] = baseValue;
|
| + } else {
|
| + this.baseValues[property] = undefined;
|
| + }
|
| + }
|
| + },
|
| + applyAnimatedValues: function() {
|
| + for (var property in this.properties) {
|
| + var valuesToComposite = this.properties[property];
|
| + if (valuesToComposite.length === 0) {
|
| + continue;
|
| + }
|
| + var baseValue = this.baseValues[property];
|
| + var i = valuesToComposite.length - 1;
|
| + while (i > 0 && valuesToComposite[i].dependsOnUnderlyingValue()) {
|
| + i--;
|
| + }
|
| + for (; i < valuesToComposite.length; i++) {
|
| + baseValue = valuesToComposite[i].compositeOnto(property, baseValue);
|
| + }
|
| + ASSERT_ENABLED && assert(
|
| + isDefinedAndNotNull(baseValue) && baseValue !== '',
|
| + 'Value should always be set after compositing');
|
| + var isSvgMode = propertyIsSVGAttrib(property, this.target);
|
| + setValue(this.target, property, toCssValue(property, baseValue,
|
| + isSvgMode));
|
| + this.properties[property] = [];
|
| + }
|
| + }
|
| +};
|
| +
|
| +
|
| +var cssStyleDeclarationAttribute = {
|
| + cssText: true,
|
| + length: true,
|
| + parentRule: true,
|
| + 'var': true
|
| +};
|
| +
|
| +var cssStyleDeclarationMethodModifiesStyle = {
|
| + getPropertyValue: false,
|
| + getPropertyCSSValue: false,
|
| + removeProperty: true,
|
| + getPropertyPriority: false,
|
| + setProperty: true,
|
| + item: false
|
| +};
|
| +
|
| +var copyInlineStyle = function(sourceStyle, destinationStyle) {
|
| + for (var i = 0; i < sourceStyle.length; i++) {
|
| + var property = sourceStyle[i];
|
| + destinationStyle[property] = sourceStyle[property];
|
| + }
|
| +};
|
| +
|
| +var retickThenGetComputedStyle = function() {
|
| + repeatLastTick();
|
| + ensureOriginalGetComputedStyle();
|
| + return window.getComputedStyle.apply(this, arguments);
|
| +};
|
| +
|
| +// This redundant flag is to support Safari which has trouble determining
|
| +// function object equality during an animation.
|
| +var isGetComputedStylePatched = false;
|
| +var originalGetComputedStyle = window.getComputedStyle;
|
| +
|
| +var ensureRetickBeforeGetComputedStyle = function() {
|
| + if (!isGetComputedStylePatched) {
|
| + Object.defineProperty(window, 'getComputedStyle', configureDescriptor({
|
| + value: retickThenGetComputedStyle
|
| + }));
|
| + isGetComputedStylePatched = true;
|
| + }
|
| +};
|
| +
|
| +var ensureOriginalGetComputedStyle = function() {
|
| + if (isGetComputedStylePatched) {
|
| + Object.defineProperty(window, 'getComputedStyle', configureDescriptor({
|
| + value: originalGetComputedStyle
|
| + }));
|
| + isGetComputedStylePatched = false;
|
| + }
|
| +};
|
| +
|
| +// Changing the inline style of an element under animation may require the
|
| +// animation to be recomputed ontop of the new inline style if
|
| +// getComputedStyle() is called inbetween setting the style and the next
|
| +// animation frame.
|
| +// We modify getComputedStyle() to re-evaluate the animations only if it is
|
| +// called instead of re-evaluating them here potentially unnecessarily.
|
| +var animatedInlineStyleChanged = function() {
|
| + maybeRestartAnimation();
|
| + ensureRetickBeforeGetComputedStyle();
|
| +};
|
| +
|
| +
|
| +
|
| +/** @constructor */
|
| +var AnimatedCSSStyleDeclaration = function(element) {
|
| + ASSERT_ENABLED && assert(
|
| + !(element.style instanceof AnimatedCSSStyleDeclaration),
|
| + 'Element must not already have an animated style attached.');
|
| +
|
| + // Stores the inline style of the element on its behalf while the
|
| + // polyfill uses the element's inline style to simulate web animations.
|
| + // This is needed to fake regular inline style CSSOM access on the element.
|
| + this._surrogateElement = createDummyElement();
|
| + this._style = element.style;
|
| + this._length = 0;
|
| + this._isAnimatedProperty = {};
|
| +
|
| + // Populate the surrogate element's inline style.
|
| + copyInlineStyle(this._style, this._surrogateElement.style);
|
| + this._updateIndices();
|
| +};
|
| +
|
| +AnimatedCSSStyleDeclaration.prototype = {
|
| + get cssText() {
|
| + return this._surrogateElement.style.cssText;
|
| + },
|
| + set cssText(text) {
|
| + var isAffectedProperty = {};
|
| + for (var i = 0; i < this._surrogateElement.style.length; i++) {
|
| + isAffectedProperty[this._surrogateElement.style[i]] = true;
|
| + }
|
| + this._surrogateElement.style.cssText = text;
|
| + this._updateIndices();
|
| + for (var i = 0; i < this._surrogateElement.style.length; i++) {
|
| + isAffectedProperty[this._surrogateElement.style[i]] = true;
|
| + }
|
| + for (var property in isAffectedProperty) {
|
| + if (!this._isAnimatedProperty[property]) {
|
| + this._style.setProperty(property,
|
| + this._surrogateElement.style.getPropertyValue(property));
|
| + }
|
| + }
|
| + animatedInlineStyleChanged();
|
| + },
|
| + get length() {
|
| + return this._surrogateElement.style.length;
|
| + },
|
| + get parentRule() {
|
| + return this._style.parentRule;
|
| + },
|
| + get 'var'() {
|
| + return this._style.var;
|
| + },
|
| + _updateIndices: function() {
|
| + while (this._length < this._surrogateElement.style.length) {
|
| + Object.defineProperty(this, this._length, {
|
| + configurable: true,
|
| + enumerable: false,
|
| + get: (function(index) {
|
| + return function() {
|
| + return this._surrogateElement.style[index];
|
| + };
|
| + })(this._length)
|
| + });
|
| + this._length++;
|
| + }
|
| + while (this._length > this._surrogateElement.style.length) {
|
| + this._length--;
|
| + Object.defineProperty(this, this._length, {
|
| + configurable: true,
|
| + enumerable: false,
|
| + value: undefined
|
| + });
|
| + }
|
| + },
|
| + _clearAnimatedProperty: function(property) {
|
| + this._style[property] = this._surrogateElement.style[property];
|
| + this._isAnimatedProperty[property] = false;
|
| + },
|
| + _setAnimatedProperty: function(property, value) {
|
| + this._style[property] = value;
|
| + this._isAnimatedProperty[property] = true;
|
| + }
|
| +};
|
| +
|
| +for (var method in cssStyleDeclarationMethodModifiesStyle) {
|
| + AnimatedCSSStyleDeclaration.prototype[method] =
|
| + (function(method, modifiesStyle) {
|
| + return function() {
|
| + var result = this._surrogateElement.style[method].apply(
|
| + this._surrogateElement.style, arguments);
|
| + if (modifiesStyle) {
|
| + if (!this._isAnimatedProperty[arguments[0]]) {
|
| + this._style[method].apply(this._style, arguments);
|
| + }
|
| + this._updateIndices();
|
| + animatedInlineStyleChanged();
|
| + }
|
| + return result;
|
| + }
|
| + })(method, cssStyleDeclarationMethodModifiesStyle[method]);
|
| +}
|
| +
|
| +for (var property in document.documentElement.style) {
|
| + if (cssStyleDeclarationAttribute[property] ||
|
| + property in cssStyleDeclarationMethodModifiesStyle) {
|
| + continue;
|
| + }
|
| + (function(property) {
|
| + Object.defineProperty(AnimatedCSSStyleDeclaration.prototype, property,
|
| + configureDescriptor({
|
| + get: function() {
|
| + return this._surrogateElement.style[property];
|
| + },
|
| + set: function(value) {
|
| + this._surrogateElement.style[property] = value;
|
| + this._updateIndices();
|
| + if (!this._isAnimatedProperty[property]) {
|
| + this._style[property] = value;
|
| + }
|
| + animatedInlineStyleChanged();
|
| + }
|
| + }));
|
| + })(property);
|
| +}
|
| +
|
| +// This function is a fallback for when we can't replace an element's style with
|
| +// AnimatatedCSSStyleDeclaration and must patch the existing style to behave
|
| +// in a similar way.
|
| +// Only the methods listed in cssStyleDeclarationMethodModifiesStyle will
|
| +// be patched to behave in the same manner as a native implementation,
|
| +// getter properties like style.left or style[0] will be tainted by the
|
| +// polyfill's animation engine.
|
| +var patchInlineStyleForAnimation = function(style) {
|
| + var surrogateElement = document.createElement('div');
|
| + copyInlineStyle(style, surrogateElement.style);
|
| + var isAnimatedProperty = {};
|
| + for (var method in cssStyleDeclarationMethodModifiesStyle) {
|
| + if (!(method in style)) {
|
| + continue;
|
| + }
|
| + Object.defineProperty(style, method, configureDescriptor({
|
| + value: (function(method, originalMethod, modifiesStyle) {
|
| + return function() {
|
| + var result = surrogateElement.style[method].apply(
|
| + surrogateElement.style, arguments);
|
| + if (modifiesStyle) {
|
| + if (!isAnimatedProperty[arguments[0]]) {
|
| + originalMethod.apply(style, arguments);
|
| + }
|
| + animatedInlineStyleChanged();
|
| + }
|
| + return result;
|
| + }
|
| + })(method, style[method], cssStyleDeclarationMethodModifiesStyle[method])
|
| + }));
|
| + }
|
| +
|
| + style._clearAnimatedProperty = function(property) {
|
| + this[property] = surrogateElement.style[property];
|
| + isAnimatedProperty[property] = false;
|
| + };
|
| +
|
| + style._setAnimatedProperty = function(property, value) {
|
| + this[property] = value;
|
| + isAnimatedProperty[property] = true;
|
| + };
|
| +};
|
| +
|
| +
|
| +
|
| +/** @constructor */
|
| +var Compositor = function() {
|
| + this.targets = [];
|
| +};
|
| +
|
| +Compositor.prototype = {
|
| + setAnimatedValue: function(target, property, animValue) {
|
| + if (target !== null) {
|
| + if (target._animProperties === undefined) {
|
| + target._animProperties = new CompositedPropertyMap(target);
|
| + this.targets.push(target);
|
| + }
|
| + target._animProperties.addValue(property, animValue);
|
| + }
|
| + },
|
| + applyAnimatedValues: function() {
|
| + for (var i = 0; i < this.targets.length; i++) {
|
| + this.targets[i]._animProperties.clear();
|
| + }
|
| + for (var i = 0; i < this.targets.length; i++) {
|
| + this.targets[i]._animProperties.captureBaseValues();
|
| + }
|
| + for (var i = 0; i < this.targets.length; i++) {
|
| + this.targets[i]._animProperties.applyAnimatedValues();
|
| + }
|
| + }
|
| +};
|
| +
|
| +var ensureTargetInitialised = function(property, target) {
|
| + if (propertyIsSVGAttrib(property, target)) {
|
| + ensureTargetSVGInitialised(property, target);
|
| + } else {
|
| + ensureTargetCSSInitialised(target);
|
| + }
|
| +};
|
| +
|
| +var ensureTargetSVGInitialised = function(property, target) {
|
| + if (!isDefinedAndNotNull(target._actuals)) {
|
| + target._actuals = {};
|
| + target._bases = {};
|
| + target.actuals = {};
|
| + target._getAttribute = target.getAttribute;
|
| + target._setAttribute = target.setAttribute;
|
| + target.getAttribute = function(name) {
|
| + if (isDefinedAndNotNull(target._bases[name])) {
|
| + return target._bases[name];
|
| + }
|
| + return target._getAttribute(name);
|
| + };
|
| + target.setAttribute = function(name, value) {
|
| + if (isDefinedAndNotNull(target._actuals[name])) {
|
| + target._bases[name] = value;
|
| + } else {
|
| + target._setAttribute(name, value);
|
| + }
|
| + };
|
| + }
|
| + if (!isDefinedAndNotNull(target._actuals[property])) {
|
| + var baseVal = target.getAttribute(property);
|
| + target._actuals[property] = 0;
|
| + target._bases[property] = baseVal;
|
| +
|
| + Object.defineProperty(target.actuals, property, configureDescriptor({
|
| + set: function(value) {
|
| + if (value === null) {
|
| + target._actuals[property] = target._bases[property];
|
| + target._setAttribute(property, target._bases[property]);
|
| + } else {
|
| + target._actuals[property] = value;
|
| + target._setAttribute(property, value);
|
| + }
|
| + },
|
| + get: function() {
|
| + return target._actuals[property];
|
| + }
|
| + }));
|
| + }
|
| +};
|
| +
|
| +var ensureTargetCSSInitialised = function(target) {
|
| + if (target.style._webAnimationsStyleInitialised) {
|
| + return;
|
| + }
|
| + try {
|
| + var animatedStyle = new AnimatedCSSStyleDeclaration(target);
|
| + Object.defineProperty(target, 'style', configureDescriptor({
|
| + get: function() { return animatedStyle; }
|
| + }));
|
| + } catch (error) {
|
| + patchInlineStyleForAnimation(target.style);
|
| + }
|
| + target.style._webAnimationsStyleInitialised = true;
|
| +};
|
| +
|
| +var setValue = function(target, property, value) {
|
| + ensureTargetInitialised(property, target);
|
| + property = prefixProperty(property);
|
| + if (propertyIsSVGAttrib(property, target)) {
|
| + target.actuals[property] = value;
|
| + } else {
|
| + target.style._setAnimatedProperty(property, value);
|
| + }
|
| +};
|
| +
|
| +var clearValue = function(target, property) {
|
| + ensureTargetInitialised(property, target);
|
| + property = prefixProperty(property);
|
| + if (propertyIsSVGAttrib(property, target)) {
|
| + target.actuals[property] = null;
|
| + } else {
|
| + target.style._clearAnimatedProperty(property);
|
| + }
|
| +};
|
| +
|
| +var getValue = function(target, property) {
|
| + ensureTargetInitialised(property, target);
|
| + property = prefixProperty(property);
|
| + if (propertyIsSVGAttrib(property, target)) {
|
| + return target.actuals[property];
|
| + } else {
|
| + return getComputedStyle(target)[property];
|
| + }
|
| +};
|
| +
|
| +var rafScheduled = false;
|
| +
|
| +var compositor = new Compositor();
|
| +
|
| +var usePerformanceTiming =
|
| + typeof window.performance === 'object' &&
|
| + typeof window.performance.timing === 'object' &&
|
| + typeof window.performance.now === 'function';
|
| +
|
| +// Don't use a local named requestAnimationFrame, to avoid potential problems
|
| +// with hoisting.
|
| +var nativeRaf = window.requestAnimationFrame ||
|
| + window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame;
|
| +var raf;
|
| +if (nativeRaf) {
|
| + raf = function(callback) {
|
| + nativeRaf(function() {
|
| + callback(clockMillis());
|
| + });
|
| + };
|
| +} else {
|
| + raf = function(callback) {
|
| + setTimeout(function() {
|
| + callback(clockMillis());
|
| + }, 1000 / 60);
|
| + };
|
| +}
|
| +
|
| +var clockMillis = function() {
|
| + return usePerformanceTiming ? window.performance.now() : Date.now();
|
| +};
|
| +// Set up the zero times for document time. Document time is relative to the
|
| +// document load event.
|
| +var documentTimeZeroAsRafTime;
|
| +var documentTimeZeroAsClockTime;
|
| +var load;
|
| +if (usePerformanceTiming) {
|
| + load = function() {
|
| + // RAF time is relative to the navigationStart event.
|
| + documentTimeZeroAsRafTime =
|
| + window.performance.timing.loadEventStart -
|
| + window.performance.timing.navigationStart;
|
| + // performance.now() uses the same origin as RAF time.
|
| + documentTimeZeroAsClockTime = documentTimeZeroAsRafTime;
|
| + };
|
| +} else {
|
| + // The best approximation we have for the relevant clock and RAF times is to
|
| + // listen to the load event.
|
| + load = function() {
|
| + raf(function(rafTime) {
|
| + documentTimeZeroAsRafTime = rafTime;
|
| + });
|
| + documentTimeZeroAsClockTime = Date.now();
|
| + };
|
| +}
|
| +// Start timing when load event fires or if this script is processed when
|
| +// document loading is already complete.
|
| +if (document.readyState === 'complete') {
|
| + // When performance timing is unavailable and this script is loaded
|
| + // dynamically, document zero time is incorrect.
|
| + // Warn the user in this case.
|
| + if (!usePerformanceTiming) {
|
| + console.warn(
|
| + 'Web animations can\'t discover document zero time when ' +
|
| + 'asynchronously loaded in the absence of performance timing.');
|
| + }
|
| + load();
|
| +} else {
|
| + addEventListener('load', function() {
|
| + load();
|
| + if (usePerformanceTiming) {
|
| + // We use setTimeout() to clear cachedClockTimeMillis at the end of a
|
| + // frame, but this will not run until after other load handlers. We need
|
| + // those handlers to pick up the new value of clockMillis(), so we must
|
| + // clear the cached value.
|
| + cachedClockTimeMillis = undefined;
|
| + }
|
| + });
|
| +}
|
| +
|
| +// A cached document time for use during the current callstack.
|
| +var cachedClockTimeMillis;
|
| +// Calculates one time relative to another, returning null if the zero time is
|
| +// undefined.
|
| +var relativeTime = function(time, zeroTime) {
|
| + return isDefined(zeroTime) ? time - zeroTime : null;
|
| +};
|
| +
|
| +var lastClockTimeMillis;
|
| +
|
| +var cachedClockTime = function() {
|
| + // Cache a document time for the remainder of this callstack.
|
| + if (!isDefined(cachedClockTimeMillis)) {
|
| + cachedClockTimeMillis = clockMillis();
|
| + lastClockTimeMillis = cachedClockTimeMillis;
|
| + setTimeout(function() { cachedClockTimeMillis = undefined; }, 0);
|
| + }
|
| + return cachedClockTimeMillis;
|
| +};
|
| +
|
| +
|
| +// These functions should be called in every stack that could possibly modify
|
| +// the effect results that have already been calculated for the current tick.
|
| +var modifyCurrentAnimationStateDepth = 0;
|
| +var enterModifyCurrentAnimationState = function() {
|
| + modifyCurrentAnimationStateDepth++;
|
| +};
|
| +var exitModifyCurrentAnimationState = function(updateCallback) {
|
| + modifyCurrentAnimationStateDepth--;
|
| + // updateCallback is set to null when we know we can't possibly affect the
|
| + // current state (eg. a TimedItem which is not attached to a player). We track
|
| + // the depth of recursive calls trigger just one repeat per entry. Only the
|
| + // updateCallback from the outermost call is considered, this allows certain
|
| + // locatations (eg. constructors) to override nested calls that would
|
| + // otherwise set updateCallback unconditionally.
|
| + if (modifyCurrentAnimationStateDepth === 0 && updateCallback) {
|
| + updateCallback();
|
| + }
|
| +};
|
| +
|
| +var repeatLastTick = function() {
|
| + if (isDefined(lastTickTime)) {
|
| + ticker(lastTickTime, true);
|
| + }
|
| +};
|
| +
|
| +var playerSortFunction = function(a, b) {
|
| + var result = a.startTime - b.startTime;
|
| + return result !== 0 ? result : a._sequenceNumber - b._sequenceNumber;
|
| +};
|
| +
|
| +var lastTickTime;
|
| +var ticker = function(rafTime, isRepeat) {
|
| + // Don't tick till the page is loaded....
|
| + if (!isDefined(documentTimeZeroAsRafTime)) {
|
| + raf(ticker);
|
| + return;
|
| + }
|
| +
|
| + if (!isRepeat) {
|
| + if (rafTime < lastClockTimeMillis) {
|
| + rafTime = lastClockTimeMillis;
|
| + }
|
| + lastTickTime = rafTime;
|
| + cachedClockTimeMillis = rafTime;
|
| + }
|
| +
|
| + // Clear any modifications to getComputedStyle.
|
| + ensureOriginalGetComputedStyle();
|
| +
|
| + // Get animations for this sample. We order by AnimationPlayer then by DFS
|
| + // order within each AnimationPlayer's tree.
|
| + if (!playersAreSorted) {
|
| + PLAYERS.sort(playerSortFunction);
|
| + playersAreSorted = true;
|
| + }
|
| + var finished = true;
|
| + var paused = true;
|
| + var animations = [];
|
| + var finishedPlayers = [];
|
| + PLAYERS.forEach(function(player) {
|
| + player._update();
|
| + finished = finished && !player._hasFutureAnimation();
|
| + if (!player._hasFutureEffect()) {
|
| + finishedPlayers.push(player);
|
| + }
|
| + paused = paused && player.paused;
|
| + player._getLeafItemsInEffect(animations);
|
| + });
|
| +
|
| + // Apply animations in order
|
| + for (var i = 0; i < animations.length; i++) {
|
| + if (animations[i] instanceof Animation) {
|
| + animations[i]._sample();
|
| + }
|
| + }
|
| +
|
| + // Generate events
|
| + PLAYERS.forEach(function(player) {
|
| + player._generateEvents();
|
| + });
|
| +
|
| + // Remove finished players. Warning: _deregisterFromTimeline modifies
|
| + // the PLAYER list. It should not be called from within a PLAYERS.forEach
|
| + // loop directly.
|
| + finishedPlayers.forEach(function(player) {
|
| + player._deregisterFromTimeline();
|
| + playersAreSorted = false;
|
| + });
|
| +
|
| + // Composite animated values into element styles
|
| + compositor.applyAnimatedValues();
|
| +
|
| + if (!isRepeat) {
|
| + if (finished || paused) {
|
| + rafScheduled = false;
|
| + } else {
|
| + raf(ticker);
|
| + }
|
| + cachedClockTimeMillis = undefined;
|
| + }
|
| +};
|
| +
|
| +// Multiplication where zero multiplied by any value (including infinity)
|
| +// gives zero.
|
| +var multiplyZeroGivesZero = function(a, b) {
|
| + return (a === 0 || b === 0) ? 0 : a * b;
|
| +};
|
| +
|
| +var maybeRestartAnimation = function() {
|
| + if (rafScheduled) {
|
| + return;
|
| + }
|
| + raf(ticker);
|
| + rafScheduled = true;
|
| +};
|
| +
|
| +var DOCUMENT_TIMELINE = new AnimationTimeline(constructorToken);
|
| +// attempt to override native implementation
|
| +try {
|
| + Object.defineProperty(document, 'timeline', {
|
| + configurable: true,
|
| + get: function() { return DOCUMENT_TIMELINE }
|
| + });
|
| +} catch (e) { }
|
| +// maintain support for Safari
|
| +try {
|
| + document.timeline = DOCUMENT_TIMELINE;
|
| +} catch (e) { }
|
| +
|
| +window.Element.prototype.animate = function(effect, timing) {
|
| + var anim = new Animation(this, effect, timing);
|
| + DOCUMENT_TIMELINE.play(anim);
|
| + return anim.player;
|
| +};
|
| +window.Element.prototype.getCurrentPlayers = function() {
|
| + return PLAYERS.filter((function(player) {
|
| + return player._isCurrent() && player._isTargetingElement(this);
|
| + }).bind(this));
|
| +};
|
| +window.Element.prototype.getCurrentAnimations = function() {
|
| + var animations = [];
|
| + PLAYERS.forEach((function(player) {
|
| + if (player._isCurrent()) {
|
| + player._getAnimationsTargetingElement(this, animations);
|
| + }
|
| + }).bind(this));
|
| + return animations;
|
| +};
|
| +
|
| +window.Animation = Animation;
|
| +window.AnimationEffect = AnimationEffect;
|
| +window.AnimationGroup = AnimationGroup;
|
| +window.AnimationPlayer = AnimationPlayer;
|
| +window.AnimationSequence = AnimationSequence;
|
| +window.AnimationTimeline = AnimationTimeline;
|
| +window.KeyframeEffect = KeyframeEffect;
|
| +window.MediaReference = MediaReference;
|
| +window.MotionPathEffect = MotionPathEffect;
|
| +window.PseudoElementReference = PseudoElementReference;
|
| +window.TimedItem = TimedItem;
|
| +window.TimedItemList = TimedItemList;
|
| +window.Timing = Timing;
|
| +window.TimingEvent = TimingEvent;
|
| +window.TimingGroup = TimingGroup;
|
| +
|
| +window._WebAnimationsTestingUtilities = {
|
| + _constructorToken: constructorToken,
|
| + _deprecated: deprecated,
|
| + _positionListType: positionListType,
|
| + _hsl2rgb: hsl2rgb,
|
| + _types: propertyTypes,
|
| + _knownPlayers: PLAYERS,
|
| + _pacedTimingFunction: PacedTimingFunction,
|
| + _prefixProperty: prefixProperty,
|
| + _propertyIsSVGAttrib: propertyIsSVGAttrib
|
| +};
|
| +
|
| +})();
|
|
|
Chromium Code Reviews
Issue 603683003:
Added web-animations-js to third_party/web-animations-js. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master