Immediately cancel this animation. If the animation is running or is scheduled to run, {@link #onCancel()} will be called.

void cancel() {
 // Ignore if the animation is not currently running.
 if (!running) {
   return;
 }

 // Reset the state.
 wasStarted = isStarted; // Used by onCancel.
 element = null;
 running = false;
 isStarted = false;

 // Cancel the animation request.
 if (requestHandle != null) {
   requestHandle.cancel();
   requestHandle = null;
 }

 onCancel();
}

Interpolate the linear progress into a more natural easing function.

Depending on the {@link Animation}, the return value of this method can be less than 0.0 or greater than 1.0.

@param progress the linear progress, between 0.0 and 1.0 @return the interpolated progress

double interpolate(double progress) {
 return (1 + dart_math.cos(dart_math.PI + progress * dart_math.PI)) / 2;
}

Check if the specified run ID is still being run.

@param curRunId the current run ID to check @return true if running, false if canceled or restarted

bool isRunning(int curRunId) {
 return running && (runId == curRunId);
}

Called immediately after the animation is canceled. The default implementation of this method calls {@link #onComplete()} only if the animation has actually started running.

void onCancel() {
 if (wasStarted) {
   onComplete();
 }
}

Run this animation at the given startTime. If the startTime has already passed, the animation will run synchronously as if it started at the specified start time. If the animation is already running, it will be canceled first. <p> If the element is not <code>null</code>, the {@link #onUpdate(double)} method might be called only if the element may be visible (generally left at the appreciation of the browser). Otherwise, it will be called unconditionally.

@param duration the duration of the animation in milliseconds @param startTime the synchronized start time in milliseconds @param element the element that visually bounds the entire animation

void run(int duration, {int startTime:null, dart_html.Element element:null}) {
 // Cancel the animation if it is running
 cancel();

 if (startTime == null) {
   startTime = (new DateTime.now()).millisecondsSinceEpoch;
 }

 // Save the duration and startTime
 running = true;
 isStarted = false;
 this.duration = duration;
 this.startTime = startTime;
 this.element = element;
 ++runId;

 // Execute the first callback.
 callback.execute((new DateTime.now()).millisecondsSinceEpoch);
}

Update the {@link Animation}.

@param curTime the current time @return true if the animation should run again, false if it is complete

bool update(int curTime) {
 /*
  * Save the run id. If the runId is incremented during this execution block,
  * we know that this run has been canceled.
  */
 int curRunId = runId;

 bool finished = curTime >= startTime + duration;
 if (isStarted && !finished) {
   // Animation is in progress.
   double progress = (curTime - startTime) / duration;
   onUpdate(interpolate(progress));
   return isRunning(curRunId); // Check if this run was canceled.
 }
 if (!isStarted && curTime >= startTime) {
   /*
    * Start the animation. We do not call onUpdate() because onStart() calls
    * onUpdate() by default.
    */
   isStarted = true;
   onStart();
   if (!isRunning(curRunId)) {
     // This run was canceled.
     return false;
   }
   // Intentional fall through to possibly end the animation.
 }
 if (finished) {
   // Animation is complete.
   running = false;
   isStarted = false;
   onComplete();
   return false;
 }
 return true;
}