ControlledAnimationTimer.java

package controllers;

import java.util.LinkedList;

import javafx.animation.AnimationTimer;
import javafx.beans.property.IntegerProperty;
import javafx.beans.property.SimpleIntegerProperty;

/**
* Extension of JavaFX's AnimationTimer. It allows the user to determine the
* number of steps to run as well as Runnable tasks to execute when the timer
* starts and stops.
*
* @author Graf
*
*/
public class ControlledAnimationTimer extends AnimationTimer{
 
 // Instance variables
 private IntegerProperty currStepProperty;
 private IntegerProperty maxStepsProperty;
 private boolean running;
 private LinkedList<Runnable> onStepTasks;
 private LinkedList<Runnable> onFinishTasks;
 private LinkedList<Runnable> onStartTasks;
 
 /**
 * Constructor.
 * @param max The max number of steps to run the timer for.
 */
 public ControlledAnimationTimer(int max) {
 currStepProperty = new SimpleIntegerProperty();
 maxStepsProperty = new SimpleIntegerProperty(max);
 onFinishTasks = new LinkedList<>();
 onStartTasks = new LinkedList<>();
 onStepTasks = new LinkedList<>();
 }
 
 /**
 * Add a task to run before the timer starts.
 * @param r Runnable task to execute.
 */
 public void addOnStartTask(Runnable r) {
 if (r != null) {
 onStartTasks.add(r);
 }
 }
 
 /**
 * Add a task to run after the timer stops.
 * @param r Runnable task to execute.
 */
 public void addOnFinishTask(Runnable r) {
 if (r != null) {
 onFinishTasks.add(r);
 }
 }
 
 /**
 * Add a task to run each step of the timer.
 * @param r Runnable task to execute.
 */
 public void addOnStepTask(Runnable r) {
 if (r != null) {
 onStepTasks.add(r);
 }
 }
 
 /**
 * Removes a task from the list of tasks that run after the timer finishes.
 * @param r The task to remove from the list.
 * @return True if a task was removed.
 */
 public boolean removeOnFinishTask(Runnable r) {
 return onFinishTasks.remove(r);
 }
 
 /**
 * Removes a task from the list of tasks that run before the timer starts.
 * @param r The task to remove from the list.
 * @return True if a task was removed.
 */
 public boolean removeOnStartTask(Runnable r) {
 return onStartTasks.remove(r);
 }
 
 /**
 * Removes a task from the list of tasks that run as the timer steps.
 * @param r The task to remove from the list.
 * @return True if a task was removed.
 */
 public boolean removeOnStepTask(Runnable r) {
 return onStepTasks.remove(r);
 }
 
 /**
 * Change the number of steps the timer will run for.
 * @param max The desired number of steps.
 */
 public void setMaxSteps(int max) {
 maxStepsProperty.setValue(max);
 reset();
 }
 
 /**
 * Determines if Timer is currently running.
 * @return True if Timer is running.
 */
 public boolean isRunning() {
 return running;
 }
 
 /**
 * Getter for maximum steps.
 * @return Maximum number of steps.
 */
 public int getMaxSteps() {
 return maxStepsProperty.intValue();
 }
 
 /**
 * Getter for current step.
 * @return Reference to current step IntegerProperty.
 */
 public IntegerProperty CurrStepProperty() {
 return currStepProperty;
 }
 
 /**
 * Getter for maximum number of steps.
 * @return Reference to maximum steps IntegerProperty.
 */
 public IntegerProperty MaxStepsProperty() {
 return maxStepsProperty;
 }
 
 @Override
 public void handle(long now) {

 if (currStepProperty.intValue() 
 < maxStepsProperty.intValue()) {
 for (Runnable r : onStepTasks) {
 r.run();
 }
 currStepProperty.set(currStepProperty.intValue() + 1);;
 } else {
 stop();
 }
 }

 @Override
 public void start() {
 reset();
 running = true;
 
 // Run any on start tasks.
 for (Runnable task : onStartTasks) {
 task.run();
 }
 super.start();
 }
 
 @Override
 public void stop() {
 super.stop();
 running = false;
 
 // Run any on finish tasks.
 for (Runnable task : onFinishTasks) {
 task.run();
 }
 }
 
 // Reset the counter property.
 private void reset() {
 currStepProperty.set(0);
 }
}