package org.ntlab.animations;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.geom.Dimension2D;
import java.awt.geom.Point2D;
import java.util.TimerTask;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import org.ntlab.deltaViewer.DeltaGraphAdapter;
import org.ntlab.deltaViewer.MagnetRONScheduledThreadPoolExecutor;
import com.mxgraph.model.mxICell;
import com.mxgraph.swing.mxGraphComponent;
/**
*
*
* @author Nitta Lab.
*/
public abstract class MagnetRONAnimation {
// Test code (will be deleted)
private static final String TAG = MagnetRONAnimation.class.getSimpleName();
protected DeltaGraphAdapter mxgraph;
protected mxGraphComponent mxgraphComponent;
protected ThreadPoolExecutor threadPoolExecutor;
protected ScheduledFuture<?> scheduledFuture;
/**
* Initial delays the start of an animation.
*
* Cannot be negative. Setting to a negative number will result in {@link IllegalArgumentException}.
*
* @defaultValue 0ms
*/
private long initialDelay;
private static final long DEFAULT_INITIAL_DELAY = 0L;
/**
* Delays the interval between repeating an animation.
*
* Cannot be negative. Setting to a negative number will result in {@link IllegalArgumentException}.
*
* @defaultValue 0ms
*/
private long delay;
private static final long DEFAULT_DELAY = 0L;
/**
* Defines the direction/speed at which the {@code MagnetRONAnimation} is expected to
* be played.
* <p>
* The absolute value of {@code rate} indicates the speed which the
* {@code Animation} is to be played, while the sign of {@code rate}
* indicates the direction. A positive value of {@code rate} indicates
* forward play, a negative value indicates backward play and {@code 0.0} to
* stop a running {@code MagnetRONAnimation}.
* <p>
* Rate {@code 1.0} is normal play, {@code 2.0} is 2 time normal,
* {@code -1.0} is backwards, etc...
*
* <p>
* Inverting the rate of a running {@code MagnetRONAnimation} will cause the
* {@code MagnetRONAnimation} to reverse direction in place and play back over the
* portion of the {@code MagnetRONAnimation} that has already elapsed.
*
* @defaultValue 1.0
*/
private double rate;
private static final double DEFAULT_RATE = 1.0;
/**
* Read-only variable to indicate current direction/speed at which the
* {@code MagnetRONAnimation} is being played.
* <p>
* {@code currentRate} is not necessary equal to {@code rate}.
* {@code currentRate} is set to {@code 0.0} when animation is paused or
* stopped. {@code currentRate} may also point to different direction during
* reverse cycles when {@code reverse} is {@code true}
*
* @defaultValue 0.0
*/
private double currentRate;
private static final double DEFAULT_CURRENT_RATE = 0.0;
/**
* Defines the number of cycles in this animation. The {@code totalCycleCount}
* may be {@code INDEFINITE} for animations that repeat indefinitely, but
* must otherwise be > 0.
* <p>
* It is not possible to change the {@code totalCycleCount} of a running
* {@code MagnetRONAnimation}. If the value of {@code totalCycleCount} is changed for a
* running {@code MagnetRONAnimation}, the animation has to be stopped and started again to pick
* up the new value.
*
* @defaultValue 1
*
*/
private int totalCycleCount;
private static final int DEFAULT_TOTAL_CYCLE_COUNT = 1;
/**
* The current number of cycles in this animation.
*
* @defaultValu 0
*/
private int currentCycleCount = 0;
/**
* Used to specify an animation that repeats indefinitely, until the
* {@code stop()} method is called.
*/
private static final int INDEFINITE = -1;
/**
* The status of the {@code MagnetRONAnimation}.
*
* In {@code MagnetRONAnimation} can be in one of three states:
* {@link Status#STOPPED}, {@link Status#PAUSED} or {@link Status#RUNNING}.
*/
private Status currentStatus;
private static final Status DEFAULT_STATUS = Status.STOPPED;
/**
* The action to be executed at the conclusion of this {@code MagnetRONAnimation}.
*/
private ActionListener onFinished;
/**
* Defines whether this
* {@code MagnetRONAnimation} reverses direction on alternating cycles. If
* {@code true}, the
* {@code MagnetRONAnimation} will proceed reverses on the cycle.
* Otherwise, animation will loop such that each cycle proceeds forward from the start.
*
* It is not possible to change the {@code reverse} flag of a running
* {@code MagnetRONAnimation}. If the value of {@code reverse} is changed for a
* running {@code MagnetRONAnimation}, the animation has to be stopped and started again to pick
* up the new value.
*
* @defaultValue false
*/
private boolean reverse;
private static final boolean DEFAULT_REVERSE = false;
/**
* The object to animate.
*/
private mxICell sourceCell;
/**
* The initial point of sourceCell.
*/
private Point2D sourceInitPoint;
/**
* The initial size of sourceCell.
*/
private Dimension2D sourceInitDimension;
/**
* The possible state for MagnetRONAnimation.
*/
protected static enum Status {
/**
* The paused state.
*/
PAUSED,
/**
* The running state.
*/
RUNNING,
/**
* The stopped state.
*/
STOPPED
}
/**
* The constructor of {@code MagnetRONAnimation}.
*
* @param mxgraph: visualization model
* @param mxgraphComponent: visualization model group
*/
protected MagnetRONAnimation(DeltaGraphAdapter mxgraph, mxGraphComponent mxgraphComponent) {
this.mxgraph = mxgraph;
this.mxgraphComponent = mxgraphComponent;
}
protected void setThreadPoolExecutor(ThreadPoolExecutor threadPoolExecutor) {
this.threadPoolExecutor = threadPoolExecutor;
}
public void setInitialDelay(long initialDelay) {
this.initialDelay = initialDelay;
}
public void setDelay(long delay) {
this.delay = delay;
}
protected void setRate(double rate) {
this.rate = rate;
}
protected void setCurrentRate(double currentRate) {
this.currentRate = currentRate;
}
public void setTotalCycleCount(int totalCycleCount) {
this.totalCycleCount = totalCycleCount;
}
protected void setCurrentCycleCount(int currentCycleCount) {
this.currentCycleCount = currentCycleCount;
}
protected void setCurrentStatus(Status currentStatus) {
this.currentStatus = currentStatus;
}
public void setOnFinished(ActionListener onFinished) {
this.onFinished = onFinished;
}
public void setReverse(boolean reverse) {
this.reverse = reverse;
}
protected void setSourceCell(mxICell sourceCell) {
this.sourceCell = sourceCell;
}
protected void setSourceInitialPoint(Point2D sourceInitPoint) {
this.sourceInitPoint = sourceInitPoint;
}
protected void setSourceInitialDimension(Dimension2D sourceInitDimension) {
this.sourceInitDimension = sourceInitDimension;
}
protected void setScheduledFuture(ScheduledFuture<?> scheduledFuture) {
this.scheduledFuture = scheduledFuture;
}
protected abstract void setDestination(double x, double y);
protected abstract void setVelocity(double x, double y);
protected ThreadPoolExecutor getThreadPoolExecutor() {
return threadPoolExecutor;
}
public long getInitialDelay() {
if (initialDelay == 0L) return DEFAULT_INITIAL_DELAY;
return initialDelay;
}
public long getDelay() {
if (delay == 0L) return DEFAULT_DELAY;
return delay;
}
protected double getRate() {
if (rate == 0.0) return DEFAULT_RATE;
return rate;
}
protected double getCurrentRate() {
if (currentRate == 0.0) return DEFAULT_CURRENT_RATE;
return currentRate;
}
public int getTotalCycleCount() {
if (totalCycleCount == 0) return DEFAULT_TOTAL_CYCLE_COUNT;
return totalCycleCount;
}
protected int getCurrentCycleCount() {
return currentCycleCount;
}
protected Status getCurrentStatus() {
if (currentStatus == null) return DEFAULT_STATUS;
return currentStatus;
}
public ActionListener getOnFinished() {
return onFinished;
}
public boolean getReverse() {
if (!reverse) return DEFAULT_REVERSE;
return reverse;
}
protected mxICell getSourceCell() {
return sourceCell;
}
protected Point2D getSourceInitialPoint() {
return sourceInitPoint;
}
protected Dimension2D getSourceInitialDimension() {
return sourceInitDimension;
}
protected ScheduledFuture<?> getScheduledFuture() {
return scheduledFuture;
}
/**
* Set expand or reduction animation of edge to targetPoint.
* Must be call {@code MagnetRONAnimation#init(mxICell, mxPoint, ThreadPoolExecutor)} before calling {@code MagnetRONAnimation#play()}.
*
* @param sourceCell: edge object
* @param destinationPoint
*/
public void init(mxICell sourceCell, double destinationX, double destinationY, ThreadPoolExecutor threadPoolExecutor) {
setSourceCell(sourceCell);
setDestination(destinationX, destinationY);
setThreadPoolExecutor(threadPoolExecutor);
setSourceInitialPoint(getSourceCell().getGeometry().getPoint());
setSourceInitialDimension(
new Dimension((int) getSourceCell().getGeometry().getWidth(),
(int) getSourceCell().getGeometry().getHeight()));
setCurrentCycleCount(0);
}
public void updateCurrentCycle(int currentCycleCount) {
if (!getReverse()) { // Animation direction is forward.
setCurrentCycleCount((int) (currentCycleCount + Math.signum(getTotalCycleCount())));
} else {
setCurrentCycleCount((int) (currentCycleCount - Math.signum(getTotalCycleCount())));
}
}
public void interpolate(double cycleCount) {
}
public void playFrom() {
}
public void play() {
switch (getCurrentStatus()) {
case STOPPED:
if (getThreadPoolExecutor() != null & getThreadPoolExecutor() instanceof ScheduledThreadPoolExecutor) {
ScheduledThreadPoolExecutor scheduledThreadPoolExecutor = (ScheduledThreadPoolExecutor) getThreadPoolExecutor();
setThreadPoolExecutor(scheduledThreadPoolExecutor);
ScheduledFuture<?> scheduledFuture = scheduledThreadPoolExecutor.scheduleWithFixedDelay(new TimerTask() {
@Override
public void run() {
if(Math.abs(getCurrentCycleCount()) < Math.abs(getTotalCycleCount())) {
// Test code (will be deleted)
System.out.println(TAG + ": Run task " + getSourceCell().getId() + " " + MagnetRONAnimation.this.getClass().getSimpleName() + "-" + getCurrentCycleCount() + ". ThreadId=" + Thread.currentThread().getId());
updateCurrentCycle(getCurrentCycleCount());
jumpTo(getCurrentCycleCount());
} else if(Math.abs(getCurrentCycleCount()) >= Math.abs(getTotalCycleCount())){
onFinished();
}
}
}, getInitialDelay(), getDelay(), TimeUnit.MILLISECONDS);
setScheduledFuture(scheduledFuture);
setCurrentStatus(Status.RUNNING);
};
break;
case PAUSED:
if (getThreadPoolExecutor() != null & getThreadPoolExecutor() instanceof MagnetRONScheduledThreadPoolExecutor) {
MagnetRONScheduledThreadPoolExecutor scheduledThreadPoolExecutor = (MagnetRONScheduledThreadPoolExecutor) getThreadPoolExecutor();
scheduledThreadPoolExecutor.resume();
setCurrentStatus(Status.RUNNING);
}
break;
default:
break;
};
}
public void syncPlay() {
if (getCurrentStatus() == Status.STOPPED) {
try {
Thread.sleep(getInitialDelay());
while (true) {
while (getCurrentStatus() == Status.PAUSED) {
Thread.sleep(1L);
}
if(Math.abs(getCurrentCycleCount()) < Math.abs(getTotalCycleCount())) {
// Test code (will be deleted)
System.out.println(TAG + ": Run task " + getSourceCell().getId() + " " + MagnetRONAnimation.this.getClass().getSimpleName() + "-" + getCurrentCycleCount() + ". ThreadId=" + Thread.currentThread().getId());
updateCurrentCycle(getCurrentCycleCount());
jumpTo(getCurrentCycleCount());
} else if(Math.abs(getCurrentCycleCount()) >= Math.abs(getTotalCycleCount())){
onFinished();
break;
}
Thread.sleep(getDelay());
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void playFormStart() {
}
public void stop() {
if (getCurrentStatus() == Status.RUNNING) {
getScheduledFuture().cancel(true);
}
setCurrentStatus(Status.STOPPED);
setCurrentRate(0.0);
}
public void pause() {
if (getCurrentStatus() == Status.RUNNING) {
if (getThreadPoolExecutor() != null && getThreadPoolExecutor() instanceof MagnetRONScheduledThreadPoolExecutor) {
MagnetRONScheduledThreadPoolExecutor scheduledThreadPoolExecutor = (MagnetRONScheduledThreadPoolExecutor) getThreadPoolExecutor();
scheduledThreadPoolExecutor.pause();
setCurrentStatus(Status.PAUSED);
}
}
}
private final void onFinished() {
stop();
final ActionListener listener = getOnFinished();
if (listener != null) {
try {
listener.actionPerformed(new ActionEvent(this, ActionEvent.ACTION_PERFORMED, null));
} catch (Exception e) {
Thread.currentThread().getUncaughtExceptionHandler().uncaughtException(Thread.currentThread(), e);
}
}
}
protected abstract void jumpTo(int currentCycleCount);
}
