/*
 * AnimatedSlider
 * 
 * Version 1.1 - Java 1.1 compatible
 *
 * Dec 6 2001
 * 
 * Copyright 2001 David Joiner and the Shodor Education Foundation
 */
import java.awt.*;
import java.awt.event.*;


/**
 * The AnimatedSlider class provides a slider which is capable of
 * running itself via animation buttons. It posts events as
 * an Adjustable object. It can be treated either like a
 * traditional scollbar by using the integer value, max, min,
 * and visible amount variables, or as a real value input
 * device.
 */
public class AnimatedSlider extends BufferCanvas implements MouseListener,MouseMotionListener,Runnable,Adjustable {

    public final static int STYLE_LINEAR=0;
    public final static int STYLE_LOG=1;
    
    protected double realMin;
    protected double realMax;
    protected double realValue;
    protected int sliderStyle;

    protected boolean leftAnimButtonPressed = false;
    protected boolean leftButtonPressed = false;
    protected boolean sliderMarkerPressed = false;
    protected int sliderMarkerAnchor;
    protected boolean rightButtonPressed = false;
    protected boolean rightAnimButtonPressed = false;
    protected boolean pauseButtonDisplayed = false;
    protected boolean stillGoing = false;
    
    protected boolean reverseAnimDirection = false;
    protected Thread isAnimating = null;
    
    protected int sliderValue;
    protected int sliderMin;
    protected int sliderMax;
    protected int sliderWidth;
    protected int sliderUnit;
    
    private int buttonWidth;
    private int leftAnimButtonPos;
    private int leftButtonPos;
    private int sliderPos;
    private int rightButtonPos;
    private int rightAnimButtonPos;
    private int arrowHOffset;
    private int arrowWidth;
    private int height;
    private int sliderOffset;
    private int sliderLeftSide;
    private int sliderRightSide;
    private int markerPos;
    private int markerWidth;
    
    private AdjustmentListener adjustmentListener;
    
    /*
     * Constructors
     */

    public AnimatedSlider(int sliderMin, int sliderMax,
            int sliderWidth, int sliderValue,
            int sliderStyle,
            double realValue, double realMin, double realMax) {
        super();
        addMouseListener(this);
        addMouseMotionListener(this);
        setValue(sliderValue);
        setMinimum(sliderMin);
        setMaximum(sliderMax);
        setSliderWidth(sliderWidth);
        this.realMax = realMax;
        this.realMin = realMin;
        this.realValue = realValue;
        this.sliderStyle = sliderStyle;
        setUnitIncrement(1);
    }
    
    public AnimatedSlider () {
        this(0,110,10,0);
    }
    
    public AnimatedSlider(int sliderMin, int sliderMax,
            int sliderWidth, int sliderValue) {
        this(sliderMin, sliderMax, sliderWidth, sliderValue,
            STYLE_LINEAR, (double)sliderValue, (double) sliderMin,
            (double)(sliderMax - sliderWidth));
    }
    
    public AnimatedSlider(int sliderStyle, double realValue,
            double realMin, double realMax) {
        this(0,110,10,0,sliderStyle,realValue,realMin,realMax);
    }
    
    public AnimatedSlider(double realValue,
            double realMin, double realMax) {
        this(0,110,10,0,STYLE_LINEAR,realValue, realMin, realMax);
    }
    
    /*
     * Runnable routines
     */

    
    public void run() {
        while(isAnimating != null) {
            try {
                isAnimating.sleep(75);
                if (!buttonPressed()&&stillGoing) {
                    boolean noWall = false;
                    if (reverseAnimDirection) {
                        if (sliderValue > 0) {
                            setValue(Math.max(sliderValue-sliderUnit,sliderMin));
                            noWall = true;
                            postSliderChanged();
                        }
                    } else {
                        if (sliderValue<sliderMax-sliderWidth) {
                            setValue(Math.min(sliderValue+sliderUnit,sliderMax-sliderWidth));
                            noWall = true;
                            postSliderChanged();
                        }
                    }
                    if (!noWall) {
                        pauseButtonDisplayed = false;
                        stillGoing=false;
                    }
                    repaintBuffer();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        pauseButtonDisplayed = false;
        stillGoing=false;
        //stop();
    }
    public void start() {
        stillGoing = true;
        if (isAnimating == null) {
            isAnimating = new Thread(this);
            isAnimating.start();
        }
    }
    public void stop() {
        if (isAnimating != null) {
            isAnimating.stop();
            isAnimating = null;
        }
        stillGoing = false;
    }
    
    /*
     * Set and Get methods
     */
    

    public void setMinimum(int sliderMin){
        this.sliderMin = sliderMin;
    }
    public void setMaximum(int sliderMax){
        this.sliderMax = sliderMax;
    }
    public void setSliderWidth(int sliderWidth){
        this.sliderWidth = sliderWidth;
    }
    public void setBlockIncrement(int sliderWidth) {
        setSliderWidth(sliderWidth);
    }
    public int getBlockIncrement() {
        return getSliderWidth();
    }
    public void setVisibleAmount(int sliderWidth) {
        setSliderWidth(sliderWidth);
    }
    public int getVisibleAmount() {
        return getSliderWidth();
    }
    
    
    public int getOrientation() { return 0;}
    
    public int getValue() {
        return sliderValue;
    }
    public int getMaximum() {
        return sliderMax;
    }
    public int getMinimum() {
        return sliderMin;
    }
    public int getSliderWidth() {
        return sliderWidth;
    }
    
    public void setValue(int sliderValue) {
        sliderValue = Math.max(sliderMin,sliderValue);
        sliderValue = Math.min(sliderMax,sliderValue);
        realValue = displayToReal(sliderValue);
        this.sliderValue = sliderValue;
        repaintBuffer();
    }
    
    public void setUnitIncrement(int i) {sliderUnit = i;}
    public int getUnitIncrement() {return sliderUnit;}
    
    
    public int realToDisplay(double real) {
        if (sliderStyle == STYLE_LINEAR) {
            // linear scale
            double fraction = (real - realMin)/(realMax - realMin);
            return (int)(fraction*(double)(getMaximum()-
                getVisibleAmount()-getMinimum()))+
                getMinimum();
        } else {
            // logarithmic scale
            int n = getMaximum()-getVisibleAmount()-getMinimum();
            double factor = Math.pow((realMax/realMin),1.0/(double)(n));
            return (int)(Math.log(real)/Math.log(realMin))+getMinimum();
        }
    }
    
    public double displayToReal(int display) {
        if (sliderStyle == STYLE_LINEAR) {
            // linear scale
            double fraction = (double)(display - getMinimum())/
                (double)(getMaximum()-
                getVisibleAmount()-getMinimum());
            return fraction*(realMax-realMin)+realMin;
        } else {
            // logarithmic scale
            int n = getMaximum()-getVisibleAmount()-getMinimum();
            double factor = Math.pow((realMax/realMin),1.0/(double)(n));
            return realMin*Math.pow(factor,(double)(getValue()-getMinimum()));
        }
    }

    public void setRealMin(double realMin) {
        this.realMin = realMin;
    }
    
    public void setRealMax(double realMax) {
        this.realMax = realMax;
    }
    
    public void setRealValue(double realValue) {
        this.realValue = realValue;
        setValue(realToDisplay(this.realValue));
    }
    
    public double getRealMin() {
        return realMin;
    }
    
    public double getRealMax() {
        return realMax;
    }
    
    public double getRealValue() {
        return realValue;
    }
    
    /*
     * Graphics methods
     */
    
    public void paintBuffer(Graphics g) {
        calcButtonWidths();
        boolean isRunning = true;
        drawLeftAnimButton(g,leftAnimButtonPressed,
            pauseButtonDisplayed&&reverseAnimDirection);
        drawLeftButton(g,leftButtonPressed);
        drawSliderBar(g);
        drawRightButton(g,rightButtonPressed);
        drawRightAnimButton(g,rightAnimButtonPressed,
            pauseButtonDisplayed&&!reverseAnimDirection);
        repaint();
    }
    
    public void drawLeftAnimButton(Graphics g, boolean buttonPressed, boolean isRunning) {
        Color bgcolor = getBackground();
        Color fgcolor = g.getColor();
                    
        if(buttonPressed) {
            g.fillRect(leftAnimButtonPos,0,buttonWidth,height);
            g.setColor(bgcolor);
        }
        
        if (isRunning) {
            
            int pauseOffset = (int) ((double)buttonWidth*0.4);
            
            g.drawLine(leftAnimButtonPos+pauseOffset,arrowHOffset,
                leftAnimButtonPos+pauseOffset,height-arrowHOffset);
            g.drawLine(leftAnimButtonPos+buttonWidth-pauseOffset,arrowHOffset,
                leftAnimButtonPos+buttonWidth-pauseOffset,height-arrowHOffset);
                
        } else {

            int arrowOffset = (int) ((double)buttonWidth*0.2);
        
            g.drawLine(leftAnimButtonPos+arrowOffset+arrowWidth,arrowHOffset,
                leftAnimButtonPos+arrowOffset,height/2);
            g.drawLine(leftAnimButtonPos+arrowOffset,height/2,
                leftAnimButtonPos+arrowOffset+arrowWidth,height-arrowHOffset);
            g.drawLine(leftAnimButtonPos+arrowWidth+arrowOffset+arrowWidth,arrowHOffset,
                leftAnimButtonPos+arrowWidth+arrowOffset,height/2);
            g.drawLine(leftAnimButtonPos+arrowWidth+arrowOffset,height/2,
                leftAnimButtonPos+arrowWidth+arrowOffset+arrowWidth,height-arrowHOffset);
        }
            
        g.setColor(fgcolor);
                
    }

    public void drawLeftButton(Graphics g, boolean buttonPressed) {
        Color bgcolor = getBackground();
        Color fgcolor = g.getColor();
            
        if(buttonPressed) {
            g.fillRect(leftButtonPos,0,buttonWidth,height);
            g.setColor(bgcolor);
        }
        
        int arrowOffset = (int) ((double)buttonWidth*0.35);
        
        g.drawLine(leftButtonPos+arrowOffset+arrowWidth,arrowHOffset,
            leftButtonPos+arrowOffset,height/2);
        g.drawLine(leftButtonPos+arrowOffset,height/2,
            leftButtonPos+arrowOffset+arrowWidth,height-arrowHOffset);
            
        g.setColor(fgcolor);
        
    }
    
    public void drawSliderBar(Graphics g) {
        
        Color bgcolor = getBackground();
        Color fgcolor = g.getColor();
                                
        g.drawLine (sliderLeftSide,height/2,sliderRightSide,height/2);
        if (!sliderMarkerPressed) g.setColor(bgcolor);
        g.fillRect (markerPos,arrowHOffset,markerWidth,height-2*arrowHOffset);
        g.setColor(fgcolor);
        g.drawRect (markerPos,arrowHOffset,markerWidth,height-2*arrowHOffset);
    }
    
    public void drawRightButton(Graphics g, boolean buttonPressed) {
        Color bgcolor = getBackground();
        Color fgcolor = g.getColor();
            
        if(buttonPressed) {
            g.fillRect(rightButtonPos,0,buttonWidth,height);
            g.setColor(bgcolor);
        }
        
        int arrowOffset = (int) ((double)buttonWidth*0.35);
        
        g.drawLine(rightButtonPos+arrowOffset,arrowHOffset,
            rightButtonPos+arrowOffset+arrowWidth,height/2);
        g.drawLine(rightButtonPos+arrowOffset+arrowWidth,height/2,
            rightButtonPos+arrowOffset,height-arrowHOffset);
            
        g.setColor(fgcolor);


        
    }

    public void drawRightAnimButton(Graphics g, boolean buttonPressed, boolean isRunning) {
        Color bgcolor = getBackground();
        Color fgcolor = g.getColor();
            
        if(buttonPressed) {
            g.fillRect(rightAnimButtonPos,0,buttonWidth,height);
            g.setColor(bgcolor);
        }
        
        if (isRunning) {
            
            int pauseOffset = (int) ((double)buttonWidth*0.4);
            
            g.drawLine(rightAnimButtonPos+pauseOffset,arrowHOffset,
                rightAnimButtonPos+pauseOffset,height-arrowHOffset);
            g.drawLine(rightAnimButtonPos+buttonWidth-pauseOffset,arrowHOffset,
                rightAnimButtonPos+buttonWidth-pauseOffset,height-arrowHOffset);
                
        } else {
        
            int arrowOffset = (int) ((double)buttonWidth*0.2);
        
            g.drawLine(rightAnimButtonPos+arrowOffset,arrowHOffset,
                rightAnimButtonPos+arrowOffset+arrowWidth,height/2);
            g.drawLine(rightAnimButtonPos+arrowOffset+arrowWidth,height/2,
                rightAnimButtonPos+arrowOffset,height-arrowHOffset);
            g.drawLine(rightAnimButtonPos+arrowWidth+arrowOffset,arrowHOffset,
                rightAnimButtonPos+arrowWidth+arrowOffset+arrowWidth,height/2);
            g.drawLine(rightAnimButtonPos+arrowWidth+arrowOffset+arrowWidth,height/2,
                rightAnimButtonPos+arrowWidth+arrowOffset,height-arrowHOffset);

        }

        g.setColor(fgcolor);

    }
    
    public void calcButtonWidths () {
        // each button is 10% of screen size
        buttonWidth = (int) ((double)getSize().width*0.1);
        leftAnimButtonPos = 0;
        leftButtonPos = (int) ((double)getSize().width*0.1);
        sliderPos = (int) ((double)getSize().width*0.2);
        rightButtonPos = (int) ((double)getSize().width*0.8);
        rightAnimButtonPos = (int) ((double)getSize().width*0.9);
        arrowWidth = (int) ((double)getSize().width*0.03);
        arrowHOffset = (int) ((double)getSize().width*0.02);
        height = getSize().height;
        sliderOffset = (int) ((double)buttonWidth*0.2);
        
        double marker = (double)(sliderValue-sliderMin)/
            (double)((sliderMax-sliderMin));
        double markerWidthDouble = (double)sliderWidth/
            (double)((sliderMax-sliderMin));
        
        sliderLeftSide = sliderPos+sliderOffset;
        sliderRightSide = rightButtonPos-sliderOffset;
        double trueRange = (double)(sliderRightSide-sliderLeftSide);
        
        markerPos = (int) (marker*trueRange)+sliderLeftSide;
        markerWidth = (int) (markerWidthDouble*trueRange);
    }
    
    public int markerToSlider(int markerPosIn) {
        double trueRange = (double)(sliderRightSide-sliderLeftSide);
        double marker = (double)(markerPosIn-sliderLeftSide)/trueRange;
            
       return (int)(marker*(double)(sliderMax-sliderMin))+sliderMin;
    }
    
    /*
     * Event Handling
     */
    
    public void addAdjustmentListener(AdjustmentListener l) {
        adjustmentListener = AWTEventMulticaster.add(adjustmentListener, l);
    }
    
    public void removeAdjustmentListener(AdjustmentListener l) {
        adjustmentListener = AWTEventMulticaster.remove(adjustmentListener, l);
    }
    
    public boolean buttonPressed() {
        return leftAnimButtonPressed || leftButtonPressed ||
            sliderMarkerPressed || rightButtonPressed ||
            rightAnimButtonPressed;
    }
    
    public void mousePressed(MouseEvent e) {
        calcButtonWidths();
        int x = e.getX();
        leftAnimButtonPressed = false;
        leftButtonPressed = false;
        sliderMarkerPressed = false;
        rightButtonPressed = false;
        rightAnimButtonPressed = false;
        if (x<0) {
        } else if (x<leftButtonPos) {
            // Left animation button was pressed
            leftAnimButtonPressed = true;
        } else if (x<sliderPos) {
            // Left button was pressed
            leftButtonPressed = true;
        } else if (x<rightButtonPos) {
            // Slider bar was pressed
            if (x>markerPos&&x<(markerPos+markerWidth)) {
                sliderMarkerPressed = true;
                sliderMarkerAnchor = markerPos-x;
            }
        } else if (x<rightAnimButtonPos) {
            // Right button was pressed
            rightButtonPressed = true;
        } else if (x<getSize().width) {
            // Right animation button was pressed
            rightAnimButtonPressed = true;
        }
        repaintBuffer();
    }
    public void mouseClicked(MouseEvent e) {
    }
    public void mouseReleased(MouseEvent e) {

        
        calcButtonWidths();
        int x = e.getX();

        if (leftAnimButtonPressed) {
            // Left animation button was released
            if (!stillGoing) {
                reverseAnimDirection = true;
                pauseButtonDisplayed = true;
                start();
            } else {
                if (reverseAnimDirection) {
                    pauseButtonDisplayed = false;
                    stop();
                } else {
                    reverseAnimDirection = true;
                    pauseButtonDisplayed = true;
                    start();
                }
            }
        } else if (leftButtonPressed) {
            // Left button was released
            setValue(Math.max(sliderValue-sliderUnit,sliderMin));
            pauseButtonDisplayed = false;
            stop();
        } else if (x<rightButtonPos&&!buttonPressed()) {
            // Slider bar was released
            if (x<markerPos) {
                setValue(Math.max(sliderValue-sliderWidth,sliderMin));
            } else if (x>markerPos+markerWidth) {
                setValue(Math.min(sliderValue+sliderWidth,sliderMax-sliderWidth));
            }
            pauseButtonDisplayed = false;
            stop();
        } else if (rightButtonPressed) {
            // Right button was released
            if (sliderValue<sliderMax-sliderWidth) {
                setValue(Math.min(sliderValue+sliderUnit,sliderMax-sliderWidth));
            }
            pauseButtonDisplayed = false;
            stop();
        } else if (rightAnimButtonPressed) {
            // Right animation button was released
            if(!stillGoing) {
                reverseAnimDirection = false;
                pauseButtonDisplayed = true;
                start();
            } else {
                if (!reverseAnimDirection) {
                    pauseButtonDisplayed = false;
                    stop();
                } else {
                    pauseButtonDisplayed = true;
                    reverseAnimDirection = false;
                    start();
                }
            }
        }
        postSliderChanged();
        
        leftAnimButtonPressed = false;
        leftButtonPressed = false;
        sliderMarkerPressed = false;
        rightButtonPressed = false;
        rightAnimButtonPressed = false;
        
        repaintBuffer();

    }
    public void mouseEntered(MouseEvent e) {;}
    public void mouseExited(MouseEvent e) {;}
    public void mouseDragged(MouseEvent e) {
        // For a drag, check and see if the marker button is pressed.
        //   If so, calculate a new slider value.
        
        if (sliderMarkerPressed) {
            calcButtonWidths();
            int x = e.getX();
        
            int tempValue = Math.max(markerToSlider(x+sliderMarkerAnchor),sliderMin);
            tempValue = Math.min(tempValue,sliderMax-sliderWidth);
            setValue(tempValue);
            postSliderChanged();
            
            pauseButtonDisplayed = false;
            stop();
            
            repaintBuffer();
            

        }
        
        
    }
    public void mouseMoved(MouseEvent e) {;}
    
    public void postSliderChanged() {
        if (adjustmentListener != null)
            adjustmentListener.adjustmentValueChanged(
                new AdjustmentEvent(this,
                AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED,
                AdjustmentEvent.TRACK,getValue()));    
    }
    
    
    
}