/* BasicProgressBarUI.java --
   Copyright (C) 2004, 2005  Free Software Foundation, Inc.

This file is part of GNU Classpath.

GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.

Linking this library statically or dynamically with other modules is
making a combined work based on this library.  Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.

As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from
or based on this library.  If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so.  If you do not wish to do so, delete this
exception statement from your version. */


package javax.swing.plaf.basic;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Insets;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Shape;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ComponentAdapter;
import java.awt.event.ComponentEvent;
import java.awt.event.ComponentListener;
import java.awt.geom.AffineTransform;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;

import javax.swing.JComponent;
import javax.swing.JProgressBar;
import javax.swing.LookAndFeel;
import javax.swing.SwingConstants;
import javax.swing.SwingUtilities;
import javax.swing.Timer;
import javax.swing.UIManager;
import javax.swing.event.AncestorEvent;
import javax.swing.event.AncestorListener;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import javax.swing.plaf.ComponentUI;
import javax.swing.plaf.ProgressBarUI;

/**
 * The Basic Look and Feel UI delegate for the
 * JProgressBar.
 */
public class BasicProgressBarUI extends ProgressBarUI
{
  /**
   * A helper class that listens for ChangeEvents
   * from the progressBar's model.
   *
   * @specnote Apparently this class was intended to be protected,
   *           but was made public by a compiler bug and is now
   *           public for compatibility.
   */
  public class ChangeHandler implements ChangeListener
  {
    /**
     * Called every time the state of the model changes.
     *
     * @param e The ChangeEvent given by the model.
     */
    public void stateChanged(ChangeEvent e)
    {
      // Nothing to do but repaint.
      progressBar.repaint();
    }
  }

  /**
   * This helper class is used to listen for
   * PropertyChangeEvents from the progressBar.
   */
  private class PropertyChangeHandler implements PropertyChangeListener
  {
    /**
     * Called every time the properties of the
     * progressBar change.
     *
     * @param e The PropertyChangeEvent given by the progressBar.
     */
    public void propertyChange(PropertyChangeEvent e)
    {
      // Only need to listen for indeterminate changes.
      // All other things are done on a repaint.
      if (e.getPropertyName().equals("indeterminate"))
        if (((Boolean) e.getNewValue()).booleanValue()
            && progressBar.isShowing())
          startAnimationTimer();
        else
          stopAnimationTimer();
    }
  }

  /**
   * Receives notification when the progressbar is becoming visible or
   * invisible and starts/stops the animation timer accordingly.
   *
   * @author Roman Kennke (kennke@aicas.com)
   */
  private class AncestorHandler implements AncestorListener
  {

    /**
     * Receives notification when the progressbar is becoming visible. This
     * starts the animation timer if the progressbar is indeterminate.
     *
     * @param event the ancestor event
     */
    public void ancestorAdded(AncestorEvent event)
    {
      if (progressBar.isIndeterminate())
        startAnimationTimer();
    }

    /**
     * Receives notification when the progressbar is becoming invisible. This
     * stops the animation timer if the progressbar is indeterminate.
     *
     * @param event the ancestor event
     */
    public void ancestorRemoved(AncestorEvent event)
    {
      stopAnimationTimer();
    }

    /**
     * Receives notification when an ancestor has been moved. We don't need to
     * do anything here.
     */
    public void ancestorMoved(AncestorEvent event)
    {
      // Nothing to do here.
    }

  }

  /**
   * This helper class is used to listen for
   * the animationTimer's intervals. On every interval,
   * the bouncing box should move.
   */
  private class Animator implements ActionListener
  {
    /**
     * Called every time the animationTimer reaches
     * its interval.
     *
     * @param e The ActionEvent given by the timer.
     */
    public void actionPerformed(ActionEvent e)
    {
      // Incrementing the animation index will cause
      // a repaint.
      incrementAnimationIndex();
    }
  }

  /**
   * Receives notification when the size of the progress bar changes and
   * invalidates the layout information for the box calculation in
   * {@link BasicProgressBarUI#getBox(Rectangle)}.
   *
   * @author Roman Kennke (kennke@aicas.com)
   */
  private class ComponentHandler extends ComponentAdapter
  {
    /**
     * Receives notification when the size of the progress bar changes and
     * invalidates the layout information for the box calculation in
     * {@link BasicProgressBarUI#getBox}.
     *
     * @param e the component event
     */
    public void componentResized(ComponentEvent e)
    {
      boxDependent = -1;
      boxIndependent = -1;
      incr = -1;
    }
  }

  /**
   * Holds the value of the bouncing box that is returned by {@link #getBox}.
   *
   * @since 1.5
   */
  protected Rectangle boxRect;

  /** The timer used to move the bouncing box. */
  private transient Timer animationTimer;

  // The total number of frames must be an even number.
  // The total number of frames is calculated from
  // the cycleTime and repaintInterval given by
  // the basic Look and Feel defaults.
  //
  // +-----------------------------------------------+
  // | frame0 | frame1 | frame2 | frame 3 | frame 4  |
  // |        | frame7 | frame6 | frame 5 |          |
  // +-----------------------------------------------+

  /** The current animation index. */
  private transient int animationIndex;

  /** The total number of frames.*/
  private transient int numFrames;

  /** The helper that moves the bouncing box. */
  private transient Animator animation;

  /** The helper that listens for property change events. */
  private transient PropertyChangeHandler propertyListener;

  /** The Listener for the model. */
  protected ChangeListener changeListener;

  /** The progressBar for this UI. */
  protected JProgressBar progressBar;


  /**
   * The size of the box returned by {@link #getBox} in the orientation
   * direction of the progress bar. This is package private to avoid accessor
   * method.
   */
  transient double boxDependent = - 1;

  /**
   * The size of the box returned by {@link #getBox} against the orientation
   * direction of the progress bar. This is package private to avoid accessor
   * method.
   */
  transient int boxIndependent = - 1;

  /**
   * The increment for box animation. This is package private to avoid accessor
   * method.
   */
  transient double incr = -1;

  /** The length of the cell. The cell is the painted part. */
  private transient int cellLength;

  /** The gap between cells. */
  private transient int cellSpacing;

  /** The color of the text when the bar is not over it.*/
  private transient Color selectionBackground;

  /** The color of the text when the bar is over it. */
  private transient Color selectionForeground;

  /**
   * Listens for notification when the component becomes showing and
   * starts/stops the animation timer.
   */
  private AncestorListener ancestorListener;

  /**
   * Listens for resize events on the progress bar and invalidates some
   * layout info.
   */
  private ComponentListener componentListener;

  /**
   * Creates a new BasicProgressBarUI object.
   */
  public BasicProgressBarUI()
  {
    super();
  }

  /**
   * Creates a new BasicProgressBarUI for the component.
   *
   * @param x The JComponent to create the UI for.
   *
   * @return A new BasicProgressBarUI.
   */
  public static ComponentUI createUI(JComponent x)
  {
    return new BasicProgressBarUI();
  }

  /**
   * This method returns the length of the bar (from the minimum)
   * in pixels (or units that the Graphics object draws in) based
   * on the progressBar's getPercentComplete() value.
   *
   * @param b The insets of the progressBar.
   * @param width The width of the progressBar.
   * @param height The height of the progressBar.
   *
   * @return The length of the bar that should be painted in pixels.
   */
  protected int getAmountFull(Insets b, int width, int height)
  {
    double percentDone = progressBar.getPercentComplete();
    if (progressBar.getOrientation() == JProgressBar.HORIZONTAL)
      return (int) (percentDone * (width - b.left - b.right));
    else
      return (int) (percentDone * (height - b.top - b.bottom));
  }

  /**
   * The current animation index.
   *
   * @return The current animation index.
   */
  protected int getAnimationIndex()
  {
    return animationIndex;
  }

  /**
   * This method returns the size and position of the bouncing box
   * for the current animation index. It stores the values in the
   * given rectangle and returns it. It returns null if no box should
   * be drawn.
   *
   * @param r The bouncing box rectangle.
   *
   * @return The bouncing box rectangle.
   */
  protected Rectangle getBox(Rectangle r)
  {
    if (!progressBar.isIndeterminate())
      return null;
    if (r == null)
      r = new Rectangle();

    Rectangle vr = new Rectangle();
    SwingUtilities.calculateInnerArea(progressBar, vr);

    // Recalculate the metrics only when size of the progressbar has changed.
    if (incr == -1 || boxDependent == -1 || boxIndependent == -1)
      {
        //numFrames has to be an even number as defined by spec.
        int iterations = numFrames / 2;
        if (progressBar.getOrientation() == JProgressBar.HORIZONTAL)
          {
            boxDependent = vr.width / 6.;
            incr = ((double) (vr.width - boxDependent)) / (double) iterations;
            boxIndependent = vr.height;
          }
        else
          {
            boxDependent = vr.height / 6.;
            incr = ((double) (vr.height - boxDependent)) / (double) iterations;
            boxIndependent = vr.width;
          }
      }

    int index = getAnimationIndex();
    if (animationIndex > numFrames / 2)
      index = numFrames - getAnimationIndex();

    if (progressBar.getOrientation() == JProgressBar.HORIZONTAL)
      {
        r.x = vr.x + (int) (incr * index);
        r.y = vr.y;
        r.width = (int) boxDependent;
        r.height = (int) boxIndependent;
      }
    else
      {
        r.x = vr.x;
        r.y = vr.height - (int) (incr * index) + vr.y - (int) boxDependent;
        r.width = (int) boxIndependent;
        r.height = (int) boxDependent;
      }
    return r;
  }

  /**
   * This method returns the length of the cells.
   *
   * @return The cell length.
   */
  protected int getCellLength()
  {
    return cellLength;
  }

  /**
   * This method returns the spacing between cells.
   *
   * @return The cell gap.
   */
  protected int getCellSpacing()
  {
    return cellSpacing;
  }

  /**
   * This method returns the maximum size of the JComponent.
   * If it returns null, it is up to the LayoutManager
   * to give it a size.
   *
   * @param c The component to find a maximum size for.
   *
   * @return The maximum size.
   */
  public Dimension getMaximumSize(JComponent c)
  {
    Insets insets = c.getInsets();
    Dimension ret;
    int orientation = progressBar.getOrientation();
    if (orientation == JProgressBar.VERTICAL)
      {
        ret = getPreferredInnerVertical();
        ret.height = Short.MAX_VALUE;
        ret.width += insets.left + insets.right;
      }
    else
      {
        ret = getPreferredInnerHorizontal();
        ret.width = Short.MAX_VALUE;
        ret.height += insets.top + insets.bottom;
      }
    return ret;
  }

  /**
   * This method returns the minimum size of the JComponent.
   * If it returns null, it is up to the LayoutManager to
   * give it a size.
   *
   * @param c The component to find a minimum size for.
   *
   * @return The minimum size.
   */
  public Dimension getMinimumSize(JComponent c)
  {
    Insets insets = c.getInsets();
    Dimension ret;
    int orientation = progressBar.getOrientation();
    if (orientation == JProgressBar.VERTICAL)
      {
        ret = getPreferredInnerVertical();
        ret.height = 10;
        ret.width += insets.left + insets.right;
      }
    else
      {
        ret = getPreferredInnerHorizontal();
        ret.width = 10;
        ret.height += insets.top + insets.bottom;
      }
    return ret;
  }

  /**
   * This method returns the preferred size of the inner
   * rectangle (the bounds without the insets) if the
   * progressBar is horizontal.
   *
   * @return The preferred size of the progressBar minus
   *         insets if it's horizontal.
   */
  protected Dimension getPreferredInnerHorizontal()
  {
    Font font = progressBar.getFont();
    FontMetrics fm = progressBar.getFontMetrics(font);

    int stringWidth = 0;
    String str = progressBar.getString();
    if (str != null)
      stringWidth = fm.stringWidth(progressBar.getString());
    Insets i = progressBar.getInsets();
    int prefWidth = Math.max(200 - i.left - i.right, stringWidth);

    int stringHeight = 0;
    if (str != null)
      stringHeight = fm.getHeight();
    int prefHeight = Math.max(16 - i.top - i.bottom, stringHeight);

    return new Dimension(prefWidth, prefHeight);
  }

  /**
   * This method returns the preferred size of the inner
   * rectangle (the bounds without insets) if the
   * progressBar is vertical.
   *
   * @return The preferred size of the progressBar minus
   *         insets if it's vertical.
   */
  protected Dimension getPreferredInnerVertical()
  {
    Font font = progressBar.getFont();
    FontMetrics fm = progressBar.getFontMetrics(font);

    int stringWidth = 0;
    String str = progressBar.getString();
    if (str != null)
      stringWidth = fm.stringWidth(progressBar.getString());
    Insets i = progressBar.getInsets();
    int prefHeight = Math.max(200 - i.left - i.right, stringWidth);

    int stringHeight = 0;
    if (str != null)
      stringHeight = fm.getHeight();
    int prefWidth = Math.max(16 - i.top - i.bottom, stringHeight);

    return new Dimension(prefWidth, prefHeight);
  }

  /**
   * This method returns the preferred size of the
   * given JComponent. If it returns null, then it
   * is up to the LayoutManager to give it a size.
   *
   * @param c The component to find the preferred size for.
   *
   * @return The preferred size of the component.
   */
  public Dimension getPreferredSize(JComponent c)
  {
    Insets insets = c.getInsets();
    Dimension ret;
    int orientation = progressBar.getOrientation();
    if (orientation == JProgressBar.VERTICAL)
      ret = getPreferredInnerVertical();
    else
      ret = getPreferredInnerHorizontal();
    ret.width += insets.left + insets.right;
    ret.height += insets.top + insets.bottom;
    return ret;
  }

  /**
   * This method returns the Color that the text is shown in when the bar is
   * not over the text.
   *
   * @return The color of the text when the bar is not over it.
   */
  protected Color getSelectionBackground()
  {
    return selectionBackground;
  }

  /**
   * This method returns the Color that the text is shown in  when the bar is
   * over the text.
   *
   * @return The color of the text when the bar is over it.
   */
  protected Color getSelectionForeground()
  {
    return selectionForeground;
  }

  /**
   * This method returns the point (the top left of the bounding box)
   * where the text should be painted.
   *
   * @param g The Graphics object to measure FontMetrics with.
   * @param progressString The string to paint.
   * @param x The x coordinate of the overall bounds box.
   * @param y The y coordinate of the overall bounds box.
   * @param width The width of the overall bounds box.
   * @param height The height of the overall bounds box.
   *
   * @return The top left of the bounding box where text should be painted.
   */
  protected Point getStringPlacement(Graphics g, String progressString, int x,
                                     int y, int width, int height)
  {
    Rectangle tr = new Rectangle();
    Rectangle vr = new Rectangle();
    Rectangle ir = new Rectangle();

    if (progressBar.getOrientation() == JProgressBar.HORIZONTAL)
      vr.setBounds(x, y, width, height);
    else
      vr.setBounds(y, x, height, width);

    Font f = g.getFont();
    FontMetrics fm = g.getFontMetrics(f);

    SwingUtilities.layoutCompoundLabel(progressBar, fm, progressString, null,
                                       SwingConstants.CENTER,
                                       SwingConstants.CENTER,
                                       SwingConstants.CENTER,
                                       SwingConstants.CENTER, vr, ir, tr, 0);

    if (progressBar.getOrientation() == JProgressBar.HORIZONTAL)
      return new Point(tr.x, tr.y);
    else
      return new Point(tr.y, tr.x);
  }

  /**
   * This method increments the animation index.
   */
  protected void incrementAnimationIndex()
  {
    animationIndex++;
    //numFrames is like string length, it should be named numFrames or something
    if (animationIndex >= numFrames)
      animationIndex = 0;
    progressBar.repaint();
  }

  /**
   * This method paints the progressBar. It delegates its responsibilities
   * to paintDeterminate and paintIndeterminate.
   *
   * @param g The Graphics object to paint with.
   * @param c The JComponent to paint.
   */
  public void paint(Graphics g, JComponent c)
  {
    if (! progressBar.isIndeterminate())
      paintDeterminate(g, c);
    else
      paintIndeterminate(g, c);
  }

  /**
   * This method is called if the painting to be done is
   * for a determinate progressBar.
   *
   * @param g The Graphics object to paint with.
   * @param c The JComponent to paint.
   */
  protected void paintDeterminate(Graphics g, JComponent c)
  {
    Color saved = g.getColor();
    int space = getCellSpacing();
    int len = getCellLength();
    int max = progressBar.getMaximum();
    int min = progressBar.getMinimum();
    int value = progressBar.getValue();

    Rectangle vr = SwingUtilities.calculateInnerArea(c, new Rectangle());
    Rectangle or = progressBar.getBounds();
    Insets insets = c.getInsets();

    int amountFull = getAmountFull(insets, or.width, or.height);

        if (progressBar.getOrientation() == JProgressBar.HORIZONTAL)
          {
            g.setColor(c.getForeground());
            g.fillRect(vr.x, vr.y, amountFull, vr.height);
          }
        else
          {
            g.setColor(c.getForeground());
            g.fillRect(vr.x, vr.y + vr.height - amountFull, vr.width,
                       amountFull);
          }

    if (progressBar.isStringPainted() && !progressBar.getString().equals(""))
      paintString(g, 0, 0, or.width, or.height, amountFull, insets);
    g.setColor(saved);
  }

  /**
   * This method is called if the painting to be done is for
   * an indeterminate progressBar.
   *
   * @param g The Graphics object to paint with.
   * @param c The JComponent to paint.
   */
  protected void paintIndeterminate(Graphics g, JComponent c)
  {
    //need to paint the box at it's current position. no text is painted since
    //all we're doing is bouncing back and forth
    Color saved = g.getColor();
    Insets insets = c.getInsets();

    Rectangle or = c.getBounds();
    Rectangle vr = new Rectangle();
    SwingUtilities.calculateInnerArea(c, vr);

    g.setColor(c.getBackground());
    g.fillRect(vr.x, vr.y, vr.width, vr.height);

    boxRect = getBox(boxRect);

    g.setColor(c.getForeground());
    g.fillRect(boxRect.x, boxRect.y, boxRect.width, boxRect.height);

    if (progressBar.isStringPainted() && !progressBar.getString().equals(""))
      paintString(g, 0, 0, or.width, or.height,
                  getAmountFull(insets, or.width, or.height), insets);

    g.setColor(saved);
  }

  /**
   * This method paints the string for the progressBar.
   *
   * @param g The Graphics object to paint with.
   * @param x The x coordinate of the progressBar.
   * @param y The y coordinate of the progressBar.
   * @param width The width of the progressBar.
   * @param height The height of the progressBar.
   * @param amountFull The amount of the progressBar that has its bar filled.
   * @param b The insets of the progressBar.
   */
  protected void paintString(Graphics g, int x, int y, int width, int height,
                             int amountFull, Insets b)
  {
    String str = progressBar.getString();
    int full = getAmountFull(b, width, height);
    Point placement = getStringPlacement(g, progressBar.getString(),
                                         x + b.left, y + b.top,
                                         width - b.left - b.right,
                                         height - b.top - b.bottom);
    Color savedColor = g.getColor();
    Shape savedClip = g.getClip();
    FontMetrics fm = g.getFontMetrics(progressBar.getFont());

    if (progressBar.getOrientation() == JProgressBar.VERTICAL)
      {
        AffineTransform rotate = AffineTransform.getRotateInstance(Math.PI / 2);
        g.setFont(progressBar.getFont().deriveFont(rotate));
        placement.x = width - placement.x - fm.getAscent();
      }
    else
      {
        placement.y += fm.getAscent();
      }

    g.setColor(getSelectionForeground());
    g.setClip(0, 0, full + b.left, height);
    g.drawString(str, placement.x, placement.y);
    g.setColor(getSelectionBackground());
    g.setClip(full + b.left, 0, width - full, height);
    g.drawString(str, placement.x, placement.y);
    g.setClip(savedClip);
    g.setColor(savedColor);
  }

  /**
   * This method sets the current animation index. If the index is greater than
   * the number of frames, it resets to 0.
   *
   * @param newValue The new animation index.
   */
  protected void setAnimationIndex(int newValue)
  {
    animationIndex = (newValue <= numFrames) ? newValue : 0;
    progressBar.repaint();
  }

  /**
   * This method sets the cell length.
   *
   * @param cellLen The cell length.
   */
  protected void setCellLength(int cellLen)
  {
    cellLength = cellLen;
  }

  /**
   * This method sets the cell spacing.
   *
   * @param cellSpace The cell spacing.
   */
  protected void setCellSpacing(int cellSpace)
  {
    cellSpacing = cellSpace;
  }

  /**
   * This method starts the animation timer. It is called
   * when the propertyChangeListener detects that the progressBar
   * has changed to indeterminate mode.
   *
   * @since 1.4
   */
  protected void startAnimationTimer()
  {
    if (animationTimer != null)
      animationTimer.start();
  }

  /**
   * This method stops the animation timer. It is called when
   * the propertyChangeListener detects that the progressBar
   * has changed to determinate mode.
   *
   * @since 1.4
   */
  protected void stopAnimationTimer()
  {
    if (animationTimer != null)
      animationTimer.stop();
    setAnimationIndex(0);
  }

  /**
   * This method changes the settings for the progressBar to
   * the defaults provided by the current Look and Feel.
   */
  protected void installDefaults()
  {
    LookAndFeel.installColorsAndFont(progressBar, "ProgressBar.background",
                                     "ProgressBar.foreground",
                                     "ProgressBar.font");
    LookAndFeel.installBorder(progressBar, "ProgressBar.border");
    progressBar.setOpaque(true);

    selectionForeground = UIManager.getColor("ProgressBar.selectionForeground");
    selectionBackground = UIManager.getColor("ProgressBar.selectionBackground");
    cellLength = UIManager.getInt("ProgressBar.cellLength");
    cellSpacing = UIManager.getInt("ProgressBar.cellSpacing");

    int repaintInterval = UIManager.getInt("ProgressBar.repaintInterval");
    int cycleTime = UIManager.getInt("ProgressBar.cycleTime");

    if (cycleTime % repaintInterval != 0
        && (cycleTime / repaintInterval) % 2 != 0)
      {
        int div = (cycleTime / repaintInterval) + 2;
        div /= 2;
        div *= 2;
        cycleTime = div * repaintInterval;
      }
    setAnimationIndex(0);
    numFrames = cycleTime / repaintInterval;
    animationTimer.setDelay(repaintInterval);
  }

  /**
   * The method uninstalls any defaults that were
   * set by the current Look and Feel.
   */
  protected void uninstallDefaults()
  {
    progressBar.setFont(null);
    progressBar.setForeground(null);
    progressBar.setBackground(null);

    selectionForeground = null;
    selectionBackground = null;
  }

  /**
   * This method registers listeners to all the
   * components that this UI delegate needs to listen to.
   */
  protected void installListeners()
  {
    changeListener = new ChangeHandler();
    propertyListener = new PropertyChangeHandler();
    animation = new Animator();

    progressBar.addChangeListener(changeListener);
    progressBar.addPropertyChangeListener(propertyListener);
    animationTimer.addActionListener(animation);

    ancestorListener = new AncestorHandler();
    progressBar.addAncestorListener(ancestorListener);

    componentListener = new ComponentHandler();
    progressBar.addComponentListener(componentListener);
  }

  /**
   * This method unregisters listeners to all the
   * components that were listened to.
   */
  protected void uninstallListeners()
  {
    progressBar.removeChangeListener(changeListener);
    progressBar.removePropertyChangeListener(propertyListener);
    animationTimer.removeActionListener(animation);

    changeListener = null;
    propertyListener = null;
    animation = null;

    if (ancestorListener != null)
      progressBar.removeAncestorListener(ancestorListener);
    ancestorListener = null;

    if (componentListener != null)
      progressBar.removeComponentListener(componentListener);
    componentListener = null;
  }

  /**
   * This method installs the UI for the given JComponent.
   * This includes setting up defaults and listeners as
   * well as initializing any values or objects that
   * the UI may need.
   *
   * @param c The JComponent that is having this UI installed.
   */
  public void installUI(JComponent c)
  {
    super.installUI(c);
    if (c instanceof JProgressBar)
      {
        progressBar = (JProgressBar) c;

        animationTimer = new Timer(200, null);
        animationTimer.setRepeats(true);

        installDefaults();
        installListeners();
      }
    if (progressBar.isIndeterminate())
      startAnimationTimer();
  }

  /**
   * This method removes the UI for the given JComponent.
   * This includes removing any listeners or defaults
   * that the installUI may have set up.
   *
   * @param c The JComponent that is having this UI uninstalled.
   */
  public void uninstallUI(JComponent c)
  {
    super.uninstallUI(c);
    uninstallListeners();
    uninstallDefaults();

    animationTimer = null;
    progressBar = null;
  }

}
