GenericItem.java

Go to the documentation of this file.

/*
 * Created on Oct 19, 2009
 *
 * TODO To change the template for this generated file go to
 * Window - Preferences - Java - Code Style - Code Templates
 */
package edu.tum.cs.ias.knowrob.vis.items;

import java.util.Vector;

import edu.tum.cs.ias.knowrob.vis.Canvas;
import edu.tum.cs.ias.knowrob.vis.Drawable;
import edu.tum.cs.ias.knowrob.vis.DrawableAnimated;
import edu.tum.cs.ias.knowrob.vis.items.transform.DrawingTransformation;

public abstract class GenericItem<T extends DrawingTransformation> implements Drawable, DrawableAnimated {
        
        protected Vector<T> animation = new Vector<T>();
        
        public GenericItem(T transform) {
                animation.add(transform);
        }
        
        public boolean isAnimated() {
                return animation.size() > 0;
        }
        
        public void draw(Canvas c) {
                draw(c, 0);
        }
        
        public void draw(Canvas c, int step) {
                T currentTransform; 
                try {
                        currentTransform = animation.get(step);
                }
                catch(ArrayIndexOutOfBoundsException e) {
                        currentTransform = animation.lastElement();
                }
                c.pushMatrix();
                currentTransform.applyTransformation(c);
                drawActualItem(c);
                c.popMatrix();
        }
        
        public int getMaxStep() {
                return animation.size()-1;
        }

        protected abstract void drawActualItem(Canvas c);       
        
        public void setFrame(int frame, T transformation) {
                setFrames(frame, frame, transformation);
        }
        
        public void setFrames(int from, int to, T transformation) {
                int lastFrame = animation.size()-1;
                if(to == -1)
                        to = Math.max(to, lastFrame);
                makeAnimated(from-1);           
                if(lastFrame < from) 
                        animation.add(transformation);
                else {
                        int resetTo = Math.min(lastFrame, to);
                        for(int i = from; i < resetTo; i++)
                                animation.set(i, transformation);
                }
                makeAnimated(to);
        }
        
        public void setFrames(int from, int to, PartialTransformationReplacer<T> ptr) {
                if(to == -1) 
                        to = Math.max(from, animation.size()-1);
                makeAnimated(to);
                
                T prev = null;
                for(int i = from; i <= to; i++) {                       
                        T newT = ptr.replace(animation.get(i));                 
                        if(prev != null && newT.equals(prev))
                                animation.set(i, prev);
                        else {
                                animation.set(i, newT);
                                prev = newT;
                        }
                }
        }
        
        public static abstract class PartialTransformationReplacer<T extends DrawingTransformation> {
                T replacement;

                public PartialTransformationReplacer(T replacement) {
                        this.replacement = replacement;
                }

                public abstract T replace(T before);
        }
        
        protected void makeAnimated(int untilFrame) {
                if(untilFrame < animation.size())
                        return;
                T transform = this.animation.lastElement();
                for(int i = animation.size()-1; i <= untilFrame; i++)
                        animation.add(transform);
        }
}