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, 798 insertions, 0 deletions

diff --git a/libjava/classpath/javax/swing/JToolBar.java b/libjava/classpath/javax/swing/JToolBar.java
new file mode 100644
index 000000000..5f4816f04
--- /dev/null
+++ b/libjava/classpath/javax/swing/JToolBar.java
@@ -0,0 +1,798 @@
+/* JToolBar.java --
+   Copyright (C) 2002, 2004, 2005, 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;
+
+import gnu.java.lang.CPStringBuilder;
+
+import java.awt.Component;
+import java.awt.Container;
+import java.awt.Dimension;
+import java.awt.Graphics;
+import java.awt.Insets;
+import java.awt.LayoutManager;
+import java.beans.PropertyChangeListener;
+
+import javax.accessibility.Accessible;
+import javax.accessibility.AccessibleContext;
+import javax.accessibility.AccessibleRole;
+import javax.accessibility.AccessibleStateSet;
+import javax.swing.plaf.ToolBarUI;
+
+/**
+ * JToolBar is a component that provides a toolbar to Swing programs. Users
+ * can add buttons (or actions that will be represented by JButtons) as well
+ * as other components to the JToolBar. JToolBars can be dragged in and out
+ * of their parent components. If the JToolBar is dragged out of the parent,
+ * then it will be displayed in its own RootPaneContainer. For dragging to
+ * work properly, JToolBars need to be placed in a Container that has a
+ * BorderLayout. That parent Container cannot have components in the NORTH,
+ * EAST, SOUTH,  or WEST components (that is not the JToolBar).
+ */
+public class JToolBar extends JComponent implements SwingConstants, Accessible
+{
+  /**
+   * Provides the accessibility features for the <code>JToolBar</code>
+   * component.
+   */
+  protected class AccessibleJToolBar extends AccessibleJComponent
+  {
+    private static final long serialVersionUID = -5516888265903814215L;
+
+    /**
+     * Creates a new <code>AccessibleJToolBar</code> instance.
+     */
+    protected AccessibleJToolBar()
+    {
+      // Nothing to do here.
+    }
+
+    /**
+     * Returns a set containing the current state of the {@link JToolBar}
+     * component.  The current implementation simply calls the superclass.
+     *
+     * @return The accessible state set.
+     */
+    public AccessibleStateSet getAccessibleStateSet()
+    {
+      // running tests against the reference implementation, I was unable
+      // to find any state information that is set specifically by the
+      // tool bar...
+      return super.getAccessibleStateSet();
+    }
+
+    /**
+     * Returns the accessible role for the <code>JToolBar</code> component.
+     *
+     * @return {@link AccessibleRole#TOOL_BAR}.
+     */
+    public AccessibleRole getAccessibleRole()
+    {
+      return AccessibleRole.TOOL_BAR;
+    }
+  }
+
+  /**
+   * This is the private JToolBar layout manager.
+   */
+  private class DefaultToolBarLayout implements LayoutManager
+  {
+    /**
+     * This method is called when a new component is added to the container.
+     *
+     * @param name The name of the component added.
+     * @param comp The component that was added.
+     */
+    public void addLayoutComponent(String name, Component comp)
+    {
+      // Do nothing.
+    }
+
+    /**
+     * This method is called to lay out the given container  to position and
+     * size the child components.
+     *
+     * @param c The container to lay out.
+     *
+     * @throws Error DOCUMENT ME!
+     */
+    public void layoutContainer(Container c)
+    {
+      if (! (c instanceof JToolBar))
+        throw new Error("DefaultToolBarLayout can only be used on JToolBars.");
+      Insets insets = getInsets();
+      Insets margin = getMargin();
+      int middle;
+      if (margin != null)
+        {
+          insets.left += margin.left;
+          insets.top += margin.top;
+          insets.bottom += margin.bottom;
+          insets.right += margin.right;
+        }
+      Component[] components = c.getComponents();
+      Dimension tdims = c.getSize();
+      int start = 0;
+      Dimension pref;
+
+      if (getOrientation() == SwingUtilities.HORIZONTAL)
+        {
+          start += insets.left;
+          for (int i = 0; i < components.length; i++)
+            {
+              if (components[i] != null && components[i].isVisible())
+                {
+                  pref = components[i].getPreferredSize();
+                  if (pref != null)
+                    {
+                      middle = (tdims.height - pref.height) / 2;
+                      components[i].setBounds(start, middle, pref.width,
+                                              pref.height);
+                      start += pref.width;
+                    }
+                }
+            }
+        }
+      else
+        {
+          start += insets.top;
+          for (int i = 0; i < components.length; i++)
+            {
+              if (components[i] != null && components[i].isVisible())
+                {
+                  pref = components[i].getPreferredSize();
+                  if (pref != null)
+                    {
+                      middle = (tdims.width - pref.width) / 2;
+                      components[i].setBounds(middle, start, pref.width,
+                                              pref.height);
+                      start += pref.height;
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * This method returns the minimum size of the given container given the
+     * child components.
+     *
+     * @param parent The container to measure.
+     *
+     * @return The minimum size of the given container.
+     */
+    public Dimension minimumLayoutSize(Container parent)
+    {
+      return preferredLayoutSize(parent);
+    }
+
+    /**
+     * This method returns the preferred size of the given container given the
+     * child components.
+     *
+     * @param parent The container to measure.
+     *
+     * @return The preferred size of the given container.
+     */
+    public Dimension preferredLayoutSize(Container parent)
+    {
+      int orientation = getOrientation();
+      Component[] components = getComponents();
+
+      int limit = 0;
+      int total = 0;
+      Dimension dims;
+
+      int w = 0;
+      int h = 0;
+
+      if (orientation == SwingConstants.HORIZONTAL)
+        {
+          for (int i = 0; i < components.length; i++)
+            {
+              dims = components[i].getPreferredSize();
+              if (dims != null)
+                {
+                  if (dims.height > limit)
+                    limit = dims.height;
+                  total += dims.width;
+                }
+            }
+          w = total;
+          h = limit;
+        }
+      else
+        {
+          for (int i = 0; i < components.length; i++)
+            {
+              dims = components[i].getPreferredSize();
+              if (dims != null)
+                {
+                  if (dims.width > limit)
+                    limit = dims.width;
+                  total += dims.height;
+                }
+            }
+          w = limit;
+          h = total;
+        }
+
+      Insets insets = getInsets();
+      w += insets.left + insets.right;
+      h += insets.top + insets.bottom;
+
+      Insets margin = getMargin();
+      if (margin != null)
+        {
+          w += margin.left + margin.right;
+          h += margin.top + margin.bottom;
+        }
+
+      return new Dimension(w, h);
+    }
+
+    /**
+     * This method is called when the given component  is removed from the
+     * container.
+     *
+     * @param comp The component removed.
+     */
+    public void removeLayoutComponent(Component comp)
+    {
+      // Do nothing.
+    }
+  }
+
+  /**
+   * This is an extension of JSeparator used in toolbars. Unlike JSeparator,
+   * nothing is painted for this Separator, it is only blank space that
+   * separates components.
+   */
+  public static class Separator extends JSeparator
+  {
+    /** DOCUMENT ME! */
+    private static final long serialVersionUID = -1656745644823105219L;
+
+    /**
+     * Creates a new Separator object.
+     */
+    public Separator()
+    {
+      super();
+    } // Separator()
+
+    /**
+     * Creates a new Separator object with the given size.
+     *
+     * @param size The size of the separator.
+     */
+    public Separator(Dimension size)
+    {
+      setPreferredSize(size);
+    } // Separator()
+
+    /**
+     * This method returns the String ID of the UI class of  Separator.
+     *
+     * @return The UI class' String ID.
+     */
+    public String getUIClassID()
+    {
+      return "ToolBarSeparatorUI";
+    } // getUIClassID()
+
+    /**
+     * This method returns the preferred size of the Separator.
+     *
+     * @return The preferred size of the Separator.
+     */
+    public Dimension getPreferredSize()
+    {
+      return super.getPreferredSize();
+    } // getPreferredSize()
+
+    /**
+     * This method returns the maximum size of the Separator.
+     *
+     * @return The maximum size of the Separator.
+     */
+    public Dimension getMaximumSize()
+    {
+      return super.getPreferredSize();
+    } // getMaximumSize()
+
+    /**
+     * This method returns the minimum size of the Separator.
+     *
+     * @return The minimum size of the Separator.
+     */
+    public Dimension getMinimumSize()
+    {
+      return super.getPreferredSize();
+    } // getMinimumSize()
+
+    /**
+     * This method returns the size of the Separator.
+     *
+     * @return The size of the Separator.
+     */
+    public Dimension getSeparatorSize()
+    {
+      return super.getPreferredSize();
+    } // getSeparatorSize()
+
+    /**
+     * This method sets the size of the Separator.
+     *
+     * @param size The new size of the Separator.
+     */
+    public void setSeparatorSize(Dimension size)
+    {
+      setPreferredSize(size);
+    } // setSeparatorSize()
+  } // Separator
+
+  /** DOCUMENT ME! */
+  private static final long serialVersionUID = -1269915519555129643L;
+
+  /** Whether the JToolBar paints its border. */
+  private transient boolean paintBorder = true;
+
+  /** The extra insets around the JToolBar. */
+  private transient Insets margin;
+
+  /** Whether the JToolBar can float (and be dragged around). */
+  private transient boolean floatable = true;
+
+  /** Whether the buttons will have rollover borders. */
+  private transient boolean rollover;
+
+  /** The orientation of the JToolBar. */
+  private int orientation = HORIZONTAL;
+
+  /**
+   * This method creates a new JToolBar object with horizontal orientation
+   * and no name.
+   */
+  public JToolBar()
+  {
+    this(null, HORIZONTAL);
+  } // JToolBar()
+
+  /**
+   * This method creates a new JToolBar with the given orientation and  no
+   * name.
+   *
+   * @param orientation JToolBar orientation (HORIZONTAL or VERTICAL)
+   */
+  public JToolBar(int orientation)
+  {
+    this(null, orientation);
+  } // JToolBar()
+
+  /**
+   * This method creates a new JToolBar object with the given name and
+   * horizontal orientation.
+   *
+   * @param name Name assigned to undocked tool bar.
+   */
+  public JToolBar(String name)
+  {
+    this(name, HORIZONTAL);
+  } // JToolBar()
+
+  /**
+   * This method creates a new JToolBar object with the given name and
+   * orientation.
+   *
+   * @param name Name assigned to undocked tool bar.
+   * @param orientation JToolBar orientation (HORIZONTAL or VERTICAL)
+   */
+  public JToolBar(String name, int orientation)
+  {
+    setName(name);
+    setOrientation(orientation);
+    setLayout(new DefaultToolBarLayout());
+    revalidate();
+    setOpaque(true);
+    updateUI();
+  }
+
+  /**
+   * This method adds a new JButton that performs the given Action to the
+   * JToolBar.
+   *
+   * @param action The Action to add to the JToolBar.
+   *
+   * @return The JButton that wraps the Action.
+   */
+  public JButton add(Action action)
+  {
+    JButton b = createActionComponent(action);
+    add(b);
+    return b;
+  } // add()
+
+  /**
+   * This method paints the border if the borderPainted property is true.
+   *
+   * @param graphics The graphics object to paint with.
+   */
+  protected void paintBorder(Graphics graphics)
+  {
+    if (paintBorder && isFloatable())
+      super.paintBorder(graphics);
+  } // paintBorder()
+
+  /**
+   * This method returns the UI class used to paint this JToolBar.
+   *
+   * @return The UI class for this JToolBar.
+   */
+  public ToolBarUI getUI()
+  {
+    return (ToolBarUI) ui;
+  } // getUI()
+
+  /**
+   * This method sets the UI used with the JToolBar.
+   *
+   * @param ui The UI used with the JToolBar.
+   */
+  public void setUI(ToolBarUI ui)
+  {
+    super.setUI(ui);
+  } // setUI()
+
+  /**
+   * This method resets the UI used to the Look and Feel defaults.
+   */
+  public void updateUI()
+  {
+    setUI((ToolBarUI) UIManager.getUI(this));
+  }
+
+  /**
+   * This method returns the String identifier for the UI class to the used
+   * with the JToolBar.
+   *
+   * @return The String identifier for the UI class.
+   */
+  public String getUIClassID()
+  {
+    return "ToolBarUI";
+  } // getUIClassID()
+
+  /**
+   * This method sets the rollover property for the JToolBar. In rollover
+   * mode, JButtons inside the JToolBar will only display their borders when
+   * the mouse is moving over them.
+   *
+   * @param b The new rollover property.
+   */
+  public void setRollover(boolean b)
+  {
+    if (b != rollover)
+      {
+        rollover = b;
+        firePropertyChange("rollover", ! rollover, rollover);
+        revalidate();
+        repaint();
+      }
+  }
+
+  /**
+   * This method returns the rollover property.
+   *
+   * @return The rollover property.
+   */
+  public boolean isRollover()
+  {
+    return rollover;
+  }
+
+  /**
+   * This method returns the index of the given component.
+   *
+   * @param component The component to find.
+   *
+   * @return The index of the given component.
+   */
+  public int getComponentIndex(Component component)
+  {
+    Component[] components = getComponents();
+    if (components == null)
+      return -1;
+
+    for (int i = 0; i < components.length; i++)
+      if (components[i] == component)
+        return i;
+
+    return -1;
+  } // getComponentIndex()
+
+  /**
+   * This method returns the component at the given index.
+   *
+   * @param index The index of the component.
+   *
+   * @return The component at the given index.
+   */
+  public Component getComponentAtIndex(int index)
+  {
+    return getComponent(index);
+  } // getComponentAtIndex()
+
+  /**
+   * This method returns the margin property.
+   *
+   * @return The margin property.
+   */
+  public Insets getMargin()
+  {
+    return margin;
+  } // getMargin()
+
+  /**
+   * This method sets the margin property. The margin property determines the
+   * extra space between the children components of the JToolBar and the
+   * border.
+   *
+   * @param margin The margin property.
+   */
+  public void setMargin(Insets margin)
+  {
+    if ((this.margin != null && margin == null)
+        || (this.margin == null && margin != null)
+        || (margin != null && this.margin != null
+        && (margin.left != this.margin.left
+        || margin.right != this.margin.right || margin.top != this.margin.top
+        || margin.bottom != this.margin.bottom)))
+      {
+        Insets oldMargin = this.margin;
+        this.margin = margin;
+        firePropertyChange("margin", oldMargin, this.margin);
+        revalidate();
+        repaint();
+      }
+  } // setMargin()
+
+  /**
+   * This method returns the borderPainted property.
+   *
+   * @return The borderPainted property.
+   */
+  public boolean isBorderPainted()
+  {
+    return paintBorder;
+  } // isBorderPainted()
+
+  /**
+   * This method sets the borderPainted property. If set to false, the border
+   * will not be painted.
+   *
+   * @param painted Whether the border will be painted.
+   */
+  public void setBorderPainted(boolean painted)
+  {
+    if (painted != paintBorder)
+      {
+        paintBorder = painted;
+        firePropertyChange("borderPainted", ! paintBorder,
+                           paintBorder);
+        repaint();
+      }
+  } // setBorderPainted()
+
+  /**
+   * This method returns the floatable property.
+   *
+   * @return The floatable property.
+   */
+  public boolean isFloatable()
+  {
+    return floatable;
+  } // isFloatable()
+
+  /**
+   * This method sets the floatable property. If set to false, the JToolBar
+   * cannot be dragged.
+   *
+   * @param floatable Whether the JToolBar can be dragged.
+   */
+  public void setFloatable(boolean floatable)
+  {
+    if (floatable != this.floatable)
+      {
+        this.floatable = floatable;
+        firePropertyChange("floatable", ! floatable, floatable);
+      }
+  } // setFloatable()
+
+  /**
+   * This method returns the orientation of the JToolBar.
+   *
+   * @return The orientation of the JToolBar.
+   */
+  public int getOrientation()
+  {
+    return orientation;
+  } // getOrientation()
+
+  /**
+   * This method sets the layout manager to be used with the JToolBar.
+   *
+   * @param mgr The Layout Manager used with the JToolBar.
+   */
+  public void setLayout(LayoutManager mgr)
+  {
+    super.setLayout(mgr);
+    revalidate();
+    repaint();
+  } // setLayout()
+
+  /**
+   * This method sets the orientation property for JToolBar.
+   *
+   * @param orientation The new orientation for JToolBar.
+   *
+   * @throws IllegalArgumentException If the orientation is not HORIZONTAL or
+   *         VERTICAL.
+   */
+  public void setOrientation(int orientation)
+  {
+    if (orientation != HORIZONTAL && orientation != VERTICAL)
+      throw new IllegalArgumentException(orientation
+                                         + " is not a legal orientation");
+    if (orientation != this.orientation)
+      {
+        int oldOrientation = this.orientation;
+        this.orientation = orientation;
+        firePropertyChange("orientation", oldOrientation, this.orientation);
+        revalidate();
+        repaint();
+      }
+  } // setOrientation()
+
+  /**
+   * This method adds a Separator of default size to the JToolBar.
+   */
+  public void addSeparator()
+  {
+    add(new Separator());
+  } // addSeparator()
+
+  /**
+   * This method adds a Separator with the given size to the JToolBar.
+   *
+   * @param size The size of the Separator.
+   */
+  public void addSeparator(Dimension size)
+  {
+    add(new Separator(size));
+  } // addSeparator()
+
+  /**
+   * This method is used to create JButtons which can be added to the JToolBar
+   * for the given action.
+   *
+   * @param action The action to create a JButton for.
+   *
+   * @return The JButton created from the action.
+   */
+  protected JButton createActionComponent(Action action)
+  {
+    return new JButton(action);
+  } // createActionComponent()
+
+  /**
+   * This method creates a pre-configured PropertyChangeListener which updates
+   * the control as changes are made to the Action. However, this is no
+   * longer the recommended way of adding Actions to Containers. As such,
+   * this method returns null.
+   *
+   * @param button The JButton to configure a PropertyChangeListener for.
+   *
+   * @return null.
+   */
+  protected PropertyChangeListener createActionChangeListener(JButton button)
+  {
+    // XXX: As specified, this returns null. But seems kind of strange, usually deprecated methods don't just return null, verify!
+    return null;
+  } // createActionChangeListener()
+
+  /**
+   * This method overrides Container's addImpl method. If a JButton is added,
+   * it is disabled.
+   *
+   * @param component The Component to add.
+   * @param constraints The Constraints placed on the component.
+   * @param index The index to place the Component at.
+   */
+  protected void addImpl(Component component, Object constraints, int index)
+  {
+    // XXX: Sun says disable button but test cases show otherwise.
+    super.addImpl(component, constraints, index);
+
+    // if we added a Swing Button then adjust this a little
+    if (component instanceof AbstractButton)
+      {
+        AbstractButton b = (AbstractButton) component;
+        b.setRolloverEnabled(rollover);
+      }
+
+  } // addImpl()
+
+  /**
+   * Returns a string describing the attributes for the <code>JToolBar</code>
+   * component, for use in debugging.  The return value is guaranteed to be
+   * non-<code>null</code>, but the format of the string may vary between
+   * implementations.
+   *
+   * @return A string describing the attributes of the <code>JToolBar</code>.
+   */
+  protected String paramString()
+  {
+    CPStringBuilder sb = new CPStringBuilder(super.paramString());
+    sb.append(",floatable=").append(floatable);
+    sb.append(",margin=");
+    if (margin != null)
+      sb.append(margin);
+    sb.append(",orientation=");
+    if (orientation == HORIZONTAL)
+      sb.append("HORIZONTAL");
+    else
+      sb.append(VERTICAL);
+    sb.append(",paintBorder=").append(paintBorder);
+    return sb.toString();
+  }
+
+  /**
+   * Returns the object that provides accessibility features for this
+   * <code>JToolBar</code> component.
+   *
+   * @return The accessible context (an instance of {@link AccessibleJToolBar}).
+   */
+  public AccessibleContext getAccessibleContext()
+  {
+    if (accessibleContext == null)
+      accessibleContext = new AccessibleJToolBar();
+
+    return accessibleContext;
+  }
+}