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

diff --git a/libjava/classpath/javax/swing/TransferHandler.java b/libjava/classpath/javax/swing/TransferHandler.java
new file mode 100644
index 000000000..abf6e8c2e
--- /dev/null
+++ b/libjava/classpath/javax/swing/TransferHandler.java
@@ -0,0 +1,654 @@
+/* TransferHandler.java --
+   Copyright (C) 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 java.awt.Toolkit;
+import java.awt.datatransfer.Clipboard;
+import java.awt.datatransfer.DataFlavor;
+import java.awt.datatransfer.Transferable;
+import java.awt.datatransfer.UnsupportedFlavorException;
+import java.awt.dnd.DragGestureEvent;
+import java.awt.dnd.DragGestureListener;
+import java.awt.dnd.DragGestureRecognizer;
+import java.awt.dnd.DragSource;
+import java.awt.dnd.DragSourceContext;
+import java.awt.dnd.DragSourceDragEvent;
+import java.awt.dnd.DragSourceDropEvent;
+import java.awt.dnd.DragSourceEvent;
+import java.awt.dnd.DragSourceListener;
+import java.awt.event.ActionEvent;
+import java.awt.event.InputEvent;
+import java.awt.event.MouseEvent;
+import java.beans.BeanInfo;
+import java.beans.IntrospectionException;
+import java.beans.Introspector;
+import java.beans.PropertyDescriptor;
+import java.io.IOException;
+import java.io.Serializable;
+import java.lang.reflect.Method;
+
+public class TransferHandler implements Serializable
+{
+
+  /**
+   * An implementation of {@link Transferable} that can be used to export
+   * data from a component's property.
+   */
+  private static class PropertyTransferable
+    implements Transferable
+  {
+    /**
+     * The component from which we export.
+     */
+    private JComponent component;
+
+    /**
+     * The property descriptor of the property that we handle.
+     */
+    private PropertyDescriptor property;
+
+    /**
+     * Creates a new PropertyTransferable.
+     *
+     * @param c the component from which we export
+     * @param prop the property from which we export
+     */
+    PropertyTransferable(JComponent c, PropertyDescriptor prop)
+    {
+      component = c;
+      property = prop;
+    }
+
+    /**
+     * Returns the data flavors supported by the Transferable.
+     *
+     * @return the data flavors supported by the Transferable
+     */
+    public DataFlavor[] getTransferDataFlavors()
+    {
+      DataFlavor[] flavors;
+      Class propClass = property.getPropertyType();
+      String mime = DataFlavor.javaJVMLocalObjectMimeType + "; class="
+                    + propClass.getName();
+      try
+        {
+          DataFlavor flavor = new DataFlavor(mime);
+          flavors = new DataFlavor[]{ flavor };
+        }
+      catch (ClassNotFoundException ex)
+        {
+          flavors = new DataFlavor[0];
+        }
+      return flavors;
+    }
+
+    /**
+     * Returns <code>true</code> when the specified data flavor is supported,
+     * <code>false</code> otherwise.
+     *
+     * @return <code>true</code> when the specified data flavor is supported,
+     *         <code>false</code> otherwise
+     */
+    public boolean isDataFlavorSupported(DataFlavor flavor)
+    {
+      Class propClass = property.getPropertyType();
+      return flavor.getPrimaryType().equals("application")
+        && flavor.getSubType().equals("x-java-jvm-local-objectref")
+        && propClass.isAssignableFrom(flavor.getRepresentationClass());
+    }
+
+    /**
+     * Returns the actual transfer data.
+     *
+     * @param flavor the data flavor
+     *
+     * @return the actual transfer data
+     */
+    public Object getTransferData(DataFlavor flavor)
+      throws UnsupportedFlavorException, IOException
+    {
+      if (isDataFlavorSupported(flavor))
+        {
+          Method getter = property.getReadMethod();
+          Object o;
+          try
+            {
+              o = getter.invoke(component);
+              return o;
+            }
+          catch (Exception ex)
+            {
+              throw new IOException("Property read failed: "
+                                    + property.getName());
+            }
+        }
+      else
+        throw new UnsupportedFlavorException(flavor);
+    }
+  }
+
+  static class TransferAction extends AbstractAction
+  {
+    private String command;
+
+    public TransferAction(String command)
+    {
+      super(command);
+      this.command = command;
+    }
+
+    public void actionPerformed(ActionEvent event)
+    {
+      JComponent component = (JComponent) event.getSource();
+      TransferHandler transferHandler = component.getTransferHandler();
+      Clipboard clipboard = getClipboard(component);
+
+      if (clipboard == null)
+        {
+          // Access denied!
+          Toolkit.getDefaultToolkit().beep();
+          return;
+        }
+
+      if (command.equals(COMMAND_COPY))
+        transferHandler.exportToClipboard(component, clipboard, COPY);
+      else if (command.equals(COMMAND_CUT))
+        transferHandler.exportToClipboard(component, clipboard, MOVE);
+      else if (command.equals(COMMAND_PASTE))
+        {
+          Transferable transferable = clipboard.getContents(null);
+
+          if (transferable != null)
+            transferHandler.importData(component, transferable);
+        }
+    }
+
+    /**
+     * Get the system cliboard or null if the caller isn't allowed to
+     * access the system clipboard.
+     *
+     * @param component a component, used to get the toolkit.
+     * @return the clipboard
+     */
+    private static Clipboard getClipboard(JComponent component)
+    {
+      try
+        {
+          return component.getToolkit().getSystemClipboard();
+        }
+      catch (SecurityException se)
+        {
+          return null;
+        }
+    }
+  }
+
+  private static class SwingDragGestureRecognizer extends DragGestureRecognizer
+  {
+
+    protected SwingDragGestureRecognizer(DragGestureListener dgl)
+    {
+      super(DragSource.getDefaultDragSource(), null, NONE, dgl);
+    }
+
+    void gesture(JComponent c, MouseEvent e, int src, int drag)
+    {
+      setComponent(c);
+      setSourceActions(src);
+      appendEvent(e);
+      fireDragGestureRecognized(drag, e.getPoint());
+    }
+
+    protected void registerListeners()
+    {
+      // Nothing to do here.
+    }
+
+    protected void unregisterListeners()
+    {
+      // Nothing to do here.
+    }
+
+  }
+
+  private static class SwingDragHandler
+    implements DragGestureListener, DragSourceListener
+  {
+
+    private boolean autoscrolls;
+
+    public void dragGestureRecognized(DragGestureEvent e)
+    {
+      JComponent c = (JComponent) e.getComponent();
+      TransferHandler th = c.getTransferHandler();
+      Transferable t = th.createTransferable(c);
+      if (t != null)
+        {
+          autoscrolls = c.getAutoscrolls();
+          c.setAutoscrolls(false);
+          try
+            {
+              e.startDrag(null, t, this);
+              return;
+            }
+          finally
+            {
+              c.setAutoscrolls(autoscrolls);
+            }
+        }
+      th.exportDone(c, t, NONE);
+    }
+
+    public void dragDropEnd(DragSourceDropEvent e)
+    {
+      DragSourceContext ctx = e.getDragSourceContext();
+      JComponent c = (JComponent) ctx.getComponent();
+      TransferHandler th = c.getTransferHandler();
+      if (e.getDropSuccess())
+        {
+          th.exportDone(c, ctx.getTransferable(), e.getDropAction());
+        }
+      else
+        {
+          th.exportDone(c, ctx.getTransferable(), e.getDropAction());
+        }
+      c.setAutoscrolls(autoscrolls);
+    }
+
+    public void dragEnter(DragSourceDragEvent e)
+    {
+      // Nothing to do here.
+    }
+
+    public void dragExit(DragSourceEvent e)
+    {
+      // Nothing to do here.
+    }
+
+    public void dragOver(DragSourceDragEvent e)
+    {
+      // Nothing to do here.
+    }
+
+    public void dropActionChanged(DragSourceDragEvent e)
+    {
+      // Nothing to do here.
+    }
+
+  }
+
+  private static final long serialVersionUID = -967749805571669910L;
+
+  private static final String COMMAND_COPY = "copy";
+  private static final String COMMAND_CUT = "cut";
+  private static final String COMMAND_PASTE = "paste";
+
+  public static final int NONE = 0;
+  public static final int COPY = 1;
+  public static final int MOVE = 2;
+  public static final int COPY_OR_MOVE = 3;
+
+  private static Action copyAction = new TransferAction(COMMAND_COPY);
+  private static Action cutAction = new TransferAction(COMMAND_CUT);
+  private static Action pasteAction = new TransferAction(COMMAND_PASTE);
+
+  private int sourceActions;
+  private Icon visualRepresentation;
+
+  /**
+   * The name of the property into/from which this TransferHandler
+   * imports/exports.
+   */
+  private String propertyName;
+
+  /**
+   * The DragGestureRecognizer for Swing.
+   */
+  private SwingDragGestureRecognizer recognizer;
+
+  public static Action getCopyAction()
+  {
+    return copyAction;
+  }
+
+  public static Action getCutAction()
+  {
+    return cutAction;
+  }
+
+  public static Action getPasteAction()
+  {
+    return pasteAction;
+  }
+
+  protected TransferHandler()
+  {
+    this.sourceActions = NONE;
+  }
+
+  public TransferHandler(String property)
+  {
+    propertyName = property;
+    this.sourceActions = property != null ? COPY : NONE;
+  }
+
+  /**
+   * Returns <code>true</code> if the data in this TransferHandler can be
+   * imported into the specified component. This will be the case when:
+   * <ul>
+   *   <li>The component has a readable and writable property with the property
+   *   name specified in the TransferHandler constructor.</li>
+   *   <li>There is a dataflavor with a mime type of
+   *     <code>application/x-java-jvm-local-object-ref</code>.</li>
+   *   <li>The dataflavor's representation class matches the class of the
+   *    property in the component.</li>
+   * </li>
+   *
+   * @param c the component to check
+   * @param flavors the possible data flavors
+   *
+   * @return <code>true</code> if the data in this TransferHandler can be
+   *         imported into the specified component, <code>false</code>
+   *         otherwise
+   */
+  public boolean canImport(JComponent c, DataFlavor[] flavors)
+  {
+    PropertyDescriptor propDesc = getPropertyDescriptor(c);
+    boolean canImport = false;
+    if (propDesc != null)
+      {
+        // Check if the property is writable. The readable check is already
+        // done in getPropertyDescriptor().
+        Method writer = propDesc.getWriteMethod();
+        if (writer != null)
+          {
+            Class[] params = writer.getParameterTypes();
+            if (params.length == 1)
+              {
+                // Number of parameters ok, now check mime type and
+                // representation class.
+                DataFlavor flavor = getPropertyDataFlavor(params[0], flavors);
+                if (flavor != null)
+                  canImport = true;
+              }
+          }
+      }
+    return canImport;
+  }
+
+  /**
+   * Creates a {@link Transferable} that can be used to export data
+   * from the specified component.
+   *
+   * This method returns <code>null</code> when the specified component
+   * doesn't have a readable property that matches the property name
+   * specified in the <code>TransferHandler</code> constructor.
+   *
+   * @param c the component to create a transferable for
+   *
+   * @return a {@link Transferable} that can be used to export data
+   *         from the specified component, or null if the component doesn't
+   *         have a readable property like the transfer handler
+   */
+  protected Transferable createTransferable(JComponent c)
+  {
+    Transferable transferable = null;
+    if (propertyName != null)
+      {
+        PropertyDescriptor prop = getPropertyDescriptor(c);
+        if (prop != null)
+          transferable = new PropertyTransferable(c, prop);
+      }
+    return transferable;
+  }
+
+  public void exportAsDrag(JComponent c, InputEvent e, int action)
+  {
+    int src = getSourceActions(c);
+    int drag = src & action;
+    if (! (e instanceof MouseEvent))
+      {
+        drag = NONE;
+      }
+    if (drag != NONE)
+      {
+        if (recognizer == null)
+          {
+            SwingDragHandler ds = new SwingDragHandler();
+            recognizer = new SwingDragGestureRecognizer(ds);
+          }
+        recognizer.gesture(c, (MouseEvent) e, src, drag);
+      }
+    else
+      {
+        exportDone(c, null, NONE);
+      }
+  }
+
+  /**
+   * This method is invoked after data has been exported.
+   * Subclasses should implement this method to remove the data that has been
+   * transferred when the action was <code>MOVE</code>.
+   *
+   * The default implementation does nothing because MOVE is not supported.
+   *
+   * @param c the source component
+   * @param data the data that has been transferred or <code>null</code>
+   *        when the action is NONE
+   * @param action the action that has been performed
+   */
+  protected void exportDone(JComponent c, Transferable data, int action)
+  {
+    // Nothing to do in the default implementation.
+  }
+
+  /**
+   * Exports the property of the component <code>c</code> that was
+   * specified for this TransferHandler to the clipboard, performing
+   * the specified action.
+   *
+   * This will check if the action is allowed by calling
+   * {@link #getSourceActions(JComponent)}. If the action is not allowed,
+   * then no export is performed.
+   *
+   * In either case the method {@link #exportDone} will be called with
+   * the action that has been performed, or {@link #NONE} if the action
+   * was not allowed or could otherwise not be completed.
+   * Any IllegalStateException that is thrown by the Clipboard due to
+   * beeing unavailable will be propagated through this method.
+   *
+   * @param c the component from which to export
+   * @param clip the clipboard to which the data will be exported
+   * @param action the action to perform
+   *
+   * @throws IllegalStateException when the clipboard is not available
+   */
+  public void exportToClipboard(JComponent c, Clipboard clip, int action)
+    throws IllegalStateException
+  {
+    action &= getSourceActions(c);
+    Transferable transferable = createTransferable(c);
+    if (transferable != null && action != NONE)
+      {
+        try
+          {
+            clip.setContents(transferable, null);
+            exportDone(c, transferable, action);
+          }
+        catch (IllegalStateException ex)
+          {
+            exportDone(c, transferable, NONE);
+            throw ex;
+          }
+      }
+    else
+      exportDone(c, null, NONE);
+  }
+
+  public int getSourceActions(JComponent c)
+  {
+    return sourceActions;
+  }
+
+  public Icon getVisualRepresentation(Transferable t)
+  {
+    return visualRepresentation;
+  }
+
+  /**
+   * Imports the transfer data represented by <code>t</code> into the specified
+   * component <code>c</code> by setting the property of this TransferHandler
+   * on that component. If this succeeds, this method returns
+   * <code>true</code>, otherwise <code>false</code>.
+   *
+   *
+   * @param c the component to import into
+   * @param t the transfer data to import
+   *
+   * @return <code>true</code> if the transfer succeeds, <code>false</code>
+   *         otherwise
+   */
+  public boolean importData(JComponent c, Transferable t)
+  {
+    boolean ok = false;
+    PropertyDescriptor prop = getPropertyDescriptor(c);
+    if (prop != null)
+      {
+        Method writer = prop.getWriteMethod();
+        if (writer != null)
+          {
+            Class[] params = writer.getParameterTypes();
+            if (params.length == 1)
+              {
+                DataFlavor flavor = getPropertyDataFlavor(params[0],
+                                                   t.getTransferDataFlavors());
+                if (flavor != null)
+                  {
+                    try
+                      {
+                        Object value = t.getTransferData(flavor);
+                        writer.invoke(c, new Object[]{ value });
+                        ok = true;
+                      }
+                    catch (Exception ex)
+                      {
+                        // If anything goes wrong here, do nothing and return
+                        // false;
+                      }
+                  }
+              }
+          }
+      }
+    return ok;
+  }
+
+  /**
+   * Returns the property descriptor for the property of this TransferHandler
+   * in the specified component, or <code>null</code> if no such property
+   * exists in the component. This method only returns properties that are
+   * at least readable (that is, it has a public no-arg getter method).
+   *
+   * @param c the component to check
+   *
+   * @return the property descriptor for the property of this TransferHandler
+   *         in the specified component, or <code>null</code> if no such
+   *         property exists in the component
+   */
+  private PropertyDescriptor getPropertyDescriptor(JComponent c)
+  {
+    PropertyDescriptor prop = null;
+    if (propertyName != null)
+      {
+        Class clazz = c.getClass();
+        BeanInfo beanInfo;
+        try
+          {
+            beanInfo = Introspector.getBeanInfo(clazz);
+          }
+        catch (IntrospectionException ex)
+          {
+            beanInfo = null;
+          }
+        if (beanInfo != null)
+          {
+            PropertyDescriptor[] props = beanInfo.getPropertyDescriptors();
+            for (int i = 0; i < props.length && prop == null; i++)
+              {
+                PropertyDescriptor desc = props[i];
+                if (desc.getName().equals(propertyName))
+                  {
+                    Method reader = desc.getReadMethod();
+                    if (reader != null)
+                      {
+                        Class[] params = reader.getParameterTypes();
+                        if (params == null || params.length == 0)
+                          prop = desc;
+                      }
+                  }
+              }
+          }
+      }
+    return prop;
+  }
+
+  /**
+   * Searches <code>flavors</code> to find a suitable data flavor that
+   * has the mime type application/x-java-jvm-local-objectref and a
+   * representation class that is the same as the specified <code>clazz</code>.
+   * When no such data flavor is found, this returns <code>null</code>.
+   *
+   * @param clazz the representation class required for the data flavor
+   * @param flavors the possible data flavors
+   *
+   * @return the suitable data flavor or null if none is found
+   */
+  private DataFlavor getPropertyDataFlavor(Class clazz, DataFlavor[] flavors)
+  {
+    DataFlavor found = null;
+    for (int i = 0; i < flavors.length && found == null; i++)
+      {
+        DataFlavor flavor = flavors[i];
+        if (flavor.getPrimaryType().equals("application")
+            && flavor.getSubType().equals("x-java-jvm-local-objectref")
+            && clazz.isAssignableFrom(flavor.getRepresentationClass()))
+          found = flavor;
+      }
+    return found;
+  }
+}