Set the animation backend to forward calls to.
If called with null, the current backend will be removed.

@param animationBackend the backend to use or null to remove the current backend
968396
public void setAnimationBackend(@Nullable T animationBackend) {
    mAnimationBackend = animationBackend;
    if (mAnimationBackend != null) {
      applyBackendProperties(mAnimationBackend);
    }
  }
325794
@Override
    public void setAlpha(int alpha) {
        if (mAlpha != alpha) {
            mAlpha = alpha;
            if (mCurrDrawable != null) {
                if (mEnterAnimationEnd == 0) {
                    mCurrDrawable.setAlpha(alpha);
                } else {
                    animate(false);
                }
            }
        }
    }
680599
public AppMsg setAnimation(Animation inAnimation, Animation outAnimation) {
        mInAnimation = inAnimation;
        mOutAnimation = outAnimation;
        return this;
    }
1176533
protected void processAnimations(FragmentAnimation animation, FragmentTransaction ft) {
        if (animation != null) {
            if (animation.isCompletedAnimation()) {
                ft.setCustomAnimations(animation.getEnterAnim(), animation.getExitAnim(),
                        animation.getPushInAnim(), animation.getPopOutAnim());
            } else {
                ft.setCustomAnimations(animation.getEnterAnim(), animation.getExitAnim());
            }
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP)
                for (LollipopAnim sharedElement : animation.getSharedViews()) {
                    ft.addSharedElement(sharedElement.view, sharedElement.name);
                }
        }
    }
17568
public static <T> void setEndFrames(List<? extends Keyframe<T>> keyframes) {
    int size = keyframes.size();
    for (int i = 0; i < size - 1; i++) {
      // In the json, the keyframes only contain their starting frame.
      Keyframe<T> keyframe = keyframes.get(i);
      Keyframe<T> nextKeyframe = keyframes.get(i + 1);
      keyframe.endFrame = nextKeyframe.startFrame;
      if (keyframe.endValue == null && nextKeyframe.startValue != null) {
        keyframe.endValue = nextKeyframe.startValue;
        if (keyframe instanceof PathKeyframe) {
          ((PathKeyframe) keyframe).createPath();
        }
      }
    }
    Keyframe<?> lastKeyframe = keyframes.get(size - 1);
    if ((lastKeyframe.startValue == null || lastKeyframe.endValue == null) && keyframes.size() > 1) {
      // The only purpose the last keyframe has is to provide the end frame of the previous
      // keyframe.
      //noinspection SuspiciousMethodCalls
      keyframes.remove(lastKeyframe);
    }
  }
657035
public void updateAnimation()
  {
    Date time = new Date();
    long currentTime = time.getTime() - this.beginAnimation;
    if (currentTime > animationTime)
    {
      this.currentQuaternion.set(endQuaternion);
      for (int i = 0; i < 3; i++)
      {

        this.currentPos[i] = this.endPos[i];
      }
      this.animate = false;
    }

    else
    {
      float t = (float) currentTime / animationTime;
      this.currentQuaternion = this.beginQuaternion.slerp(this.endQuaternion,
                                                          t);
      for (int i = 0; i < 3; i++)
      {
        this.currentPos[i] = this.beginPos[i] + totalTranslation[i] * t;
      }

    }
  }
337422
public void setIcon(Drawable icon, boolean animation){
        if(icon == null)
            return;

        if(animation) {
            mSwitchIconAnimator.startAnimation(icon);
            invalidate();
        }
        else{
            if(mIcon != null){
                mIcon.setCallback(null);
                unscheduleDrawable(mIcon);
            }

            mIcon = icon;
            float half = mIconSize / 2f;
            mIcon.setBounds((int)(mBackground.getCenterX() - half), (int)(mBackground.getCenterY() - half), (int)(mBackground.getCenterX() + half), (int)(mBackground.getCenterY() + half));
            mIcon.setCallback(this);
            invalidate();
        }
	}
1279714
function ToggleAnimation (AppState) {
  var state = AppState.get()
  if (
    state.currentAnimation[0] === animationDictionary.bend[0] &&
    state.currentAnimation[1] === animationDictionary.bend[1]
  ) {
    state.currentAnimation = animationDictionary.jump
  } else {
    state.currentAnimation = animationDictionary.bend
  }

  AppState.set(state)
}
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);
          }
1209291
@Override
	public void registerAnimation(NavigationAnimation animation) {
		// boolean cancelSupport = configuration.getHintValue(MapConfiguration.ANIMATION_CANCEL_SUPPORT);
		// if (!cancelSupport && currentAnimation != null) {
		// return;
		// }

		if (currentAnimation != null) {
			currentAnimation.cancel();
		}
		this.currentAnimation = animation;

		// Schedule the animation from the moment the browser event loop returns:
		Scheduler.get().scheduleDeferred(new ScheduledCommand() {

			@Override
			public void execute() {
				if (currentAnimation != null) {
					if (Dom.isTransformationSupported()) {
						currentAnimation.run();
					} else {
						applyView(currentAnimation.getEndView());
						currentAnimation = null;
					}
				}
			}
		});
	}
1351398
private boolean shouldUseAnimations() {
        SharedPreferences sharedPreferences =
                PreferenceManager.getDefaultSharedPreferences(getActivity());
        String key = getString(R.string.animation_preference_key);
        boolean defaultValue = getResources().getBoolean(R.bool.animation_preference_default_value);
        return sharedPreferences.getBoolean(key, defaultValue);
    }
107616
public void hideWithAnimationWithListener(Animator.AnimatorListener animatorListener) {
		scrollDirection = SCROLL_TO_BOTTOM;
		ObjectAnimator objectAnimator = objectAnimatorFactory.getObjectAnimator(animatedView, ANIMATION_TYPE, animatedView.getHeight());
		if (animatorListener != null) {
			objectAnimator.addListener(animatorListener);
		}
		objectAnimator.setDuration(durationInMillis);
		objectAnimator.start();
	}
317872
public void close()
    {
        if (forwardEngine != null)
            forwardEngine.close();
        if (reverseEngine != null)
            reverseEngine.close();

        forwardEngine = null;
        reverseEngine = null;
    }
338875
function Animation(opts) {
  this.type = 'Animation'
  this.entity = null
  this.enabled = true
  this.playing = false
  this.loop = false
  this.time = 0 // seconds
  this.prevTime = Date.now() // ms
  this.channels = opts.channels || []
  this.changed = new Signal()
  this.set(opts)
}
734421
public void setSelection(int position, boolean animate) {
        // Animate only if requested position is already on screen somewhere
        boolean shouldAnimate = animate && mFirstPosition <= position &&
                position <= mFirstPosition + getChildCount() - 1;
        setSelectionInt(position, shouldAnimate);
    }
40076
@SuppressLint("NewApi")
	private void postAnimationInvalidate() {
		if (mScroller.computeScrollOffset()) {
			final int oldX = (int) mOffsetPixels;
			final int x = mScroller.getCurrX();

			if (x != oldX) {
				setOffsetPixels(x);
			}
			if (x != mScroller.getFinalX()) {
				postOnAnimation(mDragRunnable);
				return;
			}
		}

		completeAnimation();
	}
1216684
private void setAnimationParams(AnimationParams params) {
        if (params == null) {
            throw new IllegalArgumentException(
                    "params can't be null");
        }
        if (animateTimer != null) {
            animateTimer.stop();
        }
        animationParams = params;
        animateTimer = new Timer(animationParams.waitTime, animator);
        animateTimer.setInitialDelay(0);
    }