Stops the animation and skips to the next animation (if in a queue)
@param {String} animation identifier
@return {Boolean} true if the related animation exists, otherwise false
482665
function (animId) {
                var animInfo = this.animations[animId];
                if (animInfo) {
                    if (animInfo.isRunning) {
                        this._finalizeAnimation(this.animations[animId], true);
                    } else {
                        delete this.animations[animId];
                        if (animInfo.queue) {
                            var queueOrder = ariaUtilsArray.indexOf(this.queues[animInfo.queue].list, animInfo);
                            this.queues[animInfo.queue].list.splice(queueOrder, 1);
                        }
                    }
                    return true;
                }
                return false;
            }
1354161
function () {
              if (this$1._config.animation) {
                  var initConfigAnimation = this$1._config.animation || false;

                  if (getAttr(TPElement, 'x-placement') !== null) {
                      return
                  }

                  removeClass(TPElement, TP_STATE_CLASSES.FADE);
                  this$1._config.animation = false;
                  this$1.hide();
                  this$1.show();
                  this$1._config.animation = initConfigAnimation;
              }

              var prevHoverState = this$1._hoverState;
              this$1._hoverState = null;

              if (prevHoverState === TOOLTIP_HOVER_STATE_CLASSES.OUT) {
                  this$1._handleLeave(null);
              }

              var shownEvt = new CancelableEvent('shown', {
                  cancelable: false,
                  target: this$1._targetElement,
                  relatedTarget: TPElement
              });

              this$1._emitCustomEvent(shownEvt);
          }
1320670
function(next, options){
		var self = this;
		options = options || {};
		_.defaults(options, {
		// options = {
			outClass: 'pt-page-moveToLeft',
			inClass: 'pt-page-moveFromRight',

			force: false,
		});

		if(options.animation)
			_.extend(options, options.animation);

		// If we still animating, but not forcing, cancel change.
		if( this.isAnimating && !options.force)
			return false;
		this.isAnimating = true;
		
		var $currPage = this.$currentView;
		var $nextPage = (next ? this.saveView(next).addClass( 'pt-page-current' ) : null);

		if(!this.supportAnimation)
			return self.setPage($nextPage);

		this.trigger('start-animate');
		if($currPage){
			$currPage.addClass( options.outClass ).on( self.animEndEventName, function() {
				$currPage.off( self.animEndEventName );
				self.endCurrPage = true;
				checkEndAnimation();
			});
		}else{
			self.endCurrPage = true;
			checkEndAnimation();
		}

		if($nextPage){
			$nextPage.addClass( options.inClass ).on( self.animEndEventName, function() {
				$nextPage.off( self.animEndEventName );
				self.endNextPage = true;
				checkEndAnimation();
			} );
		}else{
			self.endNextPage = true;
			checkEndAnimation();
		}

		function checkEndAnimation(){
			if(self.endNextPage && self.endCurrPage)
				self.setPage($nextPage);
		}
	}
98534
public void exit(boolean withAnimation) {
        if (GestureDebug.isDebugAnimator()) {
            Log.d(TAG, "Exiting, with animation = " + withAnimation);
        }

        if (!isActivated) {
            throw new IllegalStateException("You should call enter(...) before calling exit(...)");
        }

        // Resetting 'to' position if not animating exit already
        if (!(isAnimating && position <= toPosition) && position > 0) {
            setToState(toController.getState(), position);
        }

        // Starting animation from current position or applying initial state without animation
        setState(withAnimation ? position : 0f, true, withAnimation);
    }
360119
def stop_animation(self, sprites):
        """"""
        if isinstance(sprites, list) is False:
            sprites = [sprites]

        for sprite in sprites:
            self.tweener.kill_tweens(sprite)
67156
def _finishAnimation(self):
        
        self.setCurrentIndex(self._nextIndex)
        self.widget(self._lastIndex).hide()
        self.widget(self._lastIndex).move(self._lastPoint)
        self._active = False
        
        if not self.signalsBlocked():
            self.animationFinished.emit()
1160488
function() {
    var root = this;
    var manager = root.__manager__;
    if (manager.rafID != null) {
      root.cancelAnimationFrame(manager.rafID);
    }
  }
18000
function stopTimeout(ctx) {
  assert(ctx);
  if (ctx.timer != null) {
    clearTimeout(ctx.timer);
    ctx.timer = null;
  }
  ctx.stopped = true;
}
846069
function (params, options, complete) {
		var animOptions = pick(options, globalAnimation, true);
		stop(this); // stop regardless of animation actually running, or reverting to .attr (#607)
		if (animOptions) {
			animOptions = merge(animOptions);
			if (complete) { // allows using a callback with the global animation without overwriting it
				animOptions.complete = complete;
			}
			animate(this, params, animOptions);
		} else {
			this.attr(params);
			if (complete) {
				complete();
			}
		}
	}
1057453
public void exit(boolean withAnimation) {
        if (getRequestedId() == null) {
            throw new IllegalStateException("You should call enter(...) before calling exit(...)");
        }

        if (GestureDebug.isDebugAnimator()) {
            Log.d(TAG, "Exit requested from " + getRequestedId()
                    + ", with animation = " + withAnimation);
        }

        exitRequested = true;
        exitWithAnimation = withAnimation;
        exitIfRequested();
    }
1128141
function stop() {
        logger.log('debug', 'M|stop', meta);
        var deferred = Q.defer();  // resolved by the 'exit' event
        actionQueue.add({
            "action" : "shutdown",
            "params" : {
                "forcefull" : true,
                "deferred"  : deferred
            }
        });
        return deferred.promise;
    }
776039
public static final <T extends UIObject> void stopAnimation(final T widget, final String animation){
        if (widget != null && animation != null) {
            stopAnimation(widget.getElement(), animation);
        }
    }
598679
function start () {
        var now = performance.now();

        if (typeof pausedAfter !== 'undefined') {
          startTime = now + pausedAfter;
        } else {
          startTime = now + delayMillis;
        }

        lastTime = startTime;
        pausedAfter = undefined;

        triggerEvent('start');

        startLoop(animationId, animationLoop);

        return self;
      }
1104356
function startAnimation() {
    if (isIE8) {
      return;
    }
    // stop any already running animations
    stopAnimation();
    var fnc = function () {
      addClass(CTX.box, _const_class_prefix + '-loading');
      if (!isIE9 && typeof CTX.opt.loadingAnimation === 'number') {
        var index = 0;
        animationInt = setInterval(function () {
          addClass(animationChildren[index], _const_class_prefix + '-active');
          setTimeout(function () {
            removeClass(animationChildren[index], _const_class_prefix + '-active');
          }, CTX.opt.loadingAnimation);
          index = index >= animationChildren.length ? 0 : index += 1;
        }, CTX.opt.loadingAnimation);
      }
    };
    // set timeout to not show loading animation on fast connections
    animationTimeout = setTimeout(fnc, 500);
  }
1107699
function onEnd() {
          element.off(css3AnimationEvents, onAnimationProgress);
          $$jqLite.removeClass(element, activeClassName);
          $$jqLite.removeClass(element, pendingClassName);
          if (staggerTimeout) {
            $timeout.cancel(staggerTimeout);
          }
          animateClose(element, className);
          var node = extractElementNode(element);
          for (var i in appliedStyles) {
            node.style.removeProperty(appliedStyles[i]);
          }
        }
752804
public void stop()
    {
        synchronized (mAnimQueue)
        {
            if (mIsRunning && (mAnimQueue.size() > 0))
            {
                mIsRunning = false;
                GVRAnimator animator = mAnimQueue.get(0);
                mAnimQueue.clear();
                animator.stop();
            }
        }
    }
771207
function (position, endLocation, animationInterval) {
			var currentLocation = window.pageYOffset;
			if ( position == endLocation || currentLocation == endLocation || ( (window.innerHeight + currentLocation) >= documentHeight ) ) {
				clearInterval(animationInterval);
				options.callbackAfter( toggle, anchor ); // Run callbacks after animation complete
			}
		}