gt:     if (animationIndex > numFrames / 2)
context: /* 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();
  