AWT/Swing merge from GNU Classpath.

From-SVN: r56147

1 files changed, 435 insertions, 309 deletions

diff --git a/libjava/java/awt/ScrollPane.java b/libjava/java/awt/ScrollPane.java
index dd657ac..546f8e6 100644
--- a/libjava/java/awt/ScrollPane.java
+++ b/libjava/java/awt/ScrollPane.java
@@ -1,340 +1,466 @@
-/* Copyright (C) 2000  Free Software Foundation
+/* ScrollPane.java -- Scrolling window
+   Copyright (C) 1999 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., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 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. */
 
-   This file is part of libgcj.
-
-This software is copyrighted work licensed under the terms of the
-Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
-details.  */
 
 package java.awt;
 
-import java.awt.event.AdjustmentListener;
 import java.awt.peer.ScrollPanePeer;
+import java.awt.peer.ContainerPeer;
+import java.awt.peer.ComponentPeer;
+
+/**
+  * This widget provides a scrollable region that allows a single 
+  * subcomponent to be viewed through a smaller window.
+  *
+  * @author Aaron M. Renn (arenn@urbanophile.com)
+  */
+public class ScrollPane extends Container implements java.io.Serializable
+{
+
+/*
+ * Static Variables
+ */
+
+/**
+  * Constant indicating that scrollbars are created as needed in this
+  * windows.
+  */
+public static final int SCROLLBARS_AS_NEEDED = 0;
+
+/**
+  * Constant indicating that scrollbars are always displayed in this
+  * window.
+  */
+public static final int SCROLLBARS_ALWAYS = 1;
+
+/**
+  * Constant indicating that scrollbars are never displayed in this window.
+  */
+public static final int SCROLLBARS_NEVER = 2;
 
-/** A ScrollPane is a component that has vertical and horizontal
- * scrollbars as well as a single child which is scrolled by them.
- * @author Tom Tromey <tromey@redhat.com>
- * @date December 31, 2000
+// Serialization constant
+private static final long serialVersionUID = 7956609840827222915L;
+
+/*************************************************************************/
+
+/*
+ * Instance Variables
+ */
+
+/**
+  * @serial The horizontal scrollbar for this window.  The methods
+  * <code>setMinimum()</code>, <code>setMaximum</code>, and
+  * <code>setVisibleAmount</code> must not be called on this scrollbar.
+  */
+private ScrollPaneAdjustable hAdjustable;
+
+/**
+  * @serial The vertical scrollbar for this window.  The methods
+  * <code>setMinimum()</code>, <code>setMaximum</code>, and
+  * <code>setVisibleAmount</code> must not be called on this scrollbar.
+  */
+private ScrollPaneAdjustable vAdjustable;
+
+/**
+  * @serial Indicates when scrollbars are displayed in this window, will
+  * be one of the constants from this class.
+  */
+private int scrollbarDisplayPolicy;
+
+// Current scroll position
+private Point scrollPosition = new Point(0, 0);
+
+/*************************************************************************/
+
+/*
+ * Constructors
  */
-public class ScrollPane extends Container
+
+/**
+  * Initializes a new instance of <code>ScrollPane</code> with a default
+  * scrollbar policy of <code>SCROLLBARS_AS_NEEDED</code>.
+  */
+public
+ScrollPane()
 {
-  /** This indicates that scrollbars should only be displayed when
-   * needed.  */
-  public static final int SCROLLBARS_AS_NEEDED = 0;
-  /** This indicates that scrollbars should always be displayed.  */
-  public static final int SCROLLBARS_ALWAYS = 1;
-  /** This indicates that scrollbars should never be displayed.  */
-  public static final int SCROLLBARS_NEVER = 2;
-
-  /** Create a new ScrollPane object using the indicated scrollbar
-   * display policy.  If the policy is not specified it defaults to
-   * SCROLLBARS_AS_NEEDED.  The default size of this component is
-   * 100x100.
-   * @param policy The scrollbar display policy
-   */
-  public ScrollPane ()
-  {
-    this (SCROLLBARS_AS_NEEDED);
-  }
-
-  public ScrollPane (int policy)
-  {
-    if (policy != SCROLLBARS_AS_NEEDED
-	&& policy != SCROLLBARS_ALWAYS
-	&& policy != SCROLLBARS_NEVER)
-      throw new IllegalArgumentException ("invalid value for policy");
-
-    this.policy = policy;
-    setSize (100, 100);
-  }
-
-  /** Add a component to this ScrollPane.
-   * @param comp The component to add
-   * @param constraints Constraints.  This is ignored.
-   * @param pos Position.  This must be <= 0, but is otherwise ignored.
-   */
-  protected final void addImpl (Component comp, Object constraints,
-				int pos)
-  {
-    if (pos > 0)
-      throw new IllegalArgumentException ("pos must be <= 0");
-
-    if (ncomponents > 0)
-      remove (component[0]);
-
-    if (comp.isLightweight ())
-      {
-	Panel p = new Panel ();
-	p.add (comp);
-	comp = p;
-      }
-
-    super.addImpl (comp, constraints, pos);
-  }
-
-  /** This creates the component's peer.  */
-  public void addNotify ()
-  {
-    if (peer == null)
-      peer = getToolkit ().createScrollPane (this);
-    super.addNotify ();
-  }
-
-  /** Lays out the components in this container.  */
-  public void doLayout ()
-  {
-    ScrollPanePeer spp = (ScrollPanePeer) peer;
-    Dimension c = component[0].getPreferredSize ();
-    component[0].setSize (c.width, c.height);
-    spp.childResized (c.width, c.height);
-    // Update the scrollbar position to the closest valid value.
-    setScrollPosition (hscroll.getValue (), vscroll.getValue ());
-  }
-
-  /** Returns an Adjustable representing the horizontal scrollbar.
-   * The methods setMaximum, setMinimum, and setVisibleAmount should
-   * not be called on this Adjustable.  They will throw AWTError if
-   * called.
-   */
-  public Adjustable getHAdjustable ()
-  {
-    return hscroll;
-  }
-
-  /** Returns the height of the horizontal scrollbar.  */
-  public int getHScrollbarHeight ()
-  {
-    if (peer == null)
-      return 0;
-    ScrollPanePeer spp = (ScrollPanePeer) peer;
-    return spp.getHScrollbarHeight ();
-  }
-
-  /** Returns the scrollbar display policy.  */
-  public int getScrollbarDisplayPolicy ()
-  {
-    return policy;
-  }
-
-  /** Returns the viewport's scroll position.  */
-  public Point getScrollPosition ()
-  {
-    return new Point (hscroll.getValue (), vscroll.getValue ());
-  }
-
-  /** Returns an Adjustable representing the vertical scrollbar.
-   * The methods setMaximum, setMinimum, and setVisibleAmount should
-   * not be called on this Adjustable.  They will throw AWTError if
-   * called.
-   */
-  public Adjustable getVAdjustable ()
-  {
-    return vscroll;
-  }
-
-  /** Returns the size of the viewport.  */
-  public Dimension getViewportSize ()
-  {
-    // Note: according to the online docs, the Insets are
-    // automatically updated by the peer to include the scrollbar
-    // sizes.
-    Insets ins = getInsets ();
-    int myw = width - ins.left - ins.right;
-    int myh = height - ins.top - ins.bottom;
-
-    Dimension cs;
-    if (ncomponents > 0)
-      cs = component[0].getPreferredSize ();
-    else
-      cs = new Dimension (myw, myh);
-
-    // A little optimization -- reuse the Dimension.
-    cs.setSize (myw, myh);
-    return cs;
-  }
-
-  /** Returns the width of the vertical scrollbar.  */
-  public int getVScrollbarWidth ()
-  {
-    if (peer == null)
-      return 0;
-    ScrollPanePeer spp = (ScrollPanePeer) peer;
-    return spp.getVScrollbarWidth ();
-  }
-
-  /** Generates a String representation of this ScrollPane's state.  */
-  public String paramString ()
-  {
-    return ("[" + getClass ().getName ()
-	    + ": " + ((ncomponents > 0) ? component[0].paramString () : "")
-	    + "]");
-  }
-
-  /** Set the layout manager for this component.  ScrollPane has its
-   * own layout manager and overrides this method so that the layout
-   * manager cannot be changed.
-   * @param m The new layout manager (ignored)
-   */
-  public final void setLayout (LayoutManager m)
-  {
-    // Nothing.
-  }
-
-  /** Sets the scroll position for this ScrollPane.  If the point if
-   * out of range it is silently moved within range.
-   * @param x The x coordinate
-   * @param y The y coordinate
-   */
-  public void setScrollPosition (int x, int y)
-  {
-    // According to the JCL we throw a NullPointerException if there
-    // is no child.
-    if (ncomponents == 0)
-      throw new NullPointerException ("no child in ScrollPane");
-
-    Dimension child_d = component[0].getPreferredSize ();
-    Dimension our_d = getViewportSize ();
-
-    int xmax = Math.max (0, child_d.width - our_d.width);
-    int ymax = Math.max (0, child_d.height - our_d.height);
-
-    if (x < 0)
-      x = 0;
-    else if (x > xmax)
-      x = xmax;
-    if (y < 0)
-      y = 0;
-    else if (y > ymax)
-      y = ymax;
-
-    ScrollPanePeer spp = (ScrollPanePeer) peer;
-    spp.setScrollPosition (x, y);
-  }
-
-  /** Sets the scroll position for this ScrollPane.  If the point if
-   * out of range it is silently moved within range.
-   * @param p The new point
-   */
-  public void setScrollPosition (Point p)
-  {
-    setScrollPosition (p.x, p.y);
-  }
-
-  // This implements the Adjustable for each scrollbar.  The
-  // expectation is that the peer will look at these objects directly
-  // and modify the values in them when the user manipulates the
-  // scrollbars.  This has to be done from CNI to bypass Java
-  // protection rules.  The peer should also take care of calling the
-  // adjustment listeners.
-  class ScrollPaneAdjustable implements Adjustable
-  {
-    AdjustmentListener listeners;
-    int orient;
-    int unit;
-    int block;
-    int value;
-
-    public ScrollPaneAdjustable (int orient)
-    {
-      this.orient = orient;
-    }
+  this(SCROLLBARS_AS_NEEDED);
+}
 
-    public void addAdjustmentListener (AdjustmentListener l)
-    {
-      listeners = AWTEventMulticaster.add (listeners, l);
-    }
+/*************************************************************************/
+
+/**
+  * Initializes a new instance of <code>ScrollPane</code> with the
+  * specified scrollbar policy.
+  *
+  * @param scrollbarDisplayPolicy When to display scrollbars, which must
+  * be one of the constants defined in this class.
+  */
+public
+ScrollPane(int scrollbarDisplayPolicy)
+{
+  this.scrollbarDisplayPolicy = scrollbarDisplayPolicy;
 
-    public int getBlockIncrement ()
+  if ((scrollbarDisplayPolicy != SCROLLBARS_ALWAYS) ||
+      (scrollbarDisplayPolicy != SCROLLBARS_AS_NEEDED) ||
+      (scrollbarDisplayPolicy != SCROLLBARS_NEVER))
+    throw new IllegalArgumentException("Bad scrollbarDisplayPolicy: " +
+                                       scrollbarDisplayPolicy);
+
+  if (scrollbarDisplayPolicy != SCROLLBARS_NEVER)
     {
-      return block;
+      hAdjustable = new ScrollPaneAdjustable(Scrollbar.HORIZONTAL);
+      vAdjustable = new ScrollPaneAdjustable(Scrollbar.VERTICAL);
     }
+}
 
-    public int getMaximum ()
-    {
-      Dimension child_d = component[0].getPreferredSize ();
-      Dimension our_d = getViewportSize ();
+/*************************************************************************/
 
-      int xmax = Math.max (0, child_d.width - our_d.width);
-      int ymax = Math.max (0, child_d.height - our_d.height);
+/*
+ * Instance Variables
+ */
 
-      return (orient == Adjustable.HORIZONTAL) ? xmax : ymax;
-    }
+/**
+  * Returns the current scrollbar display policy.
+  *
+  * @return The current scrollbar display policy.
+  */
+public int
+getScrollbarDisplayPolicy()
+{
+  return(scrollbarDisplayPolicy);
+}
 
-    public int getMinimum ()
-    {
-      return 0;
-    }
+/*************************************************************************/
+
+/**
+  * Returns the horizontal scrollbar for this object.  If the scrollbar
+  * display policy is set to <code>SCROLLBARS_NEVER</code> then this
+  * will be <code>null</code>.
+  *
+  * @return The horizontal scrollbar for this window.
+  */
+public Adjustable
+getHAdjustable()
+{
+  return(hAdjustable);
+}
 
-    public int getOrientation ()
-    {
-      return orient;
-    }
+/*************************************************************************/
+
+/**
+  * Returns the vertical scrollbar for this object.  If the scrollbar
+  * display policy is set to <code>SCROLLBARS_NEVER</code> then this
+  * will be <code>null</code>.
+  *
+  * @return The horizontal scrollbar for this window.
+  */
+public Adjustable
+getVAdjustable()
+{
+  return(vAdjustable);
+}
 
-    public int getUnitIncrement ()
-    {
-      return unit;
-    }
+/*************************************************************************/
 
-    public int getValue ()
-    {
-      return value;
-    }
+/**
+  * Returns the current viewport size.  The viewport is the region of
+  * this object's window where the child is actually displayed.
+  *
+  * @return The viewport size.
+  */
+public Dimension
+getViewportSize()
+{
+  Dimension viewsize = getSize();
+  Insets insets = getInsets();
+  viewsize.width = viewsize.width - (insets.left + insets.right);
+  viewsize.height = viewsize.height - (insets.top + insets.bottom);
 
-    public int getVisibleAmount ()
-    {
-      Dimension d = getViewportSize ();
-      return (orient == Adjustable.HORIZONTAL) ? d.width : d.height;
-    }
+  ScrollPaneAdjustable v = (ScrollPaneAdjustable)getVAdjustable();
+  ScrollPaneAdjustable h = (ScrollPaneAdjustable)getHAdjustable();
 
-    public void removeAdjustmentListener (AdjustmentListener l)
-    {
-      listeners = AWTEventMulticaster.remove (listeners, l);
-    }
+  if ((v != null) && v.isVisible())
+    viewsize.width = viewsize.width - v.getSize().width;
+  if ((h != null) && h.isVisible())
+    viewsize.height = viewsize.height - v.getSize().height;
 
-    public void setBlockIncrement (int b)
-    {
-      throw new AWTError ("can't use setBlockIncrement on this Adjustable");
-    }
+  return(viewsize);
+}
 
-    public void setMaximum (int max)
-    {
-      throw new AWTError ("can't use setMaximum on this Adjustable");
-    }
+/*************************************************************************/
 
-    public void setMinimum (int min)
-    {
-      throw new AWTError ("can't use setMinimum on this Adjustable");
-    }
+/**
+  * Returns the height of a horizontal scrollbar.
+  *
+  * @return The height of a horizontal scrollbar.
+  */
+public int
+getHScrollbarHeight()
+{
+  ScrollPanePeer spp = (ScrollPanePeer)getPeer();
+  if (spp != null)
+    return(spp.getHScrollbarHeight());
+  else
+    return(0); // FIXME: What to do here?
+}
 
-    public void setUnitIncrement (int u)
-    {
-      unit = u;
-      if (peer != null)
-	{
-	  ScrollPanePeer spp = (ScrollPanePeer) peer;
-	  spp.setUnitIncrement (this, u);
-	}
-    }
+/*************************************************************************/
 
-    public void setValue (int v)
-    {
-      value = v;
-      if (peer != null)
-	{
-	  ScrollPanePeer spp = (ScrollPanePeer) peer;
-	  spp.setValue (this, v);
-	}
-    }
+/**
+  * Returns the width of a vertical scrollbar.
+  *
+  * @return The width of a vertical scrollbar.
+  */
+public int
+getVScrollbarWidth()
+{
+  ScrollPanePeer spp = (ScrollPanePeer)getPeer();
+  if (spp != null)
+    return(spp.getVScrollbarWidth());
+  else
+    return(0); // FIXME: What to do here?
+}
+
+/*************************************************************************/
+
+/**
+  * Returns the current scroll position of the viewport.
+  *
+  * @return The current scroll position of the viewport.
+  */
+public Point
+getScrollPosition()
+{
+  int x = 0;
+  int y = 0;
+
+  Adjustable v = getVAdjustable();
+  Adjustable h = getHAdjustable();
+
+  if (v != null)
+    y = v.getValue();
+  if (h != null)
+    x = h.getValue();
+
+  return(new Point(x, y));
+}
+
+/*************************************************************************/
+
+/**
+  * Sets the scroll position to the specified value.
+  *
+  * @param scrollPosition The new scrollPosition.
+  *
+  * @exception IllegalArgumentException If the specified value is outside
+  * the legal scrolling range.
+  */
+public void
+setScrollPosition(Point scrollPosition) throws IllegalArgumentException
+{
+  setScrollPosition(scrollPosition.x, scrollPosition.y);
+}
+
+/*************************************************************************/
+
+/**
+  * Sets the scroll position to the specified value.
+  *
+  * @param x The new X coordinate of the scroll position.
+  * @param y The new Y coordinate of the scroll position.
+  *
+  * @exception IllegalArgumentException If the specified value is outside
+  * the legal scrolling range.
+  */
+public void
+setScrollPosition(int x, int y)
+{
+  Adjustable h = getHAdjustable();
+  Adjustable v = getVAdjustable();
+
+  if (h != null)
+    h.setValue(x);
+  if (v != null)
+    v.setValue(y);
+
+  ScrollPanePeer spp = (ScrollPanePeer)getPeer();
+  if (spp != null)
+    spp.setScrollPosition(x, y);
+}
+
+/*************************************************************************/
+
+/**
+  * Notifies this object that it should create its native peer.
+  */
+public void
+addNotify()
+{
+  if (getPeer() == null)
+    return;
+
+  setPeer((ComponentPeer)getToolkit().createScrollPane(this));
+
+  if (hAdjustable != null)
+    hAdjustable.addNotify();
+  if (vAdjustable != null)
+    vAdjustable.removeNotify();
+}
+
+/*************************************************************************/
+
+/**
+  * Notifies this object that it should destroy its native peers.
+  */
+public void
+removeNotify()
+{
+  if (hAdjustable != null)
+    hAdjustable.removeNotify();
+  if (vAdjustable != null)
+    vAdjustable.removeNotify();
 
-    public void setVisibleAmount (int v)
+  super.removeNotify();
+}
+
+/*************************************************************************/
+
+/**
+  * Adds the specified child component to this container.  A 
+  * <code>ScrollPane</code> can have at most one child, so if a second
+  * one is added, then first one is removed.
+  *
+  * @param component The component to add to this container.
+  * @param constraints A list of layout constraints for this object.
+  * @param index The index at which to add the child, which is ignored
+  * in this implementation.
+  */
+public final void
+addImpl(Component component, Object constraints, int index)
+{
+  Component[] list = getComponents();
+  if ((list != null) && (list.length > 0))
+    remove(list[0]);
+
+  super.addImpl(component, constraints, -1);
+
+  doLayout();
+}
+
+/*************************************************************************/
+
+/**
+  * Lays out this component.  This consists of resizing the sole child
+  * component to its perferred size.
+  */
+public void
+doLayout()
+{
+  Component[] list = getComponents();
+  if ((list != null) && (list.length > 0))
     {
-      throw new AWTError ("can't use setVisibleAmount on this Adjustable");
+      Dimension dim = list[0].getPreferredSize();
+      list[0].resize(dim);
+
+      Point p = getScrollPosition();
+      if (p.x > dim.width)
+        p.x = dim.width;
+      if (p.y > dim.height)
+        p.y = dim.height;
+
+      setScrollPosition(p);
     }
-  }
+}
+
+/*************************************************************************/
+
+/**
+  * Lays out this component.  This consists of resizing the sole child
+  * component to its perferred size.
+  *
+  * @deprecated This method is deprecated in favor of
+  * <code>doLayout()</code>.
+  */
+public void
+layout()
+{
+  doLayout();
+}
 
-  ScrollPaneAdjustable hscroll
-    = new ScrollPaneAdjustable (Adjustable.HORIZONTAL);
-  ScrollPaneAdjustable vscroll
-    = new ScrollPaneAdjustable (Adjustable.VERTICAL);
-  int policy;
+/*************************************************************************/
+
+/**
+  * This method overrides its superclass method to ensure no layout
+  * manager is set for this container.  <code>ScrollPane</code>'s do
+  * not have layout managers.
+  *
+  * @param layoutManager Ignored
+  */
+public final void
+setLayout(LayoutManager layoutManager)
+{
+  return;
+}
+
+/*************************************************************************/
+
+/**
+  * Prints all of the components in this container.
+  *
+  * @param graphics The desired graphics context for printing.
+  */
+public void
+printComponents(Graphics graphics)
+{
+  super.printComponents(graphics);
 }
+
+/*************************************************************************/
+
+/**
+  * Returns a debug string for this object.
+  *
+  * @return A debug string for this object.
+  */
+public String
+paramString()
+{
+  return(getClass().getName());
+}
+
+} // class ScrollPane 
+