* * The object restores all values changed in the given nodes, however, if the object * is never allowed to finish, the restoring of values becomes impossible. On any exception occuring * elsewhere, the object may not restore the conditions correctly.
*
* @author Corey Sanders
* @version 1.3 9/15/01
*/
public class SearchBSTAnimation extends AbstractAnimation {
private static int X_MOVE_VALUE = 20;
private static int Y_MOVE_VALUE = 5;
/**
* Constant that defines the starting location.
*/
private final int START = 0;
/**
* Constant the defines the final moving location.
*/
private int FINAL_MOVE;
/**
* Constant the defines the end location.
*/
private int END;
/**
* Color Scheme used for the animation on left, using one of the NodeSettings Schemes.
*/
private NodeSettings animationSchemeLeft;
/**
* Color Scheme used for the animation on right, using one of the NodeSettings Schemes.
*/
private NodeSettings animationSchemeRight;
/**
* Color Scheme used for the animator, using one of the NodeSettings Schemes.
*/
private NodeSettings animatorScheme;
/**
* Color Scheme used for the key of the animator, using one of the KeySettings Schemes.
*/
private KeySettings keyAnimatorScheme;
/**
* Private doubles used to hold the current and previous location steps.
*/
private double currentLocation = 0.0;
private double previousLocation = 0.0;
/**
* Refers to the list of AffineTransforms used to emphasize each given node.
*/
private AffineTransformList enlargeTransforms;
/**
* Refers to the list of AffineTransforms used to emphasize each given node.
*/
private AffineTransformList keySearchTransforms;
/**
* Refers to the linked list which will store the node of each step, used to draw the
* pass of each node.
*/
private LinkedList nodes;
/**
* Holds the node that is doing the drawing.
*/
private Comparable keySearch;
/**
* Counts the amount of comparisons made.
*/
private int comparisonCount = 0;
/**
* Counts the initial insertion size of the tree.
*/
private int searchingSize = 0;
/**
* Node made for the search through the tree.
*/
private BSTTree keySearchNode;
/**
* Boolean flag to signal a search discovery.
*/
private boolean searchHit = false;
/**
* The current node being compared to for the search.
*/
private BSTTree currentNode;
/**
* The Default step conversion used in animation (300).
*/
public final static int DEFAULT_CONVERSION = 300;
/**
* The constructor which initiates the status and prepares the colorSchemes. The node
* which is animating must be passed.
*
* @param keySearch the object key being searched for with the tree.
* @param headNode the head of the tree being searched.
* @param AnimationSchemeLeft the NodeSettings associated with a color scheme according to NodeSettings for the left Animation.
* @param AnimationSchemeRight the NodeSettings associated with a color scheme according to NodeSettings for the right Animation.
* @param KeyAnimatorScheme the KeySettings associated with a color scheme according to KeySettings.
* @param startingCmd the Animation command that this should start.
* @param stepTime the time for each step of the Animation. Sets the initial value.
*/
public SearchBSTAnimation(Comparable keySearch, BSTTreeHead headNode, NodeSettings AnimationSchemeLeft, NodeSettings AnimationSchemeRight, NodeSettings AnimatorScheme, KeySettings KeyAnimatorScheme, String startingCmd, int stepTime) {
super();
// Set defaults if no color schemes exist
if (AnimationSchemeLeft == null) {
AnimationSchemeLeft = new NodeSettings();
}
if (AnimationSchemeRight == null) {
AnimationSchemeRight = new NodeSettings();
}
if (AnimatorScheme == null) {
AnimatorScheme = new NodeSettings();
}
if (KeyAnimatorScheme == null) {
KeyAnimatorScheme = new KeySettings();
}
// init enlargeTransforms
enlargeTransforms = new AffineTransformList();
// init searchTransforms
keySearchTransforms = new AffineTransformList();
// init nodes
nodes = new LinkedList();
// Set Key search Node
setKeySearchNode(new BSTTree(BSTTree.ANIMATING_BST_TREE_TYPE));
getKeySearchNode().setNode(keySearch, new DrawingKey(keySearch));
// Set searching insertion size.
searchingSize = headNode.size();
// Set Animation Schemes
setAnimationSchemeLeft((NodeSettings)AnimationSchemeLeft.clone());
setAnimationSchemeRight((NodeSettings)AnimationSchemeRight.clone());
setAnimatorScheme((NodeSettings)AnimatorScheme.clone());
setKeyAnimatorScheme((KeySettings)KeyAnimatorScheme.clone());
// Set the drawing node.
setKeySearch(keySearch);
setStartingCommand(startingCmd);
setStepTime(stepTime);
}
/**
* The constructor which initiates the status and sets the color schemes to null. All colors
* are set to default for this animation. The key which is being searched for must be
* passed.
*
* @param keySearch the object key being searched for with the tree.
* @param headNode the head of the tree being searched.
*/
public SearchBSTAnimation(Comparable keySearch, BSTTreeHead headNode) {
this(keySearch, headNode, null, null, null , null , Animation.PLAY, DEFAULT_STEP);
}
/************************/
/* Accessor methods */
/************************/
/**
* Gets whether a search hit has been found.
*
* @return true if a search hit was found.
*/
public boolean isSearchHit() {
return searchHit;
}
/**
* Gets the comparable object being searched for.
*
* @return comparable object being searched for.
*/
public Comparable getKeySearch() {
return keySearch;
}
/**
* Gets the node currently being drawn during the Search.
*
* @return BSTTree of the key currently being search for.
*/
private BSTTree getKeySearchNode() {
return keySearchNode;
}
/**
* Gets the NodeSettings for the left animation scheme for the search.
*
* @return NodeSettings for the node after the animated node passes it to the left.
*/
public NodeSettings getAnimationSchemeLeft() {
return animationSchemeLeft;
}
/**
* Gets the NodeSettings for the right animation scheme for the search.
*
* @return NodeSettings for the node after the animated node passes it to the right.
*/
public NodeSettings getAnimationSchemeRight() {
return animationSchemeRight;
}
/**
* Gets the NodeSettings for the animator scheme for the search.
*
* @return NodeSettings for the node animating.
*/
public NodeSettings getAnimatorScheme() {
return animatorScheme;
}
/**
* Sets the KeySettings for the animator scheme key for the search.
*
* @return KeySettings for the key of the node animating.
*/
public KeySettings getKeyAnimatorScheme() {
return keyAnimatorScheme;
}
/************************/
/* Mutator methods */
/************************/
/**
* Sets true if a search hit is found.
*/
private void setSearchHit(boolean hit) {
searchHit = hit;
}
/**
* Sets the comparable object being searched for.
*
* @param keySearch comparable object being searched for.
*/
private void setKeySearch(Comparable key) {
keySearch = key;
}
/**
* Gets the node currently being drawn during the Search.
*
* @return BSTTree of the key currently being search for.
*/
private void setKeySearchNode(BSTTree node) {
keySearchNode = node;
}
/**
* Sets the NodeSettings for the left animation scheme for the insertion. The settings affect
* the change the node makes after the inserted node passes it to the left.
*
* @param scheme NodeSettings for the node after the animated node passes it to the left.
*/
public void setAnimationSchemeLeft(NodeSettings scheme) {
animationSchemeLeft = scheme;
}
/**
* Sets the NodeSettings for the right animation scheme for the insertion. The settings affect
* the change the node makes after the inserted node passes it to the right.
*
* @param scheme NodeSettings for the node after the animated node passes it to the right.
*/
public void setAnimationSchemeRight(NodeSettings scheme) {
animationSchemeRight = scheme;
}
/**
* Sets the NodeSettings for the animator scheme for the insertion. The settings affect
* the change the node makes as it is animating during the insertion
*
* @param scheme NodeSettings for the node animating.
*/
public void setAnimatorScheme(NodeSettings scheme) {
animatorScheme = scheme;
}
/**
* Sets the KeySettings for the animator scheme key for the insertion. The settings affect
* the change the key of the node makes as it is animating during the insertion
*
* @param scheme KeySettings for the key of the node animating.
*/
public void setKeyAnimatorScheme(KeySettings scheme) {
keyAnimatorScheme = scheme;
}
/****************************/
/* Insert Animation methods */
/****************************/
/**
* Add a step to the Search Animation. The step is added with only a BSTTree.When the step is performed, the search will transform
* the node passed (Color Scheme only). The nodes are automatically added as listeners.
*
* @param node the color scheme is changed when the step is completed.
*/
public void add(BSTTree node) {
nodes.add(node);
node.addAnimator(this);
this.addAnimationListener(node);
}
/*********************/
/* Animation methods */
/*********************/
/**
* Draws the animation of the next step, using the status of the animation (Animation.PLAY, Animation.PAUSE and so forth).
* After completing the drawing, the Animation sends an AnimationEvent to all its listeners, indicating
* any information that the listerners may wish to use.
*
* @param g2 the graphics to which the animation step should be drawn.
* @param startingStatus the status used as the starting command of animation, if needed.
*/
public void drawAnimation(Graphics2D g2, String startingStatus) {
setStartingCommand(startingStatus);
// BEGIN status
if (getStatus().equals(Animation.BEGIN)) {
currentLocation = 0;
previousLocation = 0;
if (nodes.isEmpty()) {
setStatus(Animation.FINISH);
}
else {
currentNode = (BSTTree)nodes.getFirst();
// Set transforms list
AffineTransform currentTransform = currentNode.getCurrentTransform();
AffineTransform enlargeTransform = (AffineTransform)currentTransform.clone();
enlargeTransform.scale(1.05, 1.05);
AffineTransform translateTransform = (AffineTransform)enlargeTransform.clone();
// Make initial enlarge transforms list.
enlargeTransforms.add(currentTransform);
enlargeTransforms.add(enlargeTransform);
enlargeTransforms.add(currentTransform);
// Make initial keySearch transforms list.
keySearchTransforms.add(AffineTransform.getScaleInstance(90.0, 70.0));
keySearchTransforms.add((AffineTransform)enlargeTransforms.get(1));
// Left
if((currentNode.getKey()).compareTo(getKeySearch()) > 0) {
translateTransform.translate(-X_MOVE_VALUE/enlargeTransform.getScaleX(), Y_MOVE_VALUE/(2*enlargeTransform.getScaleY()));
}
// Right
if((currentNode.getKey()).compareTo(getKeySearch()) < 0) {
translateTransform.translate(X_MOVE_VALUE/enlargeTransform.getScaleX(), Y_MOVE_VALUE/(2*enlargeTransform.getScaleY()));
}
keySearchTransforms.add(translateTransform);
getKeySearchNode().setSettings(getAnimatorScheme());
((DrawingKey)getKeySearchNode().getValue()).setSettings(getKeyAnimatorScheme());
getKeySearchNode().setCurrentTransform(AffineTransform.getScaleInstance(90.0, 70.0));
animationAction();
// Original message
messageAction(Animation.BEGIN + " Search for "+getKeySearch().toString());
// set starting status
setStatus(getStartingCommand());
// Draw all nodes
int size= nodes.size();
for(int i=0; ianimationEventPerformed method is called.
*
* @param cmd String Animation command passed instead of the current Status.
* @param description String description for messages.
*/
protected void animationAction(String cmd, String description) {
super.animationAction(AnimationEvent.SEARCH_BST_ANIMATION, cmd, description, currentLocation / (double)nodes.size());
}
}