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

diff --git a/libjava/classpath/javax/swing/plaf/basic/BasicSplitPaneDivider.java b/libjava/classpath/javax/swing/plaf/basic/BasicSplitPaneDivider.java
new file mode 100644
index 000000000..53f7db6e7
--- /dev/null
+++ b/libjava/classpath/javax/swing/plaf/basic/BasicSplitPaneDivider.java
@@ -0,0 +1,1077 @@
+/* BasicSplitPaneDivider.java --
+   Copyright (C) 2003, 2004, 2005 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.plaf.basic;
+
+import java.awt.Color;
+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.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.awt.event.MouseMotionListener;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+
+import javax.swing.JButton;
+import javax.swing.JSplitPane;
+import javax.swing.UIManager;
+import javax.swing.border.Border;
+
+/**
+ * The divider that separates the two parts of a JSplitPane in the Basic look
+ * and feel.
+ *
+ * <p>
+ * Implementation status: We do not have a real implementation yet. Currently,
+ * it is mostly a stub to allow compiling other parts of the
+ * javax.swing.plaf.basic package, although some parts are already
+ * functional.
+ * </p>
+ *
+ * @author Sascha Brawer (brawer_AT_dandelis.ch)
+ */
+public class BasicSplitPaneDivider extends Container
+  implements PropertyChangeListener
+{
+  /**
+   * The buttons used as one touch buttons.
+   */
+  private class BasicOneTouchButton
+    extends JButton
+  {
+    /**
+     * Denotes a left button.
+     */
+    static final int LEFT = 0;
+
+    /**
+     * Denotes a right button.
+     */
+    static final int RIGHT = 1;
+
+    /**
+     * The x points for the arrow.
+     */
+    private int[] xpoints;
+
+    /**
+     * The y points for the arrow.
+     */
+    private int[] ypoints;
+
+    /**
+     * Either LEFT or RIGHT.
+     */
+    private int direction;
+
+    /**
+     * Creates a new instance.
+     *
+     * @param dir either LEFT or RIGHT
+     */
+    BasicOneTouchButton(int dir)
+    {
+      direction = dir;
+      xpoints = new int[3];
+      ypoints = new int[3];
+    }
+
+    /**
+     * Never allow borders.
+     */
+    public void setBorder(Border b)
+    {
+    }
+
+    /**
+     * Never allow focus traversal.
+     */
+    public boolean isFocusTraversable()
+    {
+      return false;
+    }
+
+    /**
+     * Paints the one touch button.
+     */
+    public void paint(Graphics g)
+    {
+      if (splitPane != null)
+        {
+          // Fill background.
+          g.setColor(splitPane.getBackground());
+          g.fillRect(0, 0, getWidth(), getHeight());
+
+          // Draw arrow.
+          int size;
+          if (direction == LEFT)
+            {
+              if (orientation == JSplitPane.VERTICAL_SPLIT)
+                {
+                  size = Math.min(getHeight(), ONE_TOUCH_SIZE);
+                  xpoints[0] = 0;
+                  xpoints[1] = size / 2;
+                  xpoints[2] = size;
+                  ypoints[0] = size;
+                  ypoints[1] = 0;
+                  ypoints[2] = size;
+                }
+              else
+                {
+                  size = Math.min(getWidth(), ONE_TOUCH_SIZE);
+                  xpoints[0] = size;
+                  xpoints[1] = 0;
+                  xpoints[2] = size;
+                  ypoints[0] = 0;
+                  ypoints[1] = size / 2;
+                  ypoints[2] = size;
+                }
+            }
+          else
+            {
+              if (orientation == JSplitPane.VERTICAL_SPLIT)
+                {
+                  size = Math.min(getHeight(), ONE_TOUCH_SIZE);
+                  xpoints[0] = 0;
+                  xpoints[1] = size / 2;
+                  xpoints[2] = size;
+                  ypoints[0] = 0;
+                  ypoints[1] = size;
+                  ypoints[2] = 0;
+                }
+              else
+                {
+                  size = Math.min(getWidth(), ONE_TOUCH_SIZE);
+                  xpoints[0] = 0;
+                  xpoints[1] = size;
+                  xpoints[2] = 0;
+                  ypoints[0] = 0;
+                  ypoints[1] = size / 2;
+                  ypoints[2] = size;
+                }
+            }
+          g.setColor(Color.BLACK);
+          g.fillPolygon(xpoints, ypoints, 3);
+        }
+    }
+  }
+
+  /**
+   * Listens for actions on the one touch buttons.
+   */
+  private class OneTouchAction
+    implements ActionListener
+  {
+
+    public void actionPerformed(ActionEvent ev)
+    {
+      Insets insets = splitPane.getInsets();
+      int lastLoc = splitPane.getLastDividerLocation();
+      int currentLoc = splitPaneUI.getDividerLocation(splitPane);
+      int newLoc;
+
+      if (ev.getSource() == leftButton)
+        {
+          if (orientation == JSplitPane.VERTICAL_SPLIT)
+            {
+              if (currentLoc
+                  >= splitPane.getHeight() - insets.bottom - getHeight())
+                {
+                  newLoc = Math.min(splitPane.getMaximumDividerLocation(),
+                                    lastLoc);
+                }
+              else
+                {
+                  newLoc = insets.top;
+                }
+            }
+          else
+            {
+              if (currentLoc
+                  >= splitPane.getWidth() - insets.right - getWidth())
+                {
+                  newLoc = Math.min(splitPane.getMaximumDividerLocation(),
+                                    lastLoc);
+                }
+              else
+                {
+                  newLoc = insets.left;
+                }
+            }
+        }
+      else
+        {
+          if (orientation == JSplitPane.VERTICAL_SPLIT)
+            {
+              if (currentLoc == insets.top)
+                {
+                  newLoc = Math.min(splitPane.getMaximumDividerLocation(),
+                                    lastLoc);
+                }
+              else
+                {
+                  newLoc = splitPane.getHeight() - insets.top - getHeight();
+                }
+            }
+          else
+            {
+              if (currentLoc == insets.left)
+                {
+                  newLoc = Math.min(splitPane.getMaximumDividerLocation(),
+                                    lastLoc);
+                }
+              else
+                {
+                  newLoc = splitPane.getWidth() - insets.left - getWidth();
+                }
+            }
+        }
+      if (currentLoc != newLoc)
+        {
+          splitPane.setDividerLocation(newLoc);
+          splitPane.setLastDividerLocation(currentLoc);
+        }
+    }
+  }
+
+  /**
+   * Determined using the <code>serialver</code> tool of Apple/Sun JDK 1.3.1
+   * on MacOS X 10.1.5.
+   */
+  static final long serialVersionUID = 1463404307042803342L;
+
+  /**
+   * The width and height of the little buttons for showing and hiding parts
+   * of a JSplitPane in a single mouse click.
+   */
+  protected static final int ONE_TOUCH_SIZE = 6;
+
+  /** The distance the one touch buttons will sit from the divider's edges. */
+  protected static final int ONE_TOUCH_OFFSET = 2;
+
+  /**
+   * An object that performs the tasks associated with an ongoing drag
+   * operation, or <code>null</code> if the user is currently not dragging
+   * the divider.
+   */
+  protected DragController dragger;
+
+  /**
+   * The delegate object that is responsible for the UI of the
+   * <code>JSplitPane</code> that contains this divider.
+   */
+  protected BasicSplitPaneUI splitPaneUI;
+
+  /** The thickness of the divider in pixels. */
+  protected int dividerSize;
+
+  /** A divider that is used for layout purposes. */
+  protected Component hiddenDivider;
+
+  /** The JSplitPane containing this divider. */
+  protected JSplitPane splitPane;
+
+  /**
+   * The listener for handling mouse events from both the divider and the
+   * containing <code>JSplitPane</code>.
+   *
+   * <p>
+   * The reason for also handling MouseEvents from the containing
+   * <code>JSplitPane</code> is that users should be able to start a drag
+   * gesture from inside the JSplitPane, but slightly outisde the divider.
+   * </p>
+   */
+  protected MouseHandler mouseHandler = new MouseHandler();
+
+  /**
+   * The current orientation of the containing <code>JSplitPane</code>, which
+   * is either {@link javax.swing.JSplitPane#HORIZONTAL_SPLIT} or {@link
+   * javax.swing.JSplitPane#VERTICAL_SPLIT}.
+   */
+  protected int orientation;
+
+  /**
+   * The button for showing and hiding the left (or top) component of the
+   * <code>JSplitPane</code>.
+   */
+  protected JButton leftButton;
+
+  /**
+   * The button for showing and hiding the right (or bottom) component of the
+   * <code>JSplitPane</code>.
+   */
+  protected JButton rightButton;
+
+  /**
+   * The border of this divider. Typically, this will be an instance of {@link
+   * javax.swing.plaf.basic.BasicBorders.SplitPaneDividerBorder}.
+   *
+   * @see #getBorder()
+   * @see #setBorder(javax.swing.border.Border)
+   */
+  private Border border;
+
+  // This is not a pixel count.
+  // This int should be able to take 3 values.
+  // left (top), middle, right(bottom)
+  //    0          1          2
+
+  /**
+   * Keeps track of where the divider should be placed when using one touch
+   * expand buttons.
+   * This is package-private to avoid an accessor method.
+   */
+  transient int currentDividerLocation = 1;
+
+  /**
+   * Indicates if the ont touch buttons are laid out centered or at the
+   * top/left.
+   *
+   * Package private to avoid accessor method.
+   */
+  boolean centerOneTouchButtons;
+
+  /**
+   * Constructs a new divider.
+   *
+   * @param ui the UI delegate of the enclosing <code>JSplitPane</code>.
+   */
+  public BasicSplitPaneDivider(BasicSplitPaneUI ui)
+  {
+    setLayout(new DividerLayout());
+    setBasicSplitPaneUI(ui);
+    setDividerSize(splitPane.getDividerSize());
+    centerOneTouchButtons =
+      UIManager.getBoolean("SplitPane.centerOneTouchButtons");
+  }
+
+  /**
+   * Sets the delegate object that is responsible for the UI of the {@link
+   * javax.swing.JSplitPane} containing this divider.
+   *
+   * @param newUI the UI delegate, or <code>null</code> to release the
+   *        connection to the current delegate.
+   */
+  public void setBasicSplitPaneUI(BasicSplitPaneUI newUI)
+  {
+    /* Remove the connection to the existing JSplitPane. */
+    if (splitPane != null)
+      {
+        splitPane.removePropertyChangeListener(this);
+        removeMouseListener(mouseHandler);
+        removeMouseMotionListener(mouseHandler);
+        splitPane = null;
+        hiddenDivider = null;
+      }
+
+    /* Establish the connection to the new JSplitPane. */
+    splitPaneUI = newUI;
+    if (splitPaneUI != null)
+      splitPane = newUI.getSplitPane();
+    if (splitPane != null)
+      {
+        splitPane.addPropertyChangeListener(this);
+        addMouseListener(mouseHandler);
+        addMouseMotionListener(mouseHandler);
+        hiddenDivider = splitPaneUI.getNonContinuousLayoutDivider();
+        orientation = splitPane.getOrientation();
+        if (splitPane.isOneTouchExpandable())
+          oneTouchExpandableChanged();
+      }
+  }
+
+  /**
+   * Returns the delegate object that is responsible for the UI of the {@link
+   * javax.swing.JSplitPane} containing this divider.
+   *
+   * @return The UI for the JSplitPane.
+   */
+  public BasicSplitPaneUI getBasicSplitPaneUI()
+  {
+    return splitPaneUI;
+  }
+
+  /**
+   * Sets the thickness of the divider.
+   *
+   * @param newSize the new width or height in pixels.
+   */
+  public void setDividerSize(int newSize)
+  {
+    this.dividerSize = newSize;
+  }
+
+  /**
+   * Retrieves the thickness of the divider.
+   *
+   * @return The thickness of the divider.
+   */
+  public int getDividerSize()
+  {
+    return dividerSize;
+  }
+
+  /**
+   * Sets the border of this divider.
+   *
+   * @param border the new border. Typically, this will be an instance of
+   *        {@link
+   *        javax.swing.plaf.basic.BasicBorders.SplitPaneBorder}.
+   *
+   * @since 1.3
+   */
+  public void setBorder(Border border)
+  {
+    if (border != this.border)
+      {
+        Border oldValue = this.border;
+        this.border = border;
+        firePropertyChange("border", oldValue, border);
+      }
+  }
+
+  /**
+   * Retrieves the border of this divider.
+   *
+   * @return the current border, or <code>null</code> if no border has been
+   *         set.
+   *
+   * @since 1.3
+   */
+  public Border getBorder()
+  {
+    return border;
+  }
+
+  /**
+   * Retrieves the insets of the divider. If a border has been installed on
+   * the divider, the result of calling its <code>getBorderInsets</code>
+   * method is returned. Otherwise, the inherited implementation will be
+   * invoked.
+   *
+   * @see javax.swing.border.Border#getBorderInsets(java.awt.Component)
+   */
+  public Insets getInsets()
+  {
+    if (border != null)
+      return border.getBorderInsets(this);
+    else
+      return super.getInsets();
+  }
+
+  /**
+   * Returns the preferred size of this divider, which is
+   * <code>dividerSize</code> by <code>dividerSize</code> pixels.
+   *
+   * @return The preferred size of the divider.
+   */
+  public Dimension getPreferredSize()
+  {
+    Dimension d;
+    if (orientation == JSplitPane.HORIZONTAL_SPLIT)
+      d = new Dimension(getDividerSize(), 1);
+    else
+      d = new Dimension(1, getDividerSize());
+    return d;
+  }
+
+  /**
+   * Returns the minimal size of this divider, which is
+   * <code>dividerSize</code> by <code>dividerSize</code> pixels.
+   *
+   * @return The minimal size of the divider.
+   */
+  public Dimension getMinimumSize()
+  {
+    return getPreferredSize();
+  }
+
+  /**
+   * Processes events from the <code>JSplitPane</code> that contains this
+   * divider.
+   *
+   * @param e The PropertyChangeEvent.
+   */
+  public void propertyChange(PropertyChangeEvent e)
+  {
+    if (e.getPropertyName().equals(JSplitPane.ONE_TOUCH_EXPANDABLE_PROPERTY))
+      oneTouchExpandableChanged();
+    else if (e.getPropertyName().equals(JSplitPane.ORIENTATION_PROPERTY))
+      {
+        orientation = splitPane.getOrientation();
+        invalidate();
+        if (splitPane != null)
+          splitPane.revalidate();
+      }
+    else if (e.getPropertyName().equals(JSplitPane.DIVIDER_SIZE_PROPERTY))
+      dividerSize = splitPane.getDividerSize();
+  }
+
+  /**
+   * Paints the divider by painting its border.
+   *
+   * @param g The Graphics Object to paint with.
+   */
+  public void paint(Graphics g)
+  {
+    Dimension dividerSize;
+
+    super.paint(g);
+    if (border != null)
+      {
+        dividerSize = getSize();
+        border.paintBorder(this, g, 0, 0, dividerSize.width, dividerSize.height);
+      }
+  }
+
+  /**
+   * Reacts to changes of the <code>oneToughExpandable</code> property of the
+   * containing <code>JSplitPane</code>.
+   */
+  protected void oneTouchExpandableChanged()
+  {
+    if (splitPane.isOneTouchExpandable())
+      {
+        leftButton = createLeftOneTouchButton();
+        if (leftButton != null)
+          leftButton.addActionListener(new OneTouchAction());
+
+        rightButton = createRightOneTouchButton();
+        if (rightButton != null)
+          rightButton.addActionListener(new OneTouchAction());
+
+        // Only add them when both are non-null.
+        if (leftButton != null && rightButton != null)
+          {
+            add(leftButton);
+            add(rightButton);
+          }
+      }
+    invalidate();
+    if (splitPane != null)
+      splitPane.revalidate();
+  }
+
+  /**
+   * Creates a button for showing and hiding the left (or top) part of a
+   * <code>JSplitPane</code>.
+   *
+   * @return The left one touch button.
+   */
+  protected JButton createLeftOneTouchButton()
+  {
+    JButton button = new BasicOneTouchButton(BasicOneTouchButton.LEFT);
+    button.setMinimumSize(new Dimension(ONE_TOUCH_SIZE, ONE_TOUCH_SIZE));
+    button.setRequestFocusEnabled(false);
+    return button;
+  }
+
+  /**
+   * Creates a button for showing and hiding the right (or bottom) part of a
+   * <code>JSplitPane</code>.
+   *
+   * @return The right one touch button.
+   */
+  protected JButton createRightOneTouchButton()
+  {
+    JButton button = new BasicOneTouchButton(BasicOneTouchButton.RIGHT);
+    button.setMinimumSize(new Dimension(ONE_TOUCH_SIZE, ONE_TOUCH_SIZE));
+    button.setRequestFocusEnabled(false);
+    return button;
+  }
+
+  /**
+   * Prepares the divider for dragging by calling the
+   * <code>startDragging</code> method of the UI delegate of the enclosing
+   * <code>JSplitPane</code>.
+   *
+   * @see BasicSplitPaneUI#startDragging()
+   */
+  protected void prepareForDragging()
+  {
+    if (splitPaneUI != null)
+      splitPaneUI.startDragging();
+  }
+
+  /**
+   * Drags the divider to a given location by calling the
+   * <code>dragDividerTo</code> method of the UI delegate of the enclosing
+   * <code>JSplitPane</code>.
+   *
+   * @param location the new location of the divider.
+   *
+   * @see BasicSplitPaneUI#dragDividerTo(int location)
+   */
+  protected void dragDividerTo(int location)
+  {
+    if (splitPaneUI != null)
+      splitPaneUI.dragDividerTo(location);
+  }
+
+  /**
+   * Finishes a dragging gesture by calling the <code>finishDraggingTo</code>
+   * method of the UI delegate of the enclosing <code>JSplitPane</code>.
+   *
+   * @param location the new, final location of the divider.
+   *
+   * @see BasicSplitPaneUI#finishDraggingTo(int location)
+   */
+  protected void finishDraggingTo(int location)
+  {
+    if (splitPaneUI != null)
+      splitPaneUI.finishDraggingTo(location);
+  }
+
+  /**
+   * This helper method moves the divider to one of the  three locations when
+   * using one touch expand buttons. Location 0 is the left (or top) most
+   * location. Location 1 is the middle. Location 2 is the right (or bottom)
+   * most location.
+   * This is package-private to avoid an accessor method.
+   *
+   * @param locationIndex The location to move to.
+   */
+  void moveDividerTo(int locationIndex)
+  {
+    Insets insets = splitPane.getInsets();
+    switch (locationIndex)
+      {
+      case 1:
+        splitPane.setDividerLocation(splitPane.getLastDividerLocation());
+        break;
+      case 0:
+        int top = (orientation == JSplitPane.HORIZONTAL_SPLIT) ? insets.left
+                                                               : insets.top;
+        splitPane.setDividerLocation(top);
+        break;
+      case 2:
+        int bottom;
+        if (orientation == JSplitPane.HORIZONTAL_SPLIT)
+          bottom = splitPane.getBounds().width - insets.right - dividerSize;
+        else
+          bottom = splitPane.getBounds().height - insets.bottom - dividerSize;
+        splitPane.setDividerLocation(bottom);
+        break;
+      }
+  }
+
+  /**
+   * The listener for handling mouse events from both the divider and the
+   * containing <code>JSplitPane</code>.
+   *
+   * <p>
+   * The reason for also handling MouseEvents from the containing
+   * <code>JSplitPane</code> is that users should be able to start a drag
+   * gesture from inside the JSplitPane, but slightly outisde the divider.
+   * </p>
+   *
+   * @author Sascha Brawer (brawer_AT_dandelis.ch)
+   */
+  protected class MouseHandler extends MouseAdapter
+    implements MouseMotionListener
+  {
+    /** Keeps track of whether a drag is occurring. */
+    private transient boolean isDragging;
+
+    /**
+     * This method is called when the mouse is pressed.
+     *
+     * @param e The MouseEvent.
+     */
+    public void mousePressed(MouseEvent e)
+    {
+      isDragging = true;
+      currentDividerLocation = 1;
+      if (orientation == JSplitPane.HORIZONTAL_SPLIT)
+        dragger = new DragController(e);
+      else
+        dragger = new VerticalDragController(e);
+      prepareForDragging();
+    }
+
+    /**
+     * This method is called when the mouse is released.
+     *
+     * @param e The MouseEvent.
+     */
+    public void mouseReleased(MouseEvent e)
+    {
+      if (isDragging)
+        dragger.completeDrag(e);
+      isDragging = false;
+    }
+
+    /**
+     * Repeatedly invoked when the user is dragging the mouse cursor while
+     * having pressed a mouse button.
+     *
+     * @param e The MouseEvent.
+     */
+    public void mouseDragged(MouseEvent e)
+    {
+      if (dragger != null)
+        dragger.continueDrag(e);
+    }
+
+    /**
+     * Repeatedly invoked when the user is dragging the mouse cursor without
+     * having pressed a mouse button.
+     *
+     * @param e The MouseEvent.
+     */
+    public void mouseMoved(MouseEvent e)
+    {
+      // Do nothing.
+    }
+  }
+
+  /**
+   * Performs the tasks associated with an ongoing drag operation.
+   *
+   * @author Sascha Brawer (brawer_AT_dandelis.ch)
+   */
+  protected class DragController
+  {
+    /**
+     * The difference between where the mouse is clicked and the  initial
+     * divider location.
+     */
+    transient int offset;
+
+    /**
+     * Creates a new DragController object.
+     *
+     * @param e The MouseEvent to initialize with.
+     */
+    protected DragController(MouseEvent e)
+    {
+      offset = e.getX();
+    }
+
+    /**
+     * This method returns true if the divider can move.
+     *
+     * @return True if dragging is allowed.
+     */
+    protected boolean isValid()
+    {
+      // Views can always be resized?
+      return true;
+    }
+
+    /**
+     * Returns a position for the divider given the MouseEvent.
+     *
+     * @param e MouseEvent.
+     *
+     * @return The position for the divider to move to.
+     */
+    protected int positionForMouseEvent(MouseEvent e)
+    {
+      return e.getX() + getX() - offset;
+    }
+
+    /**
+     * This method returns one of the two paramters for the orientation. In
+     * this case, it returns x.
+     *
+     * @param x The x coordinate.
+     * @param y The y coordinate.
+     *
+     * @return The x coordinate.
+     */
+    protected int getNeededLocation(int x, int y)
+    {
+      return x;
+    }
+
+    /**
+     * This method is called to pass on the drag information to the UI through
+     * dragDividerTo.
+     *
+     * @param newX The x coordinate of the MouseEvent.
+     * @param newY The y coordinate of the MouseEvent.
+     */
+    protected void continueDrag(int newX, int newY)
+    {
+      if (isValid())
+        dragDividerTo(adjust(newX, newY));
+    }
+
+    /**
+     * This method is called to pass on the drag information  to the UI
+     * through dragDividerTo.
+     *
+     * @param e The MouseEvent.
+     */
+    protected void continueDrag(MouseEvent e)
+    {
+      if (isValid())
+        dragDividerTo(positionForMouseEvent(e));
+    }
+
+    /**
+     * This method is called to finish the drag session  by calling
+     * finishDraggingTo.
+     *
+     * @param x The x coordinate of the MouseEvent.
+     * @param y The y coordinate of the MouseEvent.
+     */
+    protected void completeDrag(int x, int y)
+    {
+      finishDraggingTo(adjust(x, y));
+    }
+
+    /**
+     * This method is called to finish the drag session  by calling
+     * finishDraggingTo.
+     *
+     * @param e The MouseEvent.
+     */
+    protected void completeDrag(MouseEvent e)
+    {
+      finishDraggingTo(positionForMouseEvent(e));
+    }
+
+    /**
+     * This is a helper method that includes the offset in the needed
+     * location.
+     *
+     * @param x The x coordinate of the MouseEvent.
+     * @param y The y coordinate of the MouseEvent.
+     *
+     * @return The needed location adjusted by the offsets.
+     */
+    int adjust(int x, int y)
+    {
+      return getNeededLocation(x, y) + getX() - offset;
+    }
+  }
+
+  /**
+   * This is a helper class that controls dragging when  the orientation is
+   * VERTICAL_SPLIT.
+   */
+  protected class VerticalDragController extends DragController
+  {
+    /**
+     * Creates a new VerticalDragController object.
+     *
+     * @param e The MouseEvent to initialize with.
+     */
+    protected VerticalDragController(MouseEvent e)
+    {
+      super(e);
+      offset = e.getY();
+    }
+
+    /**
+     * This method returns one of the two parameters given the orientation. In
+     * this case, it returns y.
+     *
+     * @param x The x coordinate of the MouseEvent.
+     * @param y The y coordinate of the MouseEvent.
+     *
+     * @return The y coordinate.
+     */
+    protected int getNeededLocation(int x, int y)
+    {
+      return y;
+    }
+
+    /**
+     * This method returns the new location of the divider given a MouseEvent.
+     *
+     * @param e The MouseEvent.
+     *
+     * @return The new location of the divider.
+     */
+    protected int positionForMouseEvent(MouseEvent e)
+    {
+      return e.getY() + getY() - offset;
+    }
+
+    /**
+     * This is a helper method that includes the offset in the needed
+     * location.
+     *
+     * @param x The x coordinate of the MouseEvent.
+     * @param y The y coordinate of the MouseEvent.
+     *
+     * @return The needed location adjusted by the offsets.
+     */
+    int adjust(int x, int y)
+    {
+      return getNeededLocation(x, y) + getY() - offset;
+    }
+  }
+
+  /**
+   * This helper class acts as the Layout Manager for the divider.
+   */
+  protected class DividerLayout implements LayoutManager
+  {
+    /**
+     * Creates a new DividerLayout object.
+     */
+    protected DividerLayout()
+    {
+      // Nothing to do here.
+    }
+
+    /**
+     * This method is called when a Component is added.
+     *
+     * @param string The constraints string.
+     * @param c The Component to add.
+     */
+    public void addLayoutComponent(String string, Component c)
+    {
+      // Do nothing.
+    }
+
+    /**
+     * This method is called to lay out the container.
+     *
+     * @param c The container to lay out.
+     */
+    public void layoutContainer(Container c)
+    {
+      if (leftButton != null && rightButton != null
+          && c == BasicSplitPaneDivider.this)
+        {
+          if (splitPane.isOneTouchExpandable())
+            {
+              Insets insets = getInsets();
+              if (orientation == JSplitPane.HORIZONTAL_SPLIT)
+                {
+                  int size = getWidth() - insets.left - insets.right;
+                  size = Math.max(size, 0);
+                  size = Math.min(size, ONE_TOUCH_SIZE);
+                  int x, y;
+                  if (centerOneTouchButtons)
+                    {
+                      y = insets.top;
+                      x = (getWidth() - size) / 2;
+                    }
+                  else
+                    {
+                      x = insets.left;
+                      y = 0;
+                    }
+
+                  leftButton.setBounds(x, y + ONE_TOUCH_OFFSET, size,
+                                       size * 2);
+                  rightButton.setBounds(x, y + ONE_TOUCH_OFFSET
+                                        + ONE_TOUCH_SIZE * 2, size, size * 2);
+                }
+              else
+                {
+                  int size = getHeight() - insets.top - insets.bottom;
+                  size = Math.max(size, 0);
+                  size = Math.min(size, ONE_TOUCH_SIZE);
+                  int x, y;
+                  if (centerOneTouchButtons)
+                    {
+                      x = insets.left;
+                      y = (getHeight() - size) / 2;
+                    }
+                  else
+                    {
+                      x = 0;
+                      y = insets.top;
+                    }
+                  leftButton.setBounds(x + ONE_TOUCH_OFFSET, y, size * 2,
+                                       size);
+                  rightButton.setBounds(x + ONE_TOUCH_OFFSET
+                                        + ONE_TOUCH_SIZE * 2, y, size * 2,
+                                        size);
+                }
+            }
+          else
+            {
+              // The JDK sets this bounds for disabled one touch buttons, so
+              // do we.
+              leftButton.setBounds(-5, -5, 1, 1);
+              rightButton.setBounds(-5, -5, 1, 1);
+            }
+        }
+    }
+
+    /**
+     * This method returns the minimum layout size.
+     *
+     * @param c The container to calculate for.
+     *
+     * @return The minimum layout size.
+     */
+    public Dimension minimumLayoutSize(Container c)
+    {
+      return preferredLayoutSize(c);
+    }
+
+    /**
+     * This method returns the preferred layout size.
+     *
+     * @param c The container to calculate for.
+     *
+     * @return The preferred layout size.
+     */
+    public Dimension preferredLayoutSize(Container c)
+    {
+      return new Dimension(dividerSize, dividerSize);
+    }
+
+    /**
+     * This method is called when a component is removed.
+     *
+     * @param c The component to remove.
+     */
+    public void removeLayoutComponent(Component c)
+    {
+      // Do nothing.
+    }
+
+  }
+}