obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.

1 files changed, 491 insertions, 0 deletions

diff --git a/libjava/classpath/javax/swing/ScrollPaneLayout.java b/libjava/classpath/javax/swing/ScrollPaneLayout.java
new file mode 100644
index 000000000..fa1743bed
--- /dev/null
+++ b/libjava/classpath/javax/swing/ScrollPaneLayout.java
@@ -0,0 +1,491 @@
+/* ScrollPaneLayout.java --
+   Copyright (C) 2002, 2004  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;
+
+import java.awt.Component;
+import java.awt.Container;
+import java.awt.Dimension;
+import java.awt.Insets;
+import java.awt.LayoutManager;
+import java.awt.Rectangle;
+import java.io.Serializable;
+
+import javax.swing.border.Border;
+
+/**
+ * ScrollPaneLayout
+ * @author      Andrew Selkirk
+ * @version     1.0
+ */
+public class ScrollPaneLayout
+  implements LayoutManager, ScrollPaneConstants, Serializable
+{
+  private static final long serialVersionUID = -4480022884523193743L;
+
+  public static class UIResource extends ScrollPaneLayout
+    implements javax.swing.plaf.UIResource
+  {
+    public UIResource()
+    {
+      super();
+    }
+  }
+
+  protected JViewport viewport;
+  protected JScrollBar vsb;
+  protected JScrollBar hsb;
+  protected JViewport rowHead;
+  protected JViewport colHead;
+  protected Component lowerLeft;
+  protected Component lowerRight;
+  protected Component upperLeft;
+  protected Component upperRight;
+  protected int vsbPolicy;
+  protected int hsbPolicy;
+
+  public ScrollPaneLayout()
+  {
+        // Nothing to do here.
+  }
+
+  public void syncWithScrollPane(JScrollPane scrollPane)
+  {
+    viewport = scrollPane.getViewport();
+    rowHead = scrollPane.getRowHeader();
+    colHead = scrollPane.getColumnHeader();
+    vsb = scrollPane.getVerticalScrollBar();
+    hsb = scrollPane.getHorizontalScrollBar();
+    vsbPolicy = scrollPane.getVerticalScrollBarPolicy();
+    hsbPolicy = scrollPane.getHorizontalScrollBarPolicy();
+    lowerLeft = scrollPane.getCorner(LOWER_LEFT_CORNER);
+    lowerRight = scrollPane.getCorner(LOWER_RIGHT_CORNER);
+    upperLeft = scrollPane.getCorner(UPPER_LEFT_CORNER);
+    upperRight = scrollPane.getCorner(UPPER_RIGHT_CORNER);
+  }
+
+  /**
+   * Removes an existing component.  If oldComponent is not null
+   * and is not equal to newComponent, oldComponent must be removed
+   * from its parent.
+   * @param oldComponent the old Component that may need to be removed.
+   * @param newComponent the Component to add.
+   * @return the newComponent
+   */
+  protected Component addSingletonComponent(Component oldComponent,
+                                            Component newComponent)
+  {
+    if (oldComponent != null && oldComponent != newComponent)
+      oldComponent.getParent().remove(oldComponent);
+    return newComponent;
+  }
+
+  /**
+   * Add the specified component to the layout.
+   * @param key must be one of VIEWPORT, VERTICAL_SCROLLBAR,
+   * HORIZONTAL_SCROLLBAR, ROW_HEADER, COLUMN_HEADER,
+   * LOWER_RIGHT_CORNER, LOWER_LEFT_CORNER, UPPER_RIGHT_CORNER,
+   * UPPER_LEFT_CORNER.
+   * @param component the Component to add
+   * @throws IllegalArgumentException if key is not as above
+   */
+  public void addLayoutComponent(String key, Component component)
+  {
+    if (key == VIEWPORT)
+      viewport = (JViewport) component;
+    else if (key == VERTICAL_SCROLLBAR)
+      vsb = (JScrollBar) component;
+    else if (key == HORIZONTAL_SCROLLBAR)
+      hsb = (JScrollBar) component;
+    else if (key == ROW_HEADER)
+      rowHead = (JViewport) component;
+    else if (key == COLUMN_HEADER)
+      colHead = (JViewport) component;
+    else if (key == LOWER_RIGHT_CORNER)
+      lowerRight = component;
+    else if (key == UPPER_RIGHT_CORNER)
+      upperRight = component;
+    else if (key == LOWER_LEFT_CORNER)
+      lowerLeft = component;
+    else if (key == UPPER_LEFT_CORNER)
+      upperLeft = component;
+    else
+      throw new IllegalArgumentException();
+  }
+
+  public void removeLayoutComponent(Component component)
+  {
+    if (component == viewport)
+      viewport = null;
+    else if (component == vsb)
+      vsb = null;
+    else if (component == hsb)
+      hsb = null;
+    else if (component == rowHead)
+      rowHead = null;
+    else if (component == colHead)
+      colHead = null;
+    else if (component == lowerRight)
+      lowerRight = null;
+    else if (component == upperRight)
+      upperRight = null;
+    else if (component == lowerLeft)
+      lowerLeft = null;
+    else if (component == upperLeft)
+      upperLeft = null;
+  }
+
+  public int getVerticalScrollBarPolicy()
+  {
+    return vsbPolicy;
+  }
+
+  /**
+   * Sets the vertical scrollbar policy.
+   * @param policy must be one of VERTICAL_SCROLLBAR_AS_NEEDED,
+   * VERTICAL_SCROLLBAR_NEVER, VERTICAL_SCROLLBAR_ALWAYS.
+   * @throws IllegalArgumentException if policy is not one of the valid
+   * JScrollBar policies.
+   */
+  public void setVerticalScrollBarPolicy(int policy)
+  {
+    if (policy != VERTICAL_SCROLLBAR_AS_NEEDED &&
+        policy != VERTICAL_SCROLLBAR_NEVER &&
+        policy != VERTICAL_SCROLLBAR_ALWAYS)
+      throw new IllegalArgumentException("Illegal Scrollbar Policy");
+    vsbPolicy = policy;
+  }
+
+  public int getHorizontalScrollBarPolicy()
+  {
+    return hsbPolicy;
+  }
+
+  /**
+   * Sets the horizontal scrollbar policy.
+   * @param policy must be one of HORIZONTAL_SCROLLBAR_AS_NEEDED,
+   * HORIZONTAL_SCROLLBAR_NEVER, HORIZONTAL_SCROLLBAR_ALWAYS.
+   * @throws IllegalArgumentException if policy is not one of the valid
+   * JScrollbar policies.
+   */
+  public void setHorizontalScrollBarPolicy(int policy)
+  {
+    if (policy != HORIZONTAL_SCROLLBAR_AS_NEEDED &&
+        policy != HORIZONTAL_SCROLLBAR_NEVER &&
+        policy != HORIZONTAL_SCROLLBAR_ALWAYS)
+      throw new IllegalArgumentException("Illegal Scrollbar Policy");
+    hsbPolicy = policy;
+  }
+
+  public JViewport getViewport()
+  {
+    return viewport;
+  }
+
+  public JScrollBar getHorizontalScrollBar()
+  {
+    return hsb;
+  }
+
+  public JScrollBar getVerticalScrollBar()
+  {
+    return vsb;
+  }
+
+  public JViewport getRowHeader()
+  {
+    return rowHead;
+  }
+
+  public JViewport getColumnHeader()
+  {
+    return colHead;
+  }
+
+  /**
+   * Returns the Component at the specified corner.
+   * @param key the corner.
+   * @return the Component at the specified corner, or null if
+   * key is not one of the four valid corners.
+   */
+  public Component getCorner(String key)
+  {
+    if (key == LOWER_RIGHT_CORNER)
+      return lowerRight;
+    else if (key == UPPER_RIGHT_CORNER)
+      return upperRight;
+    else if (key == LOWER_LEFT_CORNER)
+      return lowerLeft;
+    else if (key == UPPER_LEFT_CORNER)
+      return upperLeft;
+    return null;
+  }
+
+  public Dimension preferredLayoutSize(Container parent)
+  {
+    // Sun's implementation simply throws a ClassCastException if
+    // parent is no JScrollPane, so do we.
+    JScrollPane sc = (JScrollPane) parent;
+    Dimension viewportSize = viewport.getPreferredSize();
+    Dimension viewSize = viewport.getViewSize();
+    int width = viewportSize.width;
+    int height = viewportSize.height;
+
+    // horizontal scrollbar needed if the view's preferred width
+    // is larger than the viewport's preferred width
+    if (hsb != null && viewSize.width > viewportSize.width)
+      height += hsb.getPreferredSize().height;
+
+    // vertical scrollbar needed if the view's preferred height
+    // is larger than the viewport's preferred height
+    if (vsb != null && viewSize.height > viewportSize.height)
+      width += vsb.getPreferredSize().width;
+    if (rowHead != null && rowHead.isVisible())
+      width += rowHead.getPreferredSize().width;
+    if (colHead != null && colHead.isVisible())
+      height += colHead.getPreferredSize().height;
+
+    // Add insets of viewportBorder if present.
+    Border vpBorder = sc.getViewportBorder();
+    if (vpBorder != null)
+      {
+        Insets i = vpBorder.getBorderInsets(sc);
+        width += i.left + i.right;
+        height += i.top + i.bottom;
+      }
+
+    Insets i = sc.getInsets();
+    return new Dimension(width + i.left + i.right,
+                         height + i.left + i.right);
+  }
+
+  public Dimension minimumLayoutSize(Container parent)
+  {
+    // Sun's implementation simply throws a ClassCastException if
+    // parent is no JScrollPane, so do we.
+    JScrollPane sc = (JScrollPane) parent;
+    Insets i = sc.getInsets();
+    Dimension viewportMinSize = sc.getViewport().getMinimumSize();
+
+    int width = i.left + i.right + viewportMinSize.width;
+    if (sc.getVerticalScrollBarPolicy()
+        != JScrollPane.VERTICAL_SCROLLBAR_NEVER)
+      width += sc.getVerticalScrollBar().getMinimumSize().width;
+
+    int height = i.top + i.bottom + viewportMinSize.height;
+    if (sc.getHorizontalScrollBarPolicy()
+        != JScrollPane.HORIZONTAL_SCROLLBAR_NEVER)
+      height += sc.getHorizontalScrollBar().getMinimumSize().height;
+
+    // Add insets of viewportBorder if present.
+    Border vpBorder = sc.getViewportBorder();
+    if (vpBorder != null)
+      {
+        i = vpBorder.getBorderInsets(sc);
+        width += i.left + i.right;
+        height += i.top + i.bottom;
+      }
+
+    return new Dimension(width, height);
+  }
+
+  /**
+   *
+   *     +----+--------------------+----+ y1
+   *     | c1 |   column header    | c2 |
+   *     +----+--------------------+----+ y2
+   *     | r  |                    | v  |
+   *     | o  |                    |    |
+   *     | w  |                    | s  |
+   *     |    |                    | r  |
+   *     | h  |                    | o  |
+   *     | e  |      viewport      | l  |
+   *     | a  |                    | l  |
+   *     | d  |                    | b  |
+   *     | e  |                    | a  |
+   *     | r  |                    | r  |
+   *     +----+--------------------+----+ y3
+   *     | c3 |    h scrollbar     | c4 |
+   *     +----+--------------------+----+ y4
+   *    x1   x2                   x3   x4
+   *
+   */
+  public void layoutContainer(Container parent)
+  {
+    // Sun's implementation simply throws a ClassCastException if
+    // parent is no JScrollPane, so do we.
+    JScrollPane sc = (JScrollPane) parent;
+    JViewport viewport = sc.getViewport();
+    Component view = viewport.getView();
+
+    // If there is no view in the viewport, there is no work to be done.
+    if (view == null)
+      return;
+
+    Dimension viewSize = viewport.getView().getPreferredSize();
+
+    int x1 = 0, x2 = 0, x3 = 0, x4 = 0;
+    int y1 = 0, y2 = 0, y3 = 0, y4 = 0;
+    Rectangle scrollPaneBounds = SwingUtilities.calculateInnerArea(sc, null);
+
+    // If there is a viewportBorder, remove its insets from the available
+    // space.
+    Border vpBorder = sc.getViewportBorder();
+    Insets vpi;
+    if (vpBorder != null)
+      vpi = vpBorder.getBorderInsets(sc);
+    else
+      vpi = new Insets(0, 0, 0, 0);
+
+    x1 = scrollPaneBounds.x;
+    y1 = scrollPaneBounds.y;
+    x4 = scrollPaneBounds.x + scrollPaneBounds.width;
+    y4 = scrollPaneBounds.y + scrollPaneBounds.height;
+    if (colHead != null)
+      y2 = y1 + colHead.getPreferredSize().height;
+    else
+      y2 = y1;
+
+    if (rowHead != null)
+      x2 = x1 + rowHead.getPreferredSize().width;
+    else
+      x2 = x1;
+
+    int vsbPolicy = sc.getVerticalScrollBarPolicy();
+    int hsbPolicy = sc.getHorizontalScrollBarPolicy();
+
+    int vsWidth = 0;
+    int hsHeight = 0;
+
+    boolean showVsb =
+      (vsb != null)
+      && ((vsbPolicy == VERTICAL_SCROLLBAR_ALWAYS)
+          || (vsbPolicy == VERTICAL_SCROLLBAR_AS_NEEDED
+              && viewSize.height > (y4 - y2)));
+
+    if (showVsb)
+      vsWidth = vsb.getPreferredSize().width;
+
+    // The horizontal scroll bar may become necessary if the vertical scroll
+    // bar appears, reducing the space, left for the component.
+
+    boolean showHsb =
+      (hsb != null)
+      && ((hsbPolicy == HORIZONTAL_SCROLLBAR_ALWAYS)
+          || (hsbPolicy == HORIZONTAL_SCROLLBAR_AS_NEEDED
+              && viewSize.width > (x4 - x2 - vsWidth)));
+
+    if (showHsb)
+      hsHeight = hsb.getPreferredSize().height;
+
+    // If the horizontal scroll bar appears, and the vertical scroll bar
+    // was not necessary assuming that there is no horizontal scroll bar,
+    // the vertical scroll bar may become necessary because the horizontal
+    // scroll bar reduces the vertical space for the component.
+    if (!showVsb)
+      {
+        showVsb =
+          (vsb != null)
+          && ((vsbPolicy == VERTICAL_SCROLLBAR_ALWAYS)
+              || (vsbPolicy == VERTICAL_SCROLLBAR_AS_NEEDED
+                  && viewSize.height > (y4 - y2)));
+
+        if (showVsb)
+          vsWidth = vsb.getPreferredSize().width;
+      }
+
+    x3 = x4 - vsWidth;
+    y3 = y4 - hsHeight;
+
+    // now set the layout
+    if (viewport != null)
+      viewport.setBounds(new Rectangle(x2 + vpi.left, y2 + vpi.top,
+                                       x3 - x2 - vpi.left - vpi.right,
+                                       y3 - y2 - vpi.top - vpi.bottom));
+
+    if (colHead != null)
+      colHead.setBounds(new Rectangle(x2, y1, x3 - x2, y2 - y1));
+
+    if (rowHead != null)
+      rowHead.setBounds(new Rectangle(x1, y2, x2 - x1, y3 - y2));
+
+    if (showVsb)
+      {
+        vsb.setVisible(true);
+        vsb.setBounds(new Rectangle(x3, y2, x4 - x3, y3 - y2 ));
+      }
+    else if (vsb != null)
+      vsb.setVisible(false);
+
+    if (showHsb)
+      {
+        hsb.setVisible(true);
+        hsb.setBounds(new Rectangle(x2 , y3, x3 - x2, y4 - y3));
+      }
+    else if (hsb != null)
+      hsb.setVisible(false);
+
+    if (upperLeft != null)
+      upperLeft.setBounds(new Rectangle(x1, y1, x2 - x1, y2 - y1));
+
+    if (upperRight != null)
+      upperRight.setBounds(new Rectangle(x3, y1, x4 - x3, y2 - y1));
+
+    if (lowerLeft != null)
+      lowerLeft.setBounds(new Rectangle(x1, y3, x2 - x1, y4 - y3));
+
+    if (lowerRight != null)
+      lowerRight.setBounds(new Rectangle(x3, y3, x4 - x3, y4 - y3));
+  }
+
+  /**
+   * Returns the bounds of the border around a ScrollPane's viewport.
+   *
+   * @param scrollPane the ScrollPane for which's viewport the border
+   *     is requested
+   *
+   * @deprecated As of Swing 1.1 replaced by
+   *     {@link javax.swing.JScrollPane#getViewportBorderBounds}.
+   */
+  public Rectangle getViewportBorderBounds(JScrollPane scrollPane)
+  {
+    return null;
+  }
+
+
+}