LCOV - code coverage report
Current view: top level - modules/script/tweener - tweener.js (source / functions) Coverage Total Hit
Test: gjs- Code Coverage Lines: 84.2 % 438 369
Test Date: 2024-04-29 05:18:28 Functions: 83.3 % 42 35
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 79.0 % 252 199

             Branch data     Line data    Source code
       1                 :           1 : /* -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil; -*- */
       2                 :             : /* eslint-disable block-scoped-var, eqeqeq, no-shadow, prefer-rest-params */
       3                 :             : // SPDX-License-Identifier: MIT
       4                 :             : // SPDX-FileCopyrightText: 2006-2007 Zeh Fernando and Nate Chatellier
       5                 :             : // SPDX-FileCopyrightText: 2008 litl, LLC.
       6                 :             : 
       7                 :             : /**
       8                 :             :  * Tweener
       9                 :             :  * Transition controller for movieclips, sounds, textfields and other objects
      10                 :             :  *
      11                 :             :  * @author              Zeh Fernando, Nate Chatellier, Arthur Debert
      12                 :             :  * @version             1.31.71
      13                 :             :  */
      14                 :             : /* exported addCaller, addTween, FrameTicker, getTweenCount, getTimeScale,
      15                 :             : pauseAllTweens, pauseTweens, PropertyList, registerSpecialProperty,
      16                 :             : registerSpecialPropertyModifier, registerSpecialPropertySplitter,
      17                 :             : removeAllTweens, removeTweens, restrictedWords, resumeAllTweens, resumeTweens,
      18                 :             : setFrameTicker, setTimeScale */
      19                 :             : 
      20                 :             : /*
      21                 :             :  http://code.google.com/p/tweener/
      22                 :             :  http://code.google.com/p/tweener/wiki/License
      23                 :             :  */
      24                 :             : 
      25                 :           1 : const GLib = imports.gi.GLib;
      26                 :             : 
      27                 :           1 : const TweenList = imports.tweener.tweenList;
      28                 :           1 : const Signals = imports.signals;
      29                 :             : 
      30                 :           1 : var _inited = false;
      31                 :           1 : var _engineExists = false;
      32                 :           1 : var _tweenList = null;
      33                 :             : 
      34                 :           1 : var _timeScale = 1;
      35                 :             : 
      36                 :           1 : var _specialPropertyList = [];
      37                 :           1 : var _specialPropertyModifierList = [];
      38                 :           1 : var _specialPropertySplitterList = [];
      39                 :             : 
      40                 :             : /*
      41                 :             :  * Ticker should implement:
      42                 :             :  *
      43                 :             :  * property FRAME_RATE
      44                 :             :  * start()
      45                 :             :  * stop()
      46                 :             :  * getTime() gets time in milliseconds from start()
      47                 :             :  * signal prepare-frame
      48                 :             :  *
      49                 :             :  */
      50                 :           1 : var _ticker = null;
      51                 :             : 
      52                 :           1 : var _prepareFrameId = 0;
      53                 :             : 
      54                 :             : /* default frame ticker */
      55                 :           1 : function FrameTicker() {
      56                 :           1 :     this._init();
      57                 :             : }
      58                 :             : 
      59                 :           1 : FrameTicker.prototype = {
      60                 :           1 :     FRAME_RATE: 65,
      61                 :             : 
      62                 :           1 :     _init() {
      63                 :             :     },
      64                 :             : 
      65                 :           1 :     start() {
      66                 :           0 :         this._currentTime = 0;
      67                 :             : 
      68                 :           0 :         let me = this;
      69                 :             : 
      70                 :           0 :         this._timeoutID = GLib.timeout_add(
      71                 :           0 :             GLib.PRIORITY_DEFAULT,
      72                 :           0 :             Math.floor(1000 / me.FRAME_RATE),
      73                 :           0 :             function () {
      74                 :           0 :                 me._currentTime += 1000 / me.FRAME_RATE;
      75                 :           0 :                 me.emit('prepare-frame');
      76                 :           0 :                 return true;
      77                 :             :             });
      78                 :             :     },
      79                 :             : 
      80                 :           1 :     stop() {
      81         [ #  # ]:           0 :         if ('_timeoutID' in this) {
      82                 :           0 :             GLib.source_remove(this._timeoutID);
      83                 :           0 :             delete this._timeoutID;
      84                 :             :         }
      85                 :             : 
      86                 :           0 :         this._currentTime = 0;
      87                 :             :     },
      88                 :             : 
      89                 :           1 :     getTime() {
      90                 :           0 :         return this._currentTime;
      91                 :             :     },
      92                 :             : };
      93                 :           1 : Signals.addSignalMethods(FrameTicker.prototype);
      94                 :             : 
      95                 :           1 : _ticker = new FrameTicker();
      96                 :             : 
      97                 :             : /* TODOs:
      98                 :             :  *
      99                 :             :  * Special properties:
     100                 :             :  *
     101                 :             :  * Special properties are 'proxy' properties used in Tweener to tween
     102                 :             :  * (animate) things that are not proper properties per se. One example
     103                 :             :  * given is the 'frame' of an object in ActionScript, which is not an
     104                 :             :  * object property. Using the special property '_frame' you could animate
     105                 :             :  * it like this:
     106                 :             :  *
     107                 :             :  * Tweener.addTween(myMovieClip, {_frame:20, time:1});
     108                 :             :  *
     109                 :             :  * which would be equivalent to applying a fast-forward to it.
     110                 :             :  *
     111                 :             :  * This properties need a special support in the code, and I've removed it
     112                 :             :  * for now until we see the need for it in our clutter based stuff.
     113                 :             :  */
     114                 :             : 
     115                 :             : /* This is a bit pointless now, but let's keep it anyway... */
     116                 :          52 : function _init() {
     117         [ +  - ]:           1 :     if (_inited)
     118                 :           0 :         return;
     119                 :             : 
     120                 :           1 :     _inited = true;
     121                 :             : }
     122                 :             : 
     123                 :           1 : function setFrameTicker(ticker) {
     124                 :           1 :     _ticker = ticker;
     125                 :             : }
     126                 :             : 
     127                 :           2 : function _startEngine() {
     128         [ +  - ]:           2 :     if (_engineExists)
     129                 :           0 :         return;
     130                 :             : 
     131                 :           2 :     _engineExists = true;
     132                 :           2 :     _tweenList = [];
     133                 :             : 
     134         [ +  - ]:           2 :     if (!_ticker)
     135                 :           0 :         throw new Error('Must call setFrameTicker()');
     136                 :             : 
     137                 :           4 :     _prepareFrameId = _ticker.connect('prepare-frame',
     138                 :           2 :         _onEnterFrame);
     139                 :           2 :     _ticker.start();
     140                 :             : }
     141                 :             : 
     142                 :           1 : function _stopEngine() {
     143         [ +  - ]:           1 :     if (!_engineExists)
     144                 :           0 :         return;
     145                 :             : 
     146                 :           1 :     _engineExists = false;
     147                 :           1 :     _tweenList = false;
     148                 :             : 
     149                 :           1 :     _ticker.disconnect(_prepareFrameId);
     150                 :           1 :     _prepareFrameId = 0;
     151                 :           1 :     _ticker.stop();
     152                 :             : }
     153                 :             : 
     154                 :         471 : function _getCurrentTweeningTime() {
     155                 :         471 :     return _ticker.getTime();
     156                 :             : }
     157                 :             : 
     158                 :          73 : function _removeTweenByIndex(i) {
     159                 :          73 :     _tweenList[i] = null;
     160                 :             : 
     161                 :          73 :     var finalRemoval = arguments[1];
     162                 :             : 
     163 [ +  + ][ +  + ]:          73 :     if (finalRemoval != undefined && finalRemoval)
     164                 :          32 :         _tweenList.splice(i, 1);
     165                 :             : 
     166                 :          73 :     return true;
     167                 :             : }
     168                 :             : 
     169                 :           4 : function _resumeTweenByIndex(i) {
     170                 :           4 :     var tweening = _tweenList[i];
     171                 :             : 
     172 [ -  + ][ +  - ]:           4 :     if (tweening == null || !tweening.isPaused)
     173                 :           0 :         return false;
     174                 :             : 
     175                 :           4 :     var currentTime = _getCurrentTweeningTime(tweening);
     176                 :             : 
     177                 :           4 :     tweening.timeStart += currentTime - tweening.timePaused;
     178                 :           4 :     tweening.timeComplete += currentTime - tweening.timePaused;
     179                 :           4 :     tweening.timePaused = undefined;
     180                 :           4 :     tweening.isPaused = false;
     181                 :             : 
     182                 :           4 :     return true;
     183                 :             : }
     184                 :             : 
     185                 :             : /* FIXME: any way to get the function name from the fn itself? */
     186                 :         466 : function _callOnFunction(fn, fnname, scope, fallbackScope, params) {
     187         [ +  + ]:         466 :     if (fn) {
     188         [ +  - ]:          75 :         var eventScope = scope ? scope : fallbackScope;
     189                 :          75 :         try {
     190                 :          75 :             fn.apply(eventScope, params);
     191                 :           0 :         } catch (e) {
     192                 :           0 :             logError(e, `Error calling ${fnname}`);
     193                 :             :         }
     194                 :             :     }
     195                 :             : }
     196                 :             : 
     197                 :         472 : function _updateTweenByIndex(i) {
     198                 :         472 :     var tweening = _tweenList[i];
     199                 :             : 
     200 [ +  + ][ +  + ]:         472 :     if (tweening == null || !tweening.scope)
     201                 :           9 :         return false;
     202                 :             : 
     203                 :         463 :     var currentTime = _getCurrentTweeningTime(tweening);
     204                 :             : 
     205         [ +  + ]:         463 :     if (currentTime < tweening.timeStart)
     206                 :          52 :         return true; // Hasn't started, so return true
     207                 :             : 
     208                 :         411 :     var scope = tweening.scope;
     209                 :             :     var t, b, c, d, nv;
     210                 :             : 
     211                 :         411 :     var isOver = false;
     212                 :             : 
     213         [ +  + ]:         411 :     if (tweening.isCaller) {
     214                 :           5 :         do {
     215                 :          14 :             t = (tweening.timeComplete - tweening.timeStart) / tweening.count *
     216                 :          14 :                 (tweening.timesCalled + 1);
     217                 :          14 :             b = tweening.timeStart;
     218                 :          14 :             c = tweening.timeComplete - tweening.timeStart;
     219                 :          14 :             d = tweening.timeComplete - tweening.timeStart;
     220                 :          14 :             nv = tweening.transition(t, b, c, d);
     221                 :             : 
     222         [ +  + ]:          14 :             if (currentTime >= nv) {
     223                 :          20 :                 _callOnFunction(tweening.onUpdate, 'onUpdate', tweening.onUpdateScope,
     224                 :          10 :                     scope, tweening.onUpdateParams);
     225                 :             : 
     226                 :          10 :                 tweening.timesCalled++;
     227         [ +  + ]:          10 :                 if (tweening.timesCalled >= tweening.count) {
     228                 :           1 :                     isOver = true;
     229                 :             :                     break;
     230                 :             :                 }
     231                 :             : 
     232         [ +  - ]:           9 :                 if (tweening.waitFrames)
     233                 :             :                     break;
     234                 :             :             }
     235         [ +  + ]:          13 :         } while (currentTime >= nv);
     236                 :             :     } else {
     237                 :             :         var mustUpdate, name;
     238                 :             : 
     239         [ +  + ]:         406 :         if (currentTime >= tweening.timeComplete) {
     240                 :          22 :             isOver = true;
     241                 :          22 :             mustUpdate = true;
     242                 :             :         } else {
     243         [ -  + ]:         384 :             mustUpdate = tweening.skipUpdates < 1 ||
     244         [ +  - ]:         384 :                 !tweening.skipUpdates ||
     245                 :           0 :                 tweening.updatesSkipped >= tweening.skipUpdates;
     246                 :             :         }
     247                 :             : 
     248         [ +  + ]:         406 :         if (!tweening.hasStarted) {
     249                 :          48 :             _callOnFunction(tweening.onStart, 'onStart', tweening.onStartScope,
     250                 :          24 :                 scope, tweening.onStartParams);
     251                 :             : 
     252         [ +  + ]:          59 :             for (name in tweening.properties) {
     253                 :             :                 var pv;
     254                 :             : 
     255         [ +  + ]:          35 :                 if (tweening.properties[name].isSpecialProperty) {
     256                 :             :                     // It's a special property, tunnel via the special property function
     257         [ +  - ]:           1 :                     if (_specialPropertyList[name].preProcess != undefined)
     258                 :           0 :                         tweening.properties[name].valueComplete = _specialPropertyList[name].preProcess(scope, _specialPropertyList[name].parameters, tweening.properties[name].originalValueComplete, tweening.properties[name].extra);
     259                 :           1 :                     pv = _specialPropertyList[name].getValue(scope, _specialPropertyList[name].parameters, tweening.properties[name].extra);
     260                 :             :                 } else {
     261                 :             :                     // Directly read property
     262                 :          34 :                     pv = scope[name];
     263                 :             :                 }
     264         [ +  - ]:          35 :                 tweening.properties[name].valueStart = isNaN(pv) ? tweening.properties[name].valueComplete : pv;
     265                 :             :             }
     266                 :             : 
     267                 :          24 :             mustUpdate = true;
     268                 :          24 :             tweening.hasStarted = true;
     269                 :             :         }
     270                 :             : 
     271         [ -  + ]:         406 :         if (mustUpdate) {
     272         [ +  + ]:        1166 :             for (name in tweening.properties) {
     273                 :         760 :                 var property = tweening.properties[name];
     274                 :             : 
     275         [ +  + ]:         760 :                 if (isOver) {
     276                 :             :                     // Tweening time has finished, just set it to the final value
     277                 :          33 :                     nv = property.valueComplete;
     278         [ +  + ]:         727 :                 } else if (property.hasModifier) {
     279                 :             :                     // Modified
     280                 :          49 :                     t = currentTime - tweening.timeStart;
     281                 :          49 :                     d = tweening.timeComplete - tweening.timeStart;
     282                 :          49 :                     nv = tweening.transition(t, 0, 1, d, tweening.transitionParams);
     283                 :          49 :                     nv = property.modifierFunction(property.valueStart, property.valueComplete, nv, property.modifierParameters);
     284                 :             :                 } else {
     285                 :             :                     // Normal update
     286                 :         678 :                     t = currentTime - tweening.timeStart;
     287                 :         678 :                     b = property.valueStart;
     288                 :         678 :                     c = property.valueComplete - property.valueStart;
     289                 :         678 :                     d = tweening.timeComplete - tweening.timeStart;
     290                 :         678 :                     nv = tweening.transition(t, b, c, d, tweening.transitionParams);
     291                 :             :                 }
     292                 :             : 
     293         [ +  - ]:         760 :                 if (tweening.rounded)
     294                 :           0 :                     nv = Math.round(nv);
     295                 :             : 
     296 [ +  + ][ +  + ]:         760 :                 if (tweening.min !== undefined && nv < tweening.min)
     297                 :          50 :                     nv = tweening.min;
     298 [ +  + ][ +  + ]:         760 :                 if (tweening.max !== undefined && nv > tweening.max)
     299                 :          16 :                     nv = tweening.max;
     300                 :             : 
     301         [ +  + ]:         760 :                 if (property.isSpecialProperty) {
     302                 :             :                     // It's a special property, tunnel via the special property method
     303                 :          50 :                     _specialPropertyList[name].setValue(scope, nv, _specialPropertyList[name].parameters, tweening.properties[name].extra);
     304                 :             :                 } else {
     305                 :             :                     // Directly set property
     306                 :         710 :                     scope[name] = nv;
     307                 :             :                 }
     308                 :             :             }
     309                 :             : 
     310                 :         406 :             tweening.updatesSkipped = 0;
     311                 :             : 
     312                 :         812 :             _callOnFunction(tweening.onUpdate, 'onUpdate', tweening.onUpdateScope,
     313                 :         406 :                 scope, tweening.onUpdateParams);
     314                 :             :         } else {
     315                 :           0 :             tweening.updatesSkipped++;
     316                 :             :         }
     317                 :             :     }
     318                 :             : 
     319         [ +  + ]:         411 :     if (isOver) {
     320                 :          46 :         _callOnFunction(tweening.onComplete, 'onComplete', tweening.onCompleteScope,
     321                 :          23 :             scope, tweening.onCompleteParams);
     322                 :             :     }
     323                 :             : 
     324                 :         411 :     return !isOver;
     325                 :             : }
     326                 :             : 
     327                 :         308 : function _updateTweens() {
     328         [ +  + ]:         308 :     if (_tweenList.length == 0)
     329                 :           1 :         return false;
     330                 :             : 
     331         [ +  + ]:         803 :     for (let i = 0; i < _tweenList.length; i++) {
     332 [ +  + ][ +  + ]:         496 :         if (_tweenList[i] == undefined || !_tweenList[i].isPaused) {
     333         [ +  + ]:         471 :             if (!_updateTweenByIndex(i))
     334                 :          31 :                 _removeTweenByIndex(i);
     335                 :             : 
     336         [ +  + ]:         471 :             if (_tweenList[i] == null) {
     337                 :          32 :                 _removeTweenByIndex(i, true);
     338                 :          32 :                 i--;
     339                 :             :             }
     340                 :             :         }
     341                 :             :     }
     342                 :             : 
     343                 :         307 :     return true;
     344                 :             : }
     345                 :             : 
     346                 :             : /* Ran once every 'frame'. It's the main engine, updates all existing tweenings */
     347                 :         308 : function _onEnterFrame() {
     348         [ +  + ]:         308 :     if (!_updateTweens())
     349                 :           1 :         _stopEngine();
     350                 :             : 
     351                 :         308 :     return true;
     352                 :             : }
     353                 :             : 
     354                 :           1 : var restrictedWords = {
     355                 :           1 :     time: true,
     356                 :           1 :     delay: true,
     357                 :           1 :     userFrames: true,
     358                 :           1 :     skipUpdates: true,
     359                 :           1 :     transition: true,
     360                 :           1 :     transitionParams: true,
     361                 :           1 :     onStart: true,
     362                 :           1 :     onUpdate: true,
     363                 :           1 :     onComplete: true,
     364                 :           1 :     onOverwrite: true,
     365                 :           1 :     onError: true,
     366                 :           1 :     rounded: true,
     367                 :           1 :     min: true,
     368                 :           1 :     max: true,
     369                 :           1 :     onStartParams: true,
     370                 :           1 :     onUpdateParams: true,
     371                 :           1 :     onCompleteParams: true,
     372                 :           1 :     onOverwriteParams: true,
     373                 :           1 :     onStartScope: true,
     374                 :           1 :     onUpdateScope: true,
     375                 :           1 :     onCompleteScope: true,
     376                 :           1 :     onOverwriteScope: true,
     377                 :           1 :     onErrorScope: true,
     378                 :             : };
     379                 :             : 
     380                 :          32 : function _constructPropertyList(obj) {
     381                 :          32 :     var properties = {};
     382                 :          32 :     var modifiedProperties = {};
     383                 :             : 
     384         [ +  + ]:         144 :     for (let istr in obj) {
     385         [ +  + ]:         112 :         if (restrictedWords[istr])
     386                 :             :             continue;
     387                 :             : 
     388         [ +  + ]:          50 :         if (_specialPropertySplitterList[istr] != undefined) {
     389                 :             :             // Special property splitter
     390                 :           1 :             var splitProperties = _specialPropertySplitterList[istr].splitValues(obj[istr], _specialPropertySplitterList[istr].parameters);
     391         [ +  + ]:           3 :             for (let i = 0; i < splitProperties.length; i++) {
     392         [ +  - ]:           2 :                 if (_specialPropertySplitterList[splitProperties[i].name] != undefined) {
     393                 :           0 :                     var splitProperties2 = _specialPropertySplitterList[splitProperties[i].name].splitValues(splitProperties[i].value, _specialPropertySplitterList[splitProperties[i].name].parameters);
     394         [ #  # ]:           0 :                     for (let j = 0; j < splitProperties2.length; j++) {
     395                 :           0 :                         properties[splitProperties2[j].name] = {
     396                 :           0 :                             valueStart: undefined,
     397                 :           0 :                             valueComplete: splitProperties2[j].value,
     398                 :           0 :                             arrayIndex: splitProperties2[j].arrayIndex,
     399                 :           0 :                             isSpecialProperty: false,
     400                 :             :                         };
     401                 :             :                     }
     402                 :             :                 } else {
     403                 :           2 :                     properties[splitProperties[i].name] = {
     404                 :           2 :                         valueStart: undefined,
     405                 :           2 :                         valueComplete: splitProperties[i].value,
     406                 :           2 :                         arrayIndex: splitProperties[i].arrayIndex,
     407                 :           2 :                         isSpecialProperty: false,
     408                 :             :                     };
     409                 :             :                 }
     410                 :             :             }
     411         [ +  + ]:          49 :         } else if (_specialPropertyModifierList[istr] != undefined) {
     412                 :             :             // Special property modifier
     413                 :           1 :             let tempModifiedProperties = _specialPropertyModifierList[istr].modifyValues(obj[istr]);
     414         [ +  + ]:           2 :             for (let i = 0; i < tempModifiedProperties.length; i++) {
     415                 :           1 :                 modifiedProperties[tempModifiedProperties[i].name] = {
     416                 :           1 :                     modifierParameters: tempModifiedProperties[i].parameters,
     417                 :           1 :                     modifierFunction: _specialPropertyModifierList[istr].getValue,
     418                 :             :                 };
     419                 :             :             }
     420                 :             :         } else {
     421                 :          48 :             properties[istr] = {
     422                 :          48 :                 valueStart: undefined,
     423                 :          48 :                 valueComplete: obj[istr],
     424                 :             :             };
     425                 :             :         }
     426                 :             :     }
     427                 :             : 
     428                 :             :     // Adds the modifiers to the list of properties
     429         [ +  + ]:          33 :     for (let istr in modifiedProperties) {
     430         [ -  + ]:           1 :         if (properties[istr]) {
     431                 :           1 :             properties[istr].modifierParameters = modifiedProperties[istr].modifierParameters;
     432                 :           1 :             properties[istr].modifierFunction = modifiedProperties[istr].modifierFunction;
     433                 :             :         }
     434                 :             :     }
     435                 :             : 
     436                 :          32 :     return properties;
     437                 :             : }
     438                 :             : 
     439                 :          50 : function PropertyInfo(valueStart, valueComplete, originalValueComplete,
     440                 :             :     arrayIndex, extra, isSpecialProperty,
     441                 :             :     modifierFunction, modifierParameters) {
     442                 :         100 :     this._init(valueStart, valueComplete, originalValueComplete,
     443                 :          50 :         arrayIndex, extra, isSpecialProperty,
     444                 :          50 :         modifierFunction, modifierParameters);
     445                 :             : }
     446                 :             : 
     447                 :           1 : PropertyInfo.prototype = {
     448                 :           1 :     _init(valueStart, valueComplete, originalValueComplete,
     449                 :             :         arrayIndex, extra, isSpecialProperty,
     450                 :             :         modifierFunction, modifierParameters) {
     451                 :          50 :         this.valueStart             =       valueStart;
     452                 :          50 :         this.valueComplete          =       valueComplete;
     453                 :          50 :         this.originalValueComplete  =       originalValueComplete;
     454                 :          50 :         this.arrayIndex             =       arrayIndex;
     455                 :          50 :         this.extra                  =       extra;
     456                 :          50 :         this.isSpecialProperty      =       isSpecialProperty;
     457                 :          50 :         this.hasModifier            =       Boolean(modifierFunction);
     458                 :          50 :         this.modifierFunction       =       modifierFunction;
     459                 :          50 :         this.modifierParameters     =       modifierParameters;
     460                 :             :     },
     461                 :             : };
     462                 :             : 
     463                 :          33 : function _addTweenOrCaller(target, tweeningParameters, isCaller) {
     464         [ +  - ]:          33 :     if (!target)
     465                 :           0 :         return false;
     466                 :             : 
     467                 :             :     var scopes; // List of objects to tween
     468         [ +  - ]:          33 :     if (Array.isArray(target)) {
     469                 :             :         // The first argument is an array
     470                 :           0 :         scopes = target.concat(); // XXX: To copy the array I guess
     471                 :             :     } else {
     472                 :             :         // The first argument(s) is(are) object(s)
     473                 :          33 :         scopes = new Array(target);
     474                 :             :     }
     475                 :             : 
     476                 :             :     var obj, istr;
     477                 :             : 
     478         [ +  + ]:          33 :     if (isCaller) {
     479                 :           1 :         obj = tweeningParameters;
     480                 :             :     } else {
     481                 :          32 :         obj = TweenList.makePropertiesChain(tweeningParameters);
     482                 :             : 
     483                 :          32 :         var properties = _constructPropertyList(obj);
     484                 :             : 
     485                 :             :         // Verifies whether the properties exist or not, for warning messages
     486         [ +  + ]:          82 :         for (istr in properties) {
     487         [ +  + ]:          50 :             if (_specialPropertyList[istr] != undefined) {
     488                 :           1 :                 properties[istr].isSpecialProperty = true;
     489                 :             :             } else {
     490         [ +  + ]:          98 :                 for (var i = 0; i < scopes.length; i++) {
     491         [ +  - ]:          49 :                     if (scopes[i][istr] == undefined) {
     492                 :           0 :                         log(`The property ${istr} doesn't seem to be a ` +
     493                 :           0 :                             `normal object property of ${scopes[i]} or a ` +
     494                 :           0 :                             'registered special property');
     495                 :             :                     }
     496                 :             :                 }
     497                 :             :             }
     498                 :             :         }
     499                 :             :     }
     500                 :             : 
     501                 :             :     // Creates the main engine if it isn't active
     502         [ +  + ]:          33 :     if (!_inited)
     503                 :           1 :         _init();
     504         [ +  + ]:          33 :     if (!_engineExists)
     505                 :           2 :         _startEngine();
     506                 :             : 
     507                 :             :     // Creates a "safer", more strict tweening object
     508         [ +  + ]:          33 :     var time = obj.time || 0;
     509         [ +  + ]:          33 :     var delay = obj.delay || 0;
     510                 :             : 
     511                 :             :     var transition;
     512                 :             : 
     513                 :             :     // FIXME: Tweener allows you to use functions with an all lower-case name
     514         [ +  + ]:          33 :     if (typeof obj.transition == 'string')
     515                 :           7 :         transition = imports.tweener.equations[obj.transition];
     516                 :             :     else
     517                 :          26 :         transition = obj.transition;
     518                 :             : 
     519         [ +  + ]:          33 :     if (!transition)
     520                 :          26 :         transition = imports.tweener.equations['easeOutExpo'];
     521                 :             : 
     522                 :             :     var tween;
     523                 :             : 
     524         [ +  + ]:          66 :     for (let i = 0; i < scopes.length; i++) {
     525         [ +  + ]:          33 :         if (!isCaller) {
     526                 :             :             // Make a copy of the properties
     527                 :          32 :             var copyProperties = {};
     528         [ +  + ]:          82 :             for (istr in properties) {
     529                 :         100 :                 copyProperties[istr] = new PropertyInfo(properties[istr].valueStart,
     530                 :          50 :                     properties[istr].valueComplete,
     531                 :          50 :                     properties[istr].valueComplete,
     532         [ -  + ]:          50 :                     properties[istr].arrayIndex || 0,
     533                 :          50 :                     {},
     534         [ +  + ]:          50 :                     properties[istr].isSpecialProperty || false,
     535         [ +  + ]:          50 :                     properties[istr].modifierFunction || null,
     536         [ -  + ]:          50 :                     properties[istr].modifierParameters || null);
     537                 :             :             }
     538                 :             :         }
     539                 :             : 
     540                 :          66 :         tween = new TweenList.TweenList(scopes[i],
     541                 :          33 :             _ticker.getTime() + delay * 1000 / _timeScale,
     542                 :          33 :             _ticker.getTime() + (delay * 1000 + time * 1000) / _timeScale,
     543                 :          33 :             false,
     544                 :          33 :             transition,
     545         [ -  + ]:          33 :             obj.transitionParams || null);
     546                 :             : 
     547         [ +  + ]:          33 :         tween.properties               =       isCaller ? null : copyProperties;
     548                 :          33 :         tween.onStart                  =       obj.onStart;
     549                 :          33 :         tween.onUpdate                 =       obj.onUpdate;
     550                 :          33 :         tween.onComplete               =       obj.onComplete;
     551                 :          33 :         tween.onOverwrite              =       obj.onOverwrite;
     552                 :          33 :         tween.onError                  =       obj.onError;
     553                 :          33 :         tween.onStartParams            =       obj.onStartParams;
     554                 :          33 :         tween.onUpdateParams           =       obj.onUpdateParams;
     555                 :          33 :         tween.onCompleteParams         =       obj.onCompleteParams;
     556                 :          33 :         tween.onOverwriteParams        =       obj.onOverwriteParams;
     557                 :          33 :         tween.onStartScope             =       obj.onStartScope;
     558                 :          33 :         tween.onUpdateScope            =       obj.onUpdateScope;
     559                 :          33 :         tween.onCompleteScope          =       obj.onCompleteScope;
     560                 :          33 :         tween.onOverwriteScope         =       obj.onOverwriteScope;
     561                 :          33 :         tween.onErrorScope             =       obj.onErrorScope;
     562                 :          33 :         tween.rounded                  =       obj.rounded;
     563                 :          33 :         tween.min                      =       obj.min;
     564                 :          33 :         tween.max                      =       obj.max;
     565                 :          33 :         tween.skipUpdates              =       obj.skipUpdates;
     566                 :          33 :         tween.isCaller                 =       isCaller;
     567                 :             : 
     568         [ +  + ]:          33 :         if (isCaller) {
     569                 :           1 :             tween.count = obj.count;
     570                 :           1 :             tween.waitFrames = obj.waitFrames;
     571                 :             :         }
     572                 :             : 
     573         [ +  + ]:          33 :         if (!isCaller) {
     574                 :             :             // Remove other tweenings that occur at the same time
     575                 :          32 :             removeTweensByTime(tween.scope, tween.properties, tween.timeStart, tween.timeComplete);
     576                 :             :         }
     577                 :             : 
     578                 :             :         // And finally adds it to the list
     579                 :          33 :         _tweenList.push(tween);
     580                 :             : 
     581                 :             :         // Immediate update and removal if it's an immediate tween
     582                 :             :         // If not deleted, it executes at the end of this frame execution
     583 [ +  + ][ +  + ]:          33 :         if (time == 0 && delay == 0) {
     584                 :           1 :             var myT = _tweenList.length - 1;
     585                 :           1 :             _updateTweenByIndex(myT);
     586                 :           1 :             _removeTweenByIndex(myT);
     587                 :             :         }
     588                 :             :     }
     589                 :             : 
     590                 :          33 :     return true;
     591                 :             : }
     592                 :             : 
     593                 :          32 : function addTween(target, tweeningParameters) {
     594                 :          32 :     return _addTweenOrCaller(target, tweeningParameters, false);
     595                 :             : }
     596                 :             : 
     597                 :           1 : function addCaller(target, tweeningParameters) {
     598                 :           1 :     return _addTweenOrCaller(target, tweeningParameters, true);
     599                 :             : }
     600                 :             : 
     601                 :          21 : function _getNumberOfProperties(object) {
     602                 :          21 :     var totalProperties = 0;
     603                 :             : 
     604                 :             :     // the following line is disabled because eslint was picking up the following error: the variable name is defined but never used, however since it is required to search the object it is used and we'll allow the line to be ignored to get rid of the error message
     605                 :             :     /* eslint-disable-next-line */
     606         [ +  + ]:          39 :     for (let name in object) {
     607                 :          18 :         totalProperties++;
     608                 :             :     }
     609                 :             : 
     610                 :             : 
     611                 :          21 :     return totalProperties;
     612                 :             : }
     613                 :             : 
     614                 :          32 : function removeTweensByTime(scope, properties, timeStart, timeComplete) {
     615                 :          32 :     var removed = false;
     616                 :             :     var removedLocally;
     617                 :             :     var name;
     618                 :             : 
     619         [ +  + ]:          77 :     for (let i = 0; i < _tweenList.length; i++) {
     620                 :          45 :         removedLocally = false;
     621                 :             : 
     622         [ +  + ]:          45 :         if (_tweenList[i] &&
     623         [ +  + ]:          42 :             scope == _tweenList[i].scope &&
     624         [ -  + ]:          13 :             timeComplete > _tweenList[i].timeStart &&
     625         [ +  + ]:          13 :             timeStart < _tweenList[i].timeComplete) {
     626         [ +  + ]:          30 :             for (name in _tweenList[i].properties) {
     627         [ +  + ]:          18 :                 if (properties[name]) {
     628         [ +  + ]:           9 :                     if (!removedLocally) {
     629                 :           6 :                         _callOnFunction(_tweenList[i].onOverwrite, 'onOverwrite', _tweenList[i].onOverwriteScope,
     630                 :           3 :                             _tweenList[i].scope, _tweenList[i].onOverwriteParams);
     631                 :             :                     }
     632                 :             : 
     633                 :           9 :                     _tweenList[i].properties[name] = undefined;
     634                 :           9 :                     delete _tweenList[i].properties[name];
     635                 :           9 :                     removedLocally = true;
     636                 :           9 :                     removed = true;
     637                 :             :                 }
     638                 :             :             }
     639                 :             : 
     640         [ +  + ]:          12 :             if (removedLocally &&
     641         [ +  + ]:           3 :                 _getNumberOfProperties(_tweenList[i].properties) == 0)
     642                 :           3 :                 _removeTweenByIndex(i);
     643                 :             :         }
     644                 :             :     }
     645                 :             : 
     646                 :          32 :     return removed;
     647                 :             : }
     648                 :             : 
     649                 :           5 : function _pauseTweenByIndex(i) {
     650                 :           5 :     var tweening = _tweenList[i];
     651                 :             : 
     652 [ -  + ][ +  + ]:           5 :     if (tweening == null || tweening.isPaused)
     653                 :           1 :         return false;
     654                 :             : 
     655                 :           4 :     tweening.timePaused = _getCurrentTweeningTime(tweening);
     656                 :           4 :     tweening.isPaused = true;
     657                 :             : 
     658                 :           4 :     return true;
     659                 :             : }
     660                 :             : 
     661                 :           0 : function _splitTweens(tween, properties) {
     662                 :           0 :     var originalTween = _tweenList[tween];
     663                 :           0 :     var newTween = originalTween.clone();
     664                 :             :     var name;
     665                 :             : 
     666         [ #  # ]:           0 :     for (let i = 0; i < properties.length; i++) {
     667                 :           0 :         name = properties[i];
     668         [ #  # ]:           0 :         if (originalTween.properties[name]) {
     669                 :           0 :             originalTween.properties[name] = undefined;
     670                 :           0 :             delete originalTween.properties[name];
     671                 :             :         }
     672                 :             :     }
     673                 :             : 
     674                 :           0 :     var found = false;
     675         [ #  # ]:           0 :     for (name in newTween.properties) {
     676                 :           0 :         found = false;
     677         [ #  # ]:           0 :         for (let i = 0; i < properties.length; i++) {
     678         [ #  # ]:           0 :             if (properties[i] == name) {
     679                 :           0 :                 found = true;
     680                 :             :                 break;
     681                 :             :             }
     682                 :             :         }
     683                 :             : 
     684         [ #  # ]:           0 :         if (!found) {
     685                 :           0 :             newTween.properties[name] = undefined;
     686                 :           0 :             delete newTween.properties[name];
     687                 :             :         }
     688                 :             :     }
     689                 :             : 
     690                 :           0 :     _tweenList.push(newTween);
     691                 :           0 :     return _tweenList.length - 1;
     692                 :             : }
     693                 :             : 
     694                 :           6 : function _affectTweens(affectFunction, scope, properties) {
     695                 :           6 :     var affected = false;
     696                 :             : 
     697         [ +  - ]:           6 :     if (!_tweenList)
     698                 :           0 :         return false;
     699                 :             : 
     700         [ +  + ]:          31 :     for (let i = 0; i < _tweenList.length; i++) {
     701 [ -  + ][ +  + ]:          25 :         if (!_tweenList[i] || _tweenList[i].scope != scope)
     702                 :             :             continue;
     703                 :             : 
     704         [ +  + ]:          11 :         if (properties.length == 0) {
     705                 :             :             // Can check everything
     706                 :           1 :             affectFunction(i);
     707                 :           1 :             affected = true;
     708                 :             :         } else {
     709                 :             :             // Must check whether this tween must have specific properties affected
     710                 :          10 :             var affectedProperties = [];
     711         [ +  + ]:          27 :             for (let j = 0; j < properties.length; j++) {
     712         [ +  + ]:          17 :                 if (_tweenList[i].properties[properties[j]])
     713                 :           6 :                     affectedProperties.push(properties[j]);
     714                 :             :             }
     715                 :             : 
     716         [ +  + ]:          10 :             if (affectedProperties.length > 0) {
     717                 :           6 :                 var objectProperties = _getNumberOfProperties(_tweenList[i].properties);
     718         [ -  + ]:           6 :                 if (objectProperties == affectedProperties.length) {
     719                 :             :                     // The list of properties is the same as all properties, so affect it all
     720                 :           6 :                     affectFunction(i);
     721                 :           6 :                     affected = true;
     722                 :             :                 } else {
     723                 :             :                     // The properties are mixed, so split the tween and affect only certain specific
     724                 :             :                     // properties
     725                 :           0 :                     var splicedTweenIndex = _splitTweens(i, affectedProperties);
     726                 :           0 :                     affectFunction(splicedTweenIndex);
     727                 :           0 :                     affected = true;
     728                 :             :                 }
     729                 :             :             }
     730                 :             :         }
     731                 :             :     }
     732                 :             : 
     733                 :           6 :     return affected;
     734                 :             : }
     735                 :             : 
     736                 :           7 : function _isInArray(string, array) {
     737                 :           7 :     var l = array.length;
     738                 :             : 
     739         [ +  + ]:           9 :     for (let i = 0; i < l; i++) {
     740         [ +  - ]:           2 :         if (array[i] == string)
     741                 :           0 :             return true;
     742                 :             :     }
     743                 :             : 
     744                 :           7 :     return false;
     745                 :           0 : }
     746                 :             : 
     747                 :           6 : function _affectTweensWithFunction(func, args) {
     748                 :           6 :     var properties = [];
     749                 :           6 :     var scope = args[0];
     750                 :           6 :     var affected = false;
     751                 :             :     var scopes;
     752                 :             : 
     753         [ +  - ]:           6 :     if (Array.isArray(scope))
     754                 :           0 :         scopes = scope.concat();
     755                 :             :     else
     756                 :           6 :         scopes = new Array(scope);
     757                 :             : 
     758         [ +  + ]:          13 :     for (let i = 1; args[i] != undefined; i++) {
     759 [ -  + ][ -  + ]:           7 :         if (typeof args[i] == 'string' && !_isInArray(args[i], properties)) {
     760         [ +  - ]:           7 :             if (_specialPropertySplitterList[args[i]]) {
     761                 :             :                 // special property, get splitter array first
     762                 :           0 :                 var sps = _specialPropertySplitterList[arguments[i]];
     763                 :           0 :                 var specialProps = sps.splitValues(scope, null);
     764         [ #  # ]:           0 :                 for (let j = 0; j < specialProps.length; j++)
     765                 :           0 :                     properties.push(specialProps[j].name);
     766                 :             :             } else {
     767                 :           7 :                 properties.push(args[i]);
     768                 :             :             }
     769                 :             :         }
     770                 :             :     }
     771                 :             : 
     772                 :             :     // the return now value means: "affect at least one tween"
     773         [ +  + ]:          12 :     for (let i = 0; i < scopes.length; i++)
     774         [ -  + ]:           6 :         affected = affected || _affectTweens(func, scopes[i], properties);
     775                 :             : 
     776                 :           6 :     return affected;
     777                 :             : }
     778                 :             : 
     779                 :           1 : function resumeTweens() {
     780                 :           1 :     return _affectTweensWithFunction(_resumeTweenByIndex, arguments);
     781                 :             : }
     782                 :             : 
     783                 :           3 : function pauseTweens() {
     784                 :           3 :     return _affectTweensWithFunction(_pauseTweenByIndex, arguments);
     785                 :             : }
     786                 :             : 
     787                 :           2 : function removeTweens() {
     788                 :           2 :     return _affectTweensWithFunction(_removeTweenByIndex, arguments);
     789                 :             : }
     790                 :             : 
     791                 :           3 : function _mapOverTweens(func) {
     792                 :           3 :     var rv = false;
     793                 :             : 
     794         [ +  - ]:           3 :     if (_tweenList == null)
     795                 :           0 :         return false;
     796                 :             : 
     797         [ +  + ]:          11 :     for (let i = 0; i < _tweenList.length; i++) {
     798         [ +  + ]:           8 :         if (func(i))
     799                 :           7 :             rv = true;
     800                 :             :     }
     801                 :             : 
     802                 :           3 :     return rv;
     803                 :             : }
     804                 :             : 
     805                 :           1 : function pauseAllTweens() {
     806                 :           1 :     return _mapOverTweens(_pauseTweenByIndex);
     807                 :             : }
     808                 :             : 
     809                 :           1 : function resumeAllTweens() {
     810                 :           1 :     return _mapOverTweens(_resumeTweenByIndex);
     811                 :             : }
     812                 :             : 
     813                 :           1 : function removeAllTweens() {
     814                 :           1 :     return _mapOverTweens(_removeTweenByIndex);
     815                 :             : }
     816                 :             : 
     817                 :           6 : function getTweenCount(scope) {
     818         [ +  - ]:           6 :     if (!_tweenList)
     819                 :           0 :         return 0;
     820                 :             : 
     821                 :           6 :     var c = 0;
     822                 :             : 
     823         [ +  + ]:          20 :     for (let i = 0; i < _tweenList.length; i++) {
     824 [ +  + ][ +  + ]:          14 :         if (_tweenList[i] && _tweenList[i].scope == scope)
     825                 :          12 :             c += _getNumberOfProperties(_tweenList[i].properties);
     826                 :             :     }
     827                 :             : 
     828                 :           6 :     return c;
     829                 :             : }
     830                 :             : 
     831                 :           1 : function registerSpecialProperty(name, getFunction, setFunction,
     832                 :             :     parameters, preProcessFunction) {
     833                 :           1 :     _specialPropertyList[name] = {
     834                 :           1 :         getValue: getFunction,
     835                 :           1 :         setValue: setFunction,
     836                 :           1 :         parameters,
     837                 :           1 :         preProcess: preProcessFunction,
     838                 :             :     };
     839                 :             : }
     840                 :             : 
     841                 :           1 : function registerSpecialPropertyModifier(name, modifyFunction, getFunction) {
     842                 :           1 :     _specialPropertyModifierList[name] = {
     843                 :           1 :         modifyValues: modifyFunction,
     844                 :           1 :         getValue: getFunction,
     845                 :             :     };
     846                 :             : }
     847                 :             : 
     848                 :           1 : function registerSpecialPropertySplitter(name, splitFunction, parameters) {
     849                 :           1 :     _specialPropertySplitterList[name] = {
     850                 :           1 :         splitValues: splitFunction,
     851                 :           1 :         parameters,
     852                 :             :     };
     853                 :             : }
     854                 :             : 
     855                 :           0 : function setTimeScale(scale) {
     856                 :           0 :     _timeScale = scale;
     857                 :             : }
     858                 :             : 
     859                 :           0 : function getTimeScale() {
     860                 :           0 :     return _timeScale;
     861                 :             : }
        

Generated by: LCOV version 2.0-1