/* AsyncBoxView.java -- A box view that performs layout asynchronously
   Copyright (C) 2006 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.text;

import java.awt.Component;
import java.awt.Graphics;
import java.awt.Rectangle;
import java.awt.Shape;
import java.util.ArrayList;

import javax.swing.event.DocumentEvent;
import javax.swing.text.Position.Bias;

/**
 * A {@link View} implementation that lays out its child views in a box, either
 * vertically or horizontally. The difference to {@link BoxView} is that the
 * layout is performed in an asynchronous manner. This helps to keep the
 * eventqueue free from non-GUI related tasks.
 *
 * This view is currently not used in standard text components. In order to
 * use it you would have to implement a special {@link EditorKit} with a
 * {@link ViewFactory} that returns this view. For example:
 *
 * <pre>
 * static class AsyncEditorKit extends StyledEditorKit implements ViewFactory
 * {
 *   public View create(Element el)
 *   {
 *     if (el.getName().equals(AbstractDocument.SectionElementName))
 *       return new AsyncBoxView(el, View.Y_AXIS);
 *     return super.getViewFactory().create(el);
 *   }
 *   public ViewFactory getViewFactory() {
 *     return this;
 *   }
 * }
 * </pre>
 *
 * @author Roman Kennke (kennke@aicas.com)
 *
 * @since 1.3
 */
public class AsyncBoxView
  extends View
{

  /**
   * Manages the effective position of child views. That keeps the visible
   * layout stable while the AsyncBoxView might be changing until the layout
   * thread decides to publish the new layout.
   */
  public class ChildLocator
  {

    /**
     * The last valid location.
     */
    protected ChildState lastValidOffset;

    /**
     * The last allocation.
     */
    protected Rectangle lastAlloc;

    /**
     * A Rectangle used for child allocation calculation to avoid creation
     * of lots of garbage Rectangle objects.
     */
    protected Rectangle childAlloc;

    /**
     * Creates a new ChildLocator.
     */
    public ChildLocator()
    {
      lastAlloc = new Rectangle();
      childAlloc = new Rectangle();
    }

    /**
     * Receives notification that a child has changed. This is called by
     * child state objects that have changed it's major span.
     *
     * This sets the {@link #lastValidOffset} field to <code>cs</code> if
     * the new child state's view start offset is smaller than the start offset
     * of the current child state's view or when <code>lastValidOffset</code>
     * is <code>null</code>.
     *
     * @param cs the child state object that has changed
     */
    public synchronized void childChanged(ChildState cs)
    {
      if (lastValidOffset == null
          || cs.getChildView().getStartOffset()
             < lastValidOffset.getChildView().getStartOffset())
        {
          lastValidOffset = cs;
        }
    }

    /**
     * Returns the view index of the view that occupies the specified area, or
     * <code>-1</code> if there is no such child view.
     *
     * @param x the x coordinate (relative to <code>a</code>)
     * @param y the y coordinate (relative to <code>a</code>)
     * @param a the current allocation of this view
     *
     * @return the view index of the view that occupies the specified area, or
     *         <code>-1</code> if there is no such child view
     */
    public int getViewIndexAtPoint(float x, float y, Shape a)
    {
      setAllocation(a);
      float targetOffset = (getMajorAxis() == X_AXIS) ? x - lastAlloc.x
                                                      : y - lastAlloc.y;
      int index = getViewIndexAtVisualOffset(targetOffset);
      return index;
    }

    /**
     * Returns the current allocation for a child view. This updates the
     * offsets for all children <em>before</em> the requested child view.
     *
     * @param index the index of the child view
     * @param a the current allocation of this view
     * 
     * @return the current allocation for a child view
     */
    public synchronized Shape getChildAllocation(int index, Shape a)
    {
      if (a == null)
        return null;
      setAllocation(a);
      ChildState cs = getChildState(index);
      if (cs.getChildView().getStartOffset()
          > lastValidOffset.getChildView().getStartOffset())
        {
          updateChildOffsetsToIndex(index);
        }
      Shape ca = getChildAllocation(index);
      return ca;
    }

    /**
     * Paints all child views.
     *
     * @param g the graphics context to use
     */
    public synchronized void paintChildren(Graphics g)
    {
      Rectangle clip = g.getClipBounds();
      float targetOffset = (getMajorAxis() == X_AXIS) ? clip.x - lastAlloc.x
                                                      : clip.y - lastAlloc.y;
      int index = getViewIndexAtVisualOffset(targetOffset);
      int n = getViewCount();
      float offs = getChildState(index).getMajorOffset();
      for (int i = index; i < n; i++)
        {
          ChildState cs = getChildState(i);
          cs.setMajorOffset(offs);
          Shape ca = getChildAllocation(i);
          if (ca.intersects(clip))
            {
              synchronized (cs)
                {
                  View v = cs.getChildView();
                  v.paint(g, ca);
                }
            }
          else
            {
              // done painting intersection
              break;
            }
          offs += cs.getMajorSpan();
        }
    }

    /**
     * Returns the current allocation of the child view with the specified
     * index. Note that this will <em>not</em> update any location information.
     * 
     * @param index the index of the requested child view
     *
     * @return the current allocation of the child view with the specified
     *         index
     */
    protected Shape getChildAllocation(int index)
    {
      ChildState cs = getChildState(index);
      if (! cs.isLayoutValid())
          cs.run();

      if (getMajorAxis() == X_AXIS)
        {
          childAlloc.x = lastAlloc.x + (int) cs.getMajorOffset();
          childAlloc.y = lastAlloc.y + (int) cs.getMinorOffset();
          childAlloc.width = (int) cs.getMajorSpan();
          childAlloc.height = (int) cs.getMinorSpan();
        }
      else
        {
          childAlloc.y = lastAlloc.y + (int) cs.getMajorOffset();
          childAlloc.x = lastAlloc.x + (int) cs.getMinorOffset();
          childAlloc.height = (int) cs.getMajorSpan();
          childAlloc.width = (int) cs.getMinorSpan();
        }
      return childAlloc;
    }

    /**
     * Sets the current allocation for this view.
     *
     * @param a the allocation to set
     */
    protected void setAllocation(Shape a)
    {
      if (a instanceof Rectangle)
        lastAlloc.setBounds((Rectangle) a);
      else
        lastAlloc.setBounds(a.getBounds());

      setSize(lastAlloc.width, lastAlloc.height);
    }

    /**
     * Returns the index of the view at the specified offset along the major
     * layout axis.
     *
     * @param targetOffset the requested offset
     *
     * @return the index of the view at the specified offset along the major
     * layout axis
     */
    protected int getViewIndexAtVisualOffset(float targetOffset)
    {
      int n = getViewCount();
      if (n > 0)
        {
          if (lastValidOffset == null)
            lastValidOffset = getChildState(0);
          if (targetOffset > majorSpan)
            return 0;
          else if (targetOffset > lastValidOffset.getMajorOffset())
            return updateChildOffsets(targetOffset);
          else
            {
              float offs = 0f;
              for (int i = 0; i < n; i++)
                {
                  ChildState cs = getChildState(i);
                  float nextOffs = offs + cs.getMajorSpan();
                  if (targetOffset < nextOffs)
                    return i;
                  offs = nextOffs;
                }
            }
        }
      return n - 1;
    }

    /**
     * Updates all the child view offsets up to the specified targetOffset.
     *
     * @param targetOffset the offset up to which the child view offsets are
     *        updated
     *
     * @return the index of the view at the specified offset
     */
    private int updateChildOffsets(float targetOffset)
    {
      int n = getViewCount();
      int targetIndex = n - 1;;
      int pos = lastValidOffset.getChildView().getStartOffset();
      int startIndex = getViewIndexAtPosition(pos, Position.Bias.Forward);
      float start = lastValidOffset.getMajorOffset();
      float lastOffset = start;
      for (int i = startIndex; i < n; i++)
        {
          ChildState cs = getChildState(i);
          cs.setMajorOffset(lastOffset);
          lastOffset += cs.getMajorSpan();
          if (targetOffset < lastOffset)
            {
              targetIndex = i;
              lastValidOffset = cs;
              break;
            }
        }
      return targetIndex;
    }

    /**
     * Updates the offsets of the child views up to the specified index.
     *
     * @param index the index up to which the offsets are updated
     */
    private void updateChildOffsetsToIndex(int index)
    {
      int pos = lastValidOffset.getChildView().getStartOffset();
      int startIndex = getViewIndexAtPosition(pos, Position.Bias.Forward);
      float lastOffset = lastValidOffset.getMajorOffset();
      for (int i = startIndex; i <= index; i++)
        {
          ChildState cs = getChildState(i);
          cs.setMajorOffset(lastOffset);
          lastOffset += cs.getMajorSpan();
        }
    }
  }

  /**
   * Represents the layout state of a child view.
   */
  public class ChildState
    implements Runnable
  {

    /**
     * The child view for this state record.
     */
    private View childView;

    /**
     * Indicates if the minor axis requirements of this child view are valid
     * or not.
     */
    private boolean minorValid;

    /**
     * Indicates if the major axis requirements of this child view are valid
     * or not.
     */
    private boolean majorValid;

    /**
     * Indicates if the current child size is valid. This is package private
     * to avoid synthetic accessor method.
     */
    boolean childSizeValid;

    /**
     * The child views minimumSpan. This is package private to avoid accessor
     * method.
     */
    float minimum;

    /**
     * The child views preferredSpan. This is package private to avoid accessor
     * method.
     */
    float preferred;

    /**
     * The current span of the child view along the major axis.
     */
    private float majorSpan;

    /**
     * The current offset of the child view along the major axis.
     */
    private float majorOffset;

    /**
     * The current span of the child view along the minor axis.
     */
    private float minorSpan;

    /**
     * The current offset of the child view along the major axis.
     */
    private float minorOffset;

    /**
     * The child views maximumSpan.
     */
    private float maximum;

    /**
     * Creates a new <code>ChildState</code> object for the specified child
     * view.
     *
     * @param view the child view for which to create the state record
     */
    public ChildState(View view)
    {
      childView = view;
    }

    /**
     * Returns the child view for which this <code>ChildState</code> represents
     * the layout state.
     *
     * @return the child view for this child state object 
     */
    public View getChildView()
    {
      return childView;
    }

    /**
     * Returns <code>true</code> if the current layout information is valid,
     * <code>false</code> otherwise.
     *
     * @return <code>true</code> if the current layout information is valid,
     *         <code>false</code> otherwise
     */
    public boolean isLayoutValid()
    {
      return minorValid && majorValid && childSizeValid;
    }

    /**
     * Performs the layout update for the child view managed by this
     * <code>ChildState</code>.
     */
    public void run()
    {
      Document doc = getDocument();
      if (doc instanceof AbstractDocument)
        {
          AbstractDocument abstractDoc = (AbstractDocument) doc;
          abstractDoc.readLock();
        }

      try
        {

          if (!(minorValid &&  majorValid && childSizeValid)
              && childView.getParent() == AsyncBoxView.this)
            {
              synchronized(AsyncBoxView.this)
              {
                changing = this;
              }
              update();
              synchronized(AsyncBoxView.this)
              {
                changing = null;
              }
              // Changing the major axis may cause the minor axis
              // requirements to have changed, so we need to do this again.
              update();
            }
        }
      finally
        {
          if (doc instanceof AbstractDocument)
            {
              AbstractDocument abstractDoc = (AbstractDocument) doc;
              abstractDoc.readUnlock();
            }
        }
    }

    /**
     * Performs the actual update after the run methods has made its checks
     * and locked the document.
     */
    private void update()
    {
      int majorAxis = getMajorAxis();
      boolean minorUpdated = false;
      synchronized (this)
        {
          if (! minorValid)
            {
              int minorAxis = getMinorAxis();
              minimum = childView.getMinimumSpan(minorAxis);
              preferred = childView.getPreferredSpan(minorAxis);
              maximum = childView.getMaximumSpan(minorAxis);
              minorValid = true;
              minorUpdated = true;
            }
        }
      if (minorUpdated)
        minorRequirementChange(this);

      boolean majorUpdated = false;
      float delta = 0.0F;
      synchronized (this)
        {
          if (! majorValid)
            {
              float oldSpan = majorSpan;
              majorSpan = childView.getPreferredSpan(majorAxis);
              delta = majorSpan - oldSpan;
              majorValid = true;
              majorUpdated = true;
            }
        }
      if (majorUpdated)
        {
          majorRequirementChange(this, delta);
          locator.childChanged(this);
        }

      synchronized (this)
        {
          if (! childSizeValid)
            {
              float w;
              float h;
              if (majorAxis == X_AXIS)
                {
                  w = majorSpan;
                  h = getMinorSpan();
                }
              else
                {
                  w = getMinorSpan();
                  h = majorSpan;
                }
              childSizeValid = true;
              childView.setSize(w, h);
            }
        }
    }

    /**
     * Returns the span of the child view along the minor layout axis.
     *
     * @return the span of the child view along the minor layout axis
     */
    public float getMinorSpan()
    {
      float retVal;
      if (maximum < minorSpan)
        retVal = maximum;
      else
        retVal = Math.max(minimum, minorSpan);
      return retVal;
    }

    /**
     * Returns the offset of the child view along the minor layout axis.
     *
     * @return the offset of the child view along the minor layout axis
     */
    public float getMinorOffset()
    {
      float retVal;
      if (maximum < minorSpan)
        {
          float align = childView.getAlignment(getMinorAxis());
          retVal = ((minorSpan - maximum) * align);
        }
      else
        retVal = 0f;

      return retVal;
    }

    /**
     * Returns the span of the child view along the major layout axis.
     *
     * @return the span of the child view along the major layout axis
     */

    public float getMajorSpan()
    {
      return majorSpan;
    }

    /**
     * Returns the offset of the child view along the major layout axis.
     *
     * @return the offset of the child view along the major layout axis
     */
    public float getMajorOffset()
    {
      return majorOffset;
    }

    /**
     * Sets the offset of the child view along the major layout axis. This
     * should only be called by the ChildLocator of that child view.
     *
     * @param offset the offset to set
     */
    public void setMajorOffset(float offset)
    {
      majorOffset = offset;
    }

    /**
     * Mark the preferences changed for that child. This forwards to
     * {@link AsyncBoxView#preferenceChanged}.
     *
     * @param width <code>true</code> if the width preference has changed
     * @param height <code>true</code> if the height preference has changed
     */
    public void preferenceChanged(boolean width, boolean height)
    {
      if (getMajorAxis() == X_AXIS)
        {
          if (width)
            majorValid = false;
          if (height)
            minorValid = false;
        }
      else
        {
          if (width)
            minorValid = false;
          if (height)
            majorValid = false;
        }
      childSizeValid = false;
    }
  }

  /**
   * Flushes the requirements changes upwards asynchronously.
   */
  private class FlushTask implements Runnable
  {
    /**
     * Starts the flush task. This obtains a readLock on the document
     * and then flushes all the updates using
     * {@link AsyncBoxView#flushRequirementChanges()} after updating the
     * requirements.
     */
    public void run()
    {
      try
        {
          // Acquire a lock on the document.
          Document doc = getDocument();
          if (doc instanceof AbstractDocument)
            {
              AbstractDocument abstractDoc = (AbstractDocument) doc;
              abstractDoc.readLock();
            }

          int n = getViewCount();
          if (minorChanged && (n > 0))
            {
              LayoutQueue q = getLayoutQueue();
              ChildState min = getChildState(0);
              ChildState pref = getChildState(0);
              for (int i = 1; i < n; i++)
                {
                  ChildState cs = getChildState(i);
                  if (cs.minimum > min.minimum)
                    min = cs;
                  if (cs.preferred > pref.preferred)
                    pref = cs;
                }
              synchronized (AsyncBoxView.this)
              {
                minReq = min;
                prefReq = pref;
              }
            }

          flushRequirementChanges();
        }
      finally
      {
        // Release the lock on the document.
        Document doc = getDocument();
        if (doc instanceof AbstractDocument)
          {
            AbstractDocument abstractDoc = (AbstractDocument) doc;
            abstractDoc.readUnlock();
          }
      }
    }

  }

  /**
   * The major layout axis.
   */
  private int majorAxis;

  /**
   * The top inset.
   */
  private float topInset;

  /**
   * The bottom inset.
   */
  private float bottomInset;

  /**
   * The left inset.
   */
  private float leftInset;

  /**
   * Indicates if the major span should be treated as beeing estimated or not.
   */
  private boolean estimatedMajorSpan;

  /**
   * The right inset.
   */
  private float rightInset;

  /**
   * The children and their layout statistics.
   */
  private ArrayList childStates;

  /**
   * The currently changing child state. May be null if there is no child state
   * updating at the moment. This is package private to avoid a synthetic
   * accessor method inside ChildState.
   */
  ChildState changing;

  /**
   * Represents the minimum requirements. This is used in
   * {@link #getMinimumSpan(int)}.
   */
  ChildState minReq;

  /**
   * Represents the minimum requirements. This is used in
   * {@link #getPreferredSpan(int)}.
   */
  ChildState prefReq;

  /**
   * Indicates that the major axis requirements have changed.
   */
  private boolean majorChanged;

  /**
   * Indicates that the minor axis requirements have changed. This is package
   * private to avoid synthetic accessor method.
   */
  boolean minorChanged;

  /**
   * The current span along the major layout axis. This is package private to
   * avoid synthetic accessor method.
   */
  float majorSpan;

  /**
   * The current span along the minor layout axis. This is package private to
   * avoid synthetic accessor method.
   */
  float minorSpan;

  /**
   * This tasked is placed on the layout queue to flush updates up to the
   * parent view.
   */
  private Runnable flushTask;

  /**
   * The child locator for this view.
   */
  protected ChildLocator locator;

  /**
   * Creates a new <code>AsyncBoxView</code> that represents the specified
   * element and layouts its children along the specified axis.
   *
   * @param elem the element
   * @param axis the layout axis
   */
  public AsyncBoxView(Element elem, int axis)
  {
    super(elem);
    majorAxis = axis;
    childStates = new ArrayList();
    flushTask = new FlushTask();
    locator = new ChildLocator();
    minorSpan = Short.MAX_VALUE;
  }

  /**
   * Returns the major layout axis.
   *
   * @return the major layout axis
   */
  public int getMajorAxis()
  {
    return majorAxis;
  }

  /**
   * Returns the minor layout axis, that is the axis orthogonal to the major
   * layout axis.
   *
   * @return the minor layout axis
   */
  public int getMinorAxis()
  {
    return majorAxis == X_AXIS ? Y_AXIS : X_AXIS;
  }

  /**
   * Returns the view at the specified <code>index</code>.
   *
   * @param index the index of the requested child view
   *
   * @return the view at the specified <code>index</code>
   */
  public View getView(int index)
  {
    View view = null;
    synchronized(childStates)
      {
        if ((index >= 0) && (index < childStates.size()))
          {
            ChildState cs = (ChildState) childStates.get(index);
            view = cs.getChildView();
          }
      }
    return view;
  }

  /**
   * Returns the number of child views.
   *
   * @return the number of child views
   */
  public int getViewCount()
  {
    synchronized(childStates)
    {
      return childStates.size();
    }
  }

  /**
   * Returns the view index of the child view that represents the specified
   * model position.
   *
   * @param pos the model position for which we search the view index
   * @param bias the bias
   *
   * @return the view index of the child view that represents the specified
   *         model position
   */
  public int getViewIndex(int pos, Position.Bias bias)
  {
    int retVal = -1;

    if (bias == Position.Bias.Backward)
      pos = Math.max(0, pos - 1);

    // TODO: A possible optimization would be to implement a binary search
    // here.
    int numChildren = childStates.size();
    if (numChildren > 0)
      {
        for (int i = 0; i < numChildren; ++i)
          {
            View child = ((ChildState) childStates.get(i)).getChildView();
            if (child.getStartOffset() <= pos && child.getEndOffset() > pos)
              {
                retVal = i;
                break;
              }
          }
      }
    return retVal;
  }

  /**
   * Returns the top inset.
   *
   * @return the top inset
   */
  public float getTopInset()
  {
    return topInset;
  }

  /**
   * Sets the top inset.
   *
   * @param top the top inset
   */
  public void setTopInset(float top)
  {
    topInset = top;
  }

  /**
   * Returns the bottom inset.
   *
   * @return the bottom inset
   */
  public float getBottomInset()
  {
    return bottomInset;
  }

  /**
   * Sets the bottom inset.
   *
   * @param bottom the bottom inset
   */
  public void setBottomInset(float bottom)
  {
    bottomInset = bottom;
  }

  /**
   * Returns the left inset.
   *
   * @return the left inset
   */
  public float getLeftInset()
  {
    return leftInset;
  }

  /**
   * Sets the left inset.
   *
   * @param left the left inset
   */
  public void setLeftInset(float left)
  {
    leftInset = left;
  }

  /**
   * Returns the right inset.
   *
   * @return the right inset
   */
  public float getRightInset()
  {
    return rightInset;
  }

  /**
   * Sets the right inset.
   *
   * @param right the right inset
   */
  public void setRightInset(float right)
  {
    rightInset = right;
  }

  /**
   * Loads the child views of this view. This is triggered by
   * {@link #setParent(View)}.
   *
   * @param f the view factory to build child views with
   */
  protected void loadChildren(ViewFactory f)
  {
    Element e = getElement();
    int n = e.getElementCount();
    if (n > 0)
      {
        View[] added = new View[n];
        for (int i = 0; i < n; i++)
          {
            added[i] = f.create(e.getElement(i));
          }
        replace(0, 0, added);
      }
  }
  
  /**
   * Returns the span along an axis that is taken up by the insets.
   *
   * @param axis the axis
   *
   * @return the span along an axis that is taken up by the insets
   *
   * @since 1.4
   */
  protected float getInsetSpan(int axis)
  {
    float span;
    if (axis == X_AXIS)
      span = leftInset + rightInset;
    else
      span = topInset + bottomInset;
    return span;
  }

  /**
   * Sets the <code>estimatedMajorSpan</code> property that determines if
   * the major span should be treated as beeing estimated.
   *
   * @param estimated if the major span should be treated as estimated or not
   *
   * @since 1.4
   */
  protected void setEstimatedMajorSpan(boolean estimated)
  {
    estimatedMajorSpan = estimated;
  }

  /**
   * Determines whether the major span should be treated as estimated or as
   * beeing accurate.
   *
   * @return <code>true</code> if the major span should be treated as
   *         estimated, <code>false</code> if the major span should be treated
   *         as accurate
   *
   * @since 1.4
   */
  protected boolean getEstimatedMajorSpan()
  {
    return estimatedMajorSpan;
  }

  /**
   * Receives notification from the child states that the requirements along
   * the minor axis have changed.
   *
   * @param cs the child state from which this notification is messaged
   */
  protected synchronized void minorRequirementChange(ChildState cs)
  {
    minorChanged = true;
  }

  /**
   * Receives notification from the child states that the requirements along
   * the major axis have changed.
   *
   * @param cs the child state from which this notification is messaged
   */
  protected void majorRequirementChange(ChildState cs, float delta)
  {
    if (! estimatedMajorSpan)
      majorSpan += delta;
    majorChanged = true;
  }

  /**
   * Sets the parent for this view. This calls loadChildren if
   * <code>parent</code> is not <code>null</code> and there have not been any
   * child views initializes.
   *
   * @param parent the new parent view; <code>null</code> if this view is
   *        removed from the view hierarchy
   *
   * @see View#setParent(View)
   */
  public void setParent(View parent)
  {
    super.setParent(parent);
    if ((parent != null) && (getViewCount() == 0))
      {
        ViewFactory f = getViewFactory();
        loadChildren(f);
      }
  }

  /**
   * Sets the size of this view. This is ususally called before {@link #paint}
   * is called to make sure the view has a valid layout.
   *
   * This implementation queues layout requests for every child view if the
   * minor axis span has changed. (The major axis span is requested to never
   * change for this view).
   *
   * @param width the width of the view
   * @param height the height of the view
   */
  public void setSize(float width, float height)
  {
    float targetSpan;
    if (majorAxis == X_AXIS)
      targetSpan = height - getTopInset() - getBottomInset();
    else
      targetSpan = width - getLeftInset() - getRightInset();

    if (targetSpan != minorSpan)
      {
        minorSpan = targetSpan;

        int n = getViewCount();
        LayoutQueue q = getLayoutQueue();
        for (int i = 0; i < n; i++)
          {
            ChildState cs = getChildState(i);
            cs.childSizeValid = false;
            q.addTask(cs);
          }
        q.addTask(flushTask);
    }
  }

  /**
   * Replaces child views with new child views.
   *
   * This creates ChildState objects for all the new views and adds layout
   * requests for them to the layout queue.
   *
   * @param offset the offset at which to remove/insert
   * @param length the number of child views to remove
   * @param views the new child views to insert
   */
  public void replace(int offset, int length, View[] views)
  {
    synchronized(childStates)
      {
        LayoutQueue q = getLayoutQueue();
        for (int i = 0; i < length; i++)
          childStates.remove(offset);

        for (int i = views.length - 1; i >= 0; i--)
          childStates.add(offset, createChildState(views[i]));

        // We need to go through the new child states _after_ they have been
        // added to the childStates list, otherwise the layout tasks may find
        // an incomplete child list. That means we have to loop through
        // them again, but what else can we do?
        if (views.length != 0)
          {
            for (int i = 0; i < views.length; i++)
              {
                ChildState cs = (ChildState) childStates.get(i + offset);
                cs.getChildView().setParent(this);
                q.addTask(cs);
              }
            q.addTask(flushTask);
          }
      }
  }

  /**
   * Paints the view. This requests the {@link ChildLocator} to paint the views
   * after setting the allocation on it.
   *
   * @param g the graphics context to use
   * @param s the allocation for this view
   */
  public void paint(Graphics g, Shape s)
  {
    synchronized (locator)
      {
        locator.setAllocation(s);
        locator.paintChildren(g);
      }
  }

  /**
   * Returns the preferred span of this view along the specified layout axis.
   *
   * @return the preferred span of this view along the specified layout axis
   */
  public float getPreferredSpan(int axis)
  {
    float retVal;
    if (majorAxis == axis)
      retVal = majorSpan;

    else if (prefReq != null)
      {
        View child = prefReq.getChildView();
        retVal = child.getPreferredSpan(axis);
      }

    // If we have no layout information yet, then return insets + 30 as
    // an estimation.
    else
      {
        if (axis == X_AXIS)
          retVal = getLeftInset() + getRightInset() + 30;
        else
          retVal = getTopInset() + getBottomInset() + 30;
      }
    return retVal;
  }

  /**
   * Maps a model location to view coordinates.
   *
   * @param pos the model location
   * @param a the current allocation of this view
   * @param b the bias
   *
   * @return the view allocation for the specified model location
   */
  public Shape modelToView(int pos, Shape a, Bias b)
    throws BadLocationException
  {
    int index = getViewIndexAtPosition(pos, b);
    Shape ca = locator.getChildAllocation(index, a);

    ChildState cs = getChildState(index);
    synchronized (cs)
      {
        View cv = cs.getChildView();
        Shape v = cv.modelToView(pos, ca, b);
        return v;
      }
  }

  /**
   * Maps view coordinates to a model location.
   *
   * @param x the x coordinate (relative to <code>a</code>)
   * @param y the y coordinate (relative to <code>a</code>)
   * @param b holds the bias of the model location on method exit
   *
   * @return the model location for the specified view location
   */
  public int viewToModel(float x, float y, Shape a, Bias[] b)
  {
    int pos;
    int index;
    Shape ca;

    synchronized (locator)
      {
        index = locator.getViewIndexAtPoint(x, y, a);
        ca = locator.getChildAllocation(index, a);
      }

    ChildState cs = getChildState(index);
    synchronized (cs)
      {
        View v = cs.getChildView();
        pos = v.viewToModel(x, y, ca, b);
      }
    return pos;
  }

  /**
   * Returns the child allocation for the child view with the specified
   * <code>index</code>.
   *
   * @param index the index of the child view
   * @param a the current allocation of this view
   *
   * @return the allocation of the child view
   */
  public Shape getChildAllocation(int index, Shape a)
  {
    Shape ca = locator.getChildAllocation(index, a);
    return ca;
  }

  /**
   * Returns the maximum span of this view along the specified axis.
   * This is implemented to return the <code>preferredSpan</code> for the
   * major axis (that means the box can't be resized along the major axis) and
   * {@link Short#MAX_VALUE} for the minor axis.
   *
   * @param axis the axis
   *
   * @return the maximum span of this view along the specified axis
   */
  public float getMaximumSpan(int axis)
  {
    float max;
    if (axis == majorAxis)
      max = getPreferredSpan(axis);
    else
      max = Short.MAX_VALUE;
    return max;
  }

  /**
   * Returns the minimum span along the specified axis.
   */
  public float getMinimumSpan(int axis)
  {
    float min;
    if (axis == majorAxis)
      min = getPreferredSpan(axis);
    else
      {
        if (minReq != null)
          {
            View child = minReq.getChildView();
            min = child.getMinimumSpan(axis);
          }
        else
          {
            // No layout information yet. Return insets + 5 as some kind of
            // estimation.
            if (axis == X_AXIS)
              min = getLeftInset() + getRightInset() + 5;
            else
              min = getTopInset() + getBottomInset() + 5;
          }
      }
    return min;
  }

  /**
   * Receives notification that one of the child views has changed its
   * layout preferences along one or both axis.
   *
   * This queues a layout request for that child view if necessary.
   *
   * @param view the view that has changed its preferences
   * @param width <code>true</code> if the width preference has changed
   * @param height <code>true</code> if the height preference has changed
   */
  public synchronized void preferenceChanged(View view, boolean width,
                                             boolean height)
  {
    if (view == null)
      getParent().preferenceChanged(this, width, height);
    else
      {
        if (changing != null)
          {
            View cv = changing.getChildView();
            if (cv == view)
              {
                changing.preferenceChanged(width, height);
                return;
              }
          }
        int index = getViewIndexAtPosition(view.getStartOffset(), 
                                           Position.Bias.Forward);
        ChildState cs = getChildState(index);
        cs.preferenceChanged(width, height);
        LayoutQueue q = getLayoutQueue();
        q.addTask(cs);
        q.addTask(flushTask);
      }    
  }

  /**
   * Updates the layout for this view. This is implemented to trigger
   * {@link ChildLocator#childChanged} for the changed view, if there is
   * any.
   *
   * @param ec the element change, may be <code>null</code> if there were
   *        no changes to the element of this view
   * @param e the document event
   * @param a the current allocation of this view
   */
  protected void updateLayout(DocumentEvent.ElementChange ec, 
                              DocumentEvent e, Shape a)
  {
    if (ec != null)
      {
        int index = Math.max(ec.getIndex() - 1, 0);
        ChildState cs = getChildState(index);
        locator.childChanged(cs);
      }
  }
  
  
  /**
   * Returns the <code>ChildState</code> object associated with the child view
   * at the specified <code>index</code>.
   *
   * @param index the index of the child view for which to query the state
   *
   * @return the child state for the specified child view
   */
  protected ChildState getChildState(int index) {
    synchronized (childStates)
      {
        return (ChildState) childStates.get(index);
      }
  }

  /**
   * Returns the <code>LayoutQueue</code> used for layouting the box view.
   * This simply returns {@link LayoutQueue#getDefaultQueue()}.
   *
   * @return the <code>LayoutQueue</code> used for layouting the box view
   */
  protected LayoutQueue getLayoutQueue()
  {
    return LayoutQueue.getDefaultQueue();
  }

  /**
   * Returns the child view index of the view that represents the specified
   * position in the document model.
   * 
   * @param pos the position in the model
   * @param b the bias
   *
   * @return the child view index of the view that represents the specified
   *         position in the document model
   */
  protected synchronized int getViewIndexAtPosition(int pos, Position.Bias b)
  {
    if (b == Position.Bias.Backward)
      pos = Math.max(0, pos - 1);
    Element elem = getElement();
    return elem.getElementIndex(pos);
  }

  /**
   * Creates a <code>ChildState</code> object for the specified view.
   *
   * @param v the view for which to create a child state object
   *
   * @return the created child state
   */
  protected ChildState createChildState(View v)
  {
    return new ChildState(v);
  }

  /**
   * Flushes the requirements changes upwards to the parent view. This is
   * called from the layout thread.
   */
  protected synchronized void flushRequirementChanges()
  {
    if (majorChanged || minorChanged)
      {
        View p = getParent();
        if (p != null)
          {
            boolean horizontal;
            boolean vertical;
            if (majorAxis == X_AXIS)
              {
                horizontal = majorChanged;
                vertical = minorChanged;
              }
            else
              {
                vertical = majorChanged;
                horizontal = minorChanged;
              }

            p.preferenceChanged(this, horizontal, vertical);
            majorChanged = false;
            minorChanged = false;

            Component c = getContainer();
            if (c != null)
              c.repaint();
          }
      }
  }
}