/* View.java --    Copyright (C) 2002, 2004, 2005  Free Software Foundation, Inc.This file is part of GNU Classpath.GNU Classpath is free software; you can redistribute it and/or modifyit under the terms of the GNU General Public License as published bythe 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, butWITHOUT ANY WARRANTY; without even the implied warranty ofMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNUGeneral Public License for more details.You should have received a copy of the GNU General Public Licensealong with GNU Classpath; see the file COPYING.  If not, write to theFree Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA02110-1301 USA.Linking this library statically or dynamically with other modules ismaking a combined work based on this library.  Thus, the terms andconditions of the GNU General Public License cover the wholecombination.As a special exception, the copyright holders of this library give youpermission to link this library with independent modules to produce anexecutable, regardless of the license terms of these independentmodules, and to copy and distribute the resulting executable underterms of your choice, provided that you also meet, for each linkedindependent module, the terms and conditions of the license of thatmodule.  An independent module is a module which is not derived fromor based on this library.  If you modify this library, you may extendthis exception to your version of the library, but you are notobligated to do so.  If you do not wish to do so, delete thisexception statement from your version. */package javax.swing.text;import java.awt.Container;import java.awt.Graphics;import java.awt.Rectangle;import java.awt.Shape;import javax.swing.SwingConstants;import javax.swing.event.DocumentEvent;public abstract class View implements SwingConstants{  public static final int BadBreakWeight = 0;  public static final int ExcellentBreakWeight = 2000;  public static final int ForcedBreakWeight = 3000;  public static final int GoodBreakWeight = 1000;  public static final int X_AXIS = 0;  public static final int Y_AXIS = 1;      private float width, height;  private Element elt;  private View parent;  /**   * Creates a new <code>View</code> instance.   *   * @param elem an <code>Element</code> value   */  public View(Element elem)  {    elt = elem;  }  public abstract void paint(Graphics g, Shape s);  public void setParent(View parent)  {    this.parent = parent;  }      public View getParent()  {    return parent;  }      public Container getContainer()  {    View parent = getParent();    if (parent == null)      return null;    else      return parent.getContainer();  }    public Document getDocument()  {    return getElement().getDocument();  }      public Element getElement()  {    return elt;  }  public abstract float getPreferredSpan(int axis);  public int getResizeWeight(int axis)  {    return 0;  }  public float getMaximumSpan(int axis)  {    if (getResizeWeight(axis) <= 0)      return getPreferredSpan(axis);    return Integer.MAX_VALUE;  }  public float getMinimumSpan(int axis)  {    if (getResizeWeight(axis) <= 0)      return getPreferredSpan(axis);    return Integer.MAX_VALUE;  }    public void setSize(float width, float height)  {    // The default implementation does nothing.  }    public float getAlignment(int axis)  {    return 0.5f;  }  public AttributeSet getAttributes()  {    return getElement().getAttributes();  }    public boolean isVisible()  {    return true;  }  public int getViewCount()  {    return 0;  }    public View getView(int index)  {    return null;  }  public ViewFactory getViewFactory()  {    View parent = getParent();    return parent != null ? parent.getViewFactory() : null;  }  public void replace(int offset, int length, View[] views)  {    // Default implementation does nothing.  }  public void insert(int offset, View view)  {    View[] array = { view };    replace(offset, 1, array);  }  public void append(View view)  {    View[] array = { view };    int offset = getViewCount();    replace(offset, 0, array);  }  public void removeAll()  {    replace(0, getViewCount(), new View[0]);   }  public void remove(int index)  {    replace(index, 1, null);   }  public View createFragment(int p0, int p1)  {    // The default implementation doesn't support fragmentation.    return this;  }  public int getStartOffset()  {    return getElement().getStartOffset();  }  public int getEndOffset()  {    return getElement().getEndOffset();  }  public Shape getChildAllocation(int index, Shape a)  {    return null;  }    /**   * @since 1.4   */  public int getViewIndex(float x, float y, Shape allocation)  {    return -1;  }    /**   * @since 1.4   */  public String getToolTipText(float x, float y, Shape allocation)  {    int index = getViewIndex(x, y, allocation);    if (index < -1)      return null;    Shape childAllocation = getChildAllocation(index, allocation);    if (childAllocation.getBounds().contains(x, y))      return getView(index).getToolTipText(x, y, childAllocation);    return null;  }  /**   * @since 1.3   */  public Graphics getGraphics()  {    return getContainer().getGraphics();  }  public void preferenceChanged(View child, boolean width, boolean height)  {    if (parent != null)      parent.preferenceChanged(this, width, height);  }  public int getBreakWeight(int axis, float pos, float len)  {    return BadBreakWeight;  }  public View breakView(int axis, int offset, float pos, float len)  {    return this;  }  /**   * @since 1.3   */  public int getViewIndex(int pos, Position.Bias b)  {    return -1;  }  /**   * Receive notification about an insert update to the text model.   *   * The default implementation of this method does the following:   * <ul>   * <li>Call {@link #updateChildren} if the element that this view is   * responsible for has changed. This makes sure that the children can   * correctly represent the model.<li>   * <li>Call {@link #forwardUpdate}. This forwards the DocumentEvent to   * the child views.<li>   * <li>Call {@link #updateLayout}. Gives the view a chance to either   * repair its layout, reschedule layout or do nothing at all.</li>   * </ul>   *   * @param ev the DocumentEvent that describes the change   * @param shape the shape of the view   * @param vf the ViewFactory for creating child views   */  public void insertUpdate(DocumentEvent ev, Shape shape, ViewFactory vf)  {    Element el = getElement();    DocumentEvent.ElementChange ec = ev.getChange(el);    if (ec != null)      updateChildren(ec, ev, vf);    forwardUpdate(ec, ev, shape, vf);    updateLayout(ec, ev, shape);  }  /**   * Receive notification about a remove update to the text model.   *   * The default implementation of this method does the following:   * <ul>   * <li>Call {@link #updateChildren} if the element that this view is   * responsible for has changed. This makes sure that the children can   * correctly represent the model.<li>   * <li>Call {@link #forwardUpdate}. This forwards the DocumentEvent to   * the child views.<li>   * <li>Call {@link #updateLayout}. Gives the view a chance to either   * repair its layout, reschedule layout or do nothing at all.</li>   * </ul>   *   * @param ev the DocumentEvent that describes the change