Subversion Repositories openrisc

/* ScrollPane.java -- Scrolling window

   Copyright (C) 1999, 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 java.awt;

import java.awt.event.MouseEvent;

import java.awt.peer.ComponentPeer;

import java.awt.peer.ScrollPanePeer;

import javax.accessibility.Accessible;

import javax.accessibility.AccessibleContext;

import javax.accessibility.AccessibleRole;

/**

  * This widget provides a scrollable region that allows a single

  * subcomponent to be viewed through a smaller window.

  *

  * @author Aaron M. Renn (arenn@urbanophile.com)

  */

public class ScrollPane extends Container implements Accessible

{

/*

 * Static Variables

 */

/**

  * Constant indicating that scrollbars are created as needed in this

  * windows.

  */

public static final int SCROLLBARS_AS_NEEDED = 0;

/**

  * Constant indicating that scrollbars are always displayed in this

  * window.

  */

public static final int SCROLLBARS_ALWAYS = 1;

/**

  * Constant indicating that scrollbars are never displayed in this window.

  */

public static final int SCROLLBARS_NEVER = 2;

/**

 * The number used to generate the name returned by getName.

 */

private static transient long next_scrollpane_number;

// Serialization constant

private static final long serialVersionUID = 7956609840827222915L;

/*************************************************************************/

/*

 * Instance Variables

 */

/**

  * @serial The horizontal scrollbar for this window.  The methods

  * <code>setMinimum()</code>, <code>setMaximum</code>, and

  * <code>setVisibleAmount</code> must not be called on this scrollbar.

  */

private ScrollPaneAdjustable hAdjustable;

/**

  * @serial The vertical scrollbar for this window.  The methods

  * <code>setMinimum()</code>, <code>setMaximum</code>, and

  * <code>setVisibleAmount</code> must not be called on this scrollbar.

  */

private ScrollPaneAdjustable vAdjustable;

/**

  * @serial Indicates when scrollbars are displayed in this window, will

  * be one of the constants from this class.

  */

private int scrollbarDisplayPolicy;

// Current scroll position

private Point scrollPosition = new Point(0, 0);

private boolean wheelScrollingEnabled;

/*************************************************************************/

/*

 * Constructors

 */

/**

  * Initializes a new instance of <code>ScrollPane</code> with a default

  * scrollbar policy of <code>SCROLLBARS_AS_NEEDED</code>.

  *

  * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true.

  */

public

ScrollPane()

{

  this(SCROLLBARS_AS_NEEDED);

}

/*************************************************************************/

/**

  * Initializes a new instance of <code>ScrollPane</code> with the

  * specified scrollbar policy.

  *

  * @param scrollbarDisplayPolicy When to display scrollbars, which must

  * be one of the constants defined in this class.

  *

  * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true.

  */

public

ScrollPane(int scrollbarDisplayPolicy)

{

  if (GraphicsEnvironment.isHeadless ())

    throw new HeadlessException ();

  this.scrollbarDisplayPolicy = scrollbarDisplayPolicy;

  if (scrollbarDisplayPolicy != SCROLLBARS_ALWAYS

      && scrollbarDisplayPolicy != SCROLLBARS_AS_NEEDED

      && scrollbarDisplayPolicy != SCROLLBARS_NEVER)

    throw new IllegalArgumentException("Bad scrollbarDisplayPolicy: " +

                                       scrollbarDisplayPolicy);

  if (scrollbarDisplayPolicy != SCROLLBARS_NEVER)

    {

      hAdjustable = new ScrollPaneAdjustable (this, Scrollbar.HORIZONTAL);

      vAdjustable = new ScrollPaneAdjustable (this, Scrollbar.VERTICAL);

    }

  wheelScrollingEnabled = true;

  // Default size.

  setSize(100,100);

}

/*************************************************************************/

/*

 * Instance Variables

 */

/**

  * Returns the current scrollbar display policy.

  *

  * @return The current scrollbar display policy.

  */

public int

getScrollbarDisplayPolicy()

{

  return(scrollbarDisplayPolicy);

}

/*************************************************************************/

/**

  * Returns the horizontal scrollbar for this object.  If the scrollbar

  * display policy is set to <code>SCROLLBARS_NEVER</code> then this

  * will be <code>null</code>.

  *

  * @return The horizontal scrollbar for this window.

  */

public Adjustable

getHAdjustable()

{

  return(hAdjustable);

}

/*************************************************************************/

/**

  * Returns the vertical scrollbar for this object.  If the scrollbar

  * display policy is set to <code>SCROLLBARS_NEVER</code> then this

  * will be <code>null</code>.

  *

  * @return The horizontal scrollbar for this window.

  */

public Adjustable

getVAdjustable()

{

  return(vAdjustable);

}

/*************************************************************************/

/**

  * Returns the current viewport size.  The viewport is the region of

  * this object's window where the child is actually displayed.

  *

  * @return The viewport size.

  */

public Dimension getViewportSize ()

{

  Dimension viewsize = getSize ();

  Insets insets = getInsets ();

  viewsize.width -= (insets.left + insets.right);

  viewsize.height -= (insets.top + insets.bottom);

  Component[] list = getComponents();

  if ((list == null) || (list.length <= 0))

    return viewsize;

  Dimension dim = list[0].getPreferredSize();

  if (dim.width <= 0 && dim.height <= 0)

    return viewsize;

  int vScrollbarWidth = getVScrollbarWidth ();

  int hScrollbarHeight = getHScrollbarHeight ();

  if (scrollbarDisplayPolicy == SCROLLBARS_ALWAYS)

    {

      viewsize.width -= vScrollbarWidth;

      viewsize.height -= hScrollbarHeight;

      return viewsize;

    }

  if (scrollbarDisplayPolicy == SCROLLBARS_NEVER)

    return viewsize;

  // The scroll policy is SCROLLBARS_AS_NEEDED, so we need to see if

  // either scrollbar is needed.

  // Assume we don't need either scrollbar.

  boolean mayNeedVertical = false;

  boolean mayNeedHorizontal = false;

  boolean needVertical = false;

  boolean needHorizontal = false;

  // Check if we need vertical scrollbars.  If we do, then we need to

  // subtract the width of the vertical scrollbar from the viewport's

  // width.

  if (dim.height > viewsize.height)

    needVertical = true;

  else if (dim.height > (viewsize.height - hScrollbarHeight))

    // This is tricky.  In this case the child is tall enough that its

    // bottom edge would be covered by a horizontal scrollbar, if one

    // were present.  This means that if there's a horizontal

    // scrollbar then we need a vertical scrollbar.

    mayNeedVertical = true;

  if (dim.width > viewsize.width)

    needHorizontal = true;

  else if (dim.width > (viewsize.width - vScrollbarWidth))

    mayNeedHorizontal = true;

  if (needVertical && mayNeedHorizontal)

    needHorizontal = true;

  if (needHorizontal && mayNeedVertical)

    needVertical = true;

  if (needHorizontal)

    viewsize.height -= hScrollbarHeight;

  if (needVertical)

    viewsize.width -= vScrollbarWidth;

  return viewsize;

}

/*************************************************************************/

/**

  * Returns the height of a horizontal scrollbar.

  *

  * @return The height of a horizontal scrollbar.

  */

public int

getHScrollbarHeight()

{

  ScrollPanePeer spp = (ScrollPanePeer)getPeer();

  if (spp != null)

    return(spp.getHScrollbarHeight());

  else

    return(0); // FIXME: What to do here?

}

/*************************************************************************/

/**

  * Returns the width of a vertical scrollbar.

  *

  * @return The width of a vertical scrollbar.

  */

public int

getVScrollbarWidth()

{

  ScrollPanePeer spp = (ScrollPanePeer)getPeer();

  if (spp != null)

    return(spp.getVScrollbarWidth());

  else

    return(0); // FIXME: What to do here?

}

/*************************************************************************/

/**

  * Returns the current scroll position of the viewport.

  *

  * @return The current scroll position of the viewport.

  *

  * @throws NullPointerException if the scrollpane does have a child.

  */

public Point

getScrollPosition()

{

  if (getComponentCount() == 0)

    throw new NullPointerException();

  int x = 0;

  int y = 0;

  Adjustable v = getVAdjustable();

  Adjustable h = getHAdjustable();

  if (v != null)

    y = v.getValue();

  if (h != null)

    x = h.getValue();

  return(new Point(x, y));

}

/*************************************************************************/

/**

  * Sets the scroll position to the specified value.

  *

  * @param scrollPosition The new scrollPosition.

  *

  * @exception IllegalArgumentException If the specified value is outside

  * the legal scrolling range.

  */

public void

setScrollPosition(Point scrollPosition) throws IllegalArgumentException

{

  setScrollPosition(scrollPosition.x, scrollPosition.y);

}

/*************************************************************************/

/**

  * Sets the scroll position to the specified value.

  *

  * @param x The new X coordinate of the scroll position.

  * @param y The new Y coordinate of the scroll position.

  *

  * @throws NullPointerException if scrollpane does not have a child.

  *

  * @exception IllegalArgumentException If the specified value is outside

  * the legal scrolling range.

  */

public void

setScrollPosition(int x, int y)

{

  if (getComponentCount() == 0)

    throw new NullPointerException("child is null");

  if (x > (int) (getComponent(0).getWidth() - getViewportSize().getWidth()))

    x = (int) (getComponent(0).getWidth() - getViewportSize().getWidth());

  if (y > (int) (getComponent(0).getHeight() - getViewportSize().getHeight()))

    y = (int) (getComponent(0).getHeight() - getViewportSize().getHeight());

  if (x < 0)

    x = 0;

  if (y < 0)

    y = 0;

  Adjustable h = getHAdjustable();

  Adjustable v = getVAdjustable();

  if (h != null)

    h.setValue(x);

  if (v != null)

    v.setValue(y);

  ScrollPanePeer spp = (ScrollPanePeer)getPeer();

  if (spp != null)

    spp.setScrollPosition(x, y);

}

/*************************************************************************/

/**

  * Notifies this object that it should create its native peer.

  */

public void

addNotify()

{

  if (peer != null)

    return;

  setPeer((ComponentPeer)getToolkit().createScrollPane(this));

  super.addNotify();

  Component[] list = getComponents();

  if (list != null && list.length > 0 && list[0].isLightweight())

  {

    Panel panel = new Panel();

    panel.setLayout(new BorderLayout());

    panel.add(list[0], BorderLayout.CENTER);

    add(panel);

  }

}

/*************************************************************************/

/**

  * Notifies this object that it should destroy its native peers.

  */

public void

removeNotify()

{

  super.removeNotify();

}

/*************************************************************************/

/**

  * Adds the specified child component to this container.  A

  * <code>ScrollPane</code> can have at most one child, so if a second

  * one is added, then first one is removed.

  *

  * @param component The component to add to this container.

  * @param constraints A list of layout constraints for this object.

  * @param index The index at which to add the child, which is ignored

  * in this implementation.

  */

  protected final void addImpl (Component component, Object constraints,

                                int index)

{

  Component[] list = getComponents();

  if ((list != null) && (list.length > 0))

    remove(list[0]);

  super.addImpl(component, constraints, index);

}

/*************************************************************************/

/**

  * Lays out this component.  This consists of resizing the sole child

  * component to its perferred size.

  */

public void

doLayout()

{

  layout ();

}

/*************************************************************************/

/**

  * Lays out this component.  This consists of resizing the sole child

  * component to its perferred size.

  *

  * @deprecated This method is deprecated in favor of

  * <code>doLayout()</code>.

  */

public void

layout()

{

  Component[] list = getComponents ();

  if ((list != null) && (list.length > 0))

    {

      Dimension dim = list[0].getPreferredSize ();

      Dimension vp = getViewportSize ();

      if (dim.width < vp.width)

        dim.width = vp.width;

      if (dim.height < vp.height)

        dim.height = vp.height;

      ScrollPanePeer peer = (ScrollPanePeer) getPeer ();

      if (peer != null)

        peer.childResized (dim.width, dim.height);

      list[0].setSize (dim);

      Point p = getScrollPosition ();

      if (p.x > dim.width)

        p.x = dim.width;

      if (p.y > dim.height)

        p.y = dim.height;

      setScrollPosition (p);

      list[0].setLocation(new Point());

    }

}

/*************************************************************************/

/**

  * This method overrides its superclass method to ensure no layout

  * manager is set for this container.  <code>ScrollPane</code>'s do

  * not have layout managers.

  *

  * @param layoutManager Ignored

  * @throws AWTError Always throws this error when called.

  */

public final void

setLayout(LayoutManager layoutManager)

{

  throw new AWTError("ScrollPane controls layout");

}

/*************************************************************************/

/**

  * Prints all of the components in this container.

  *

  * @param graphics The desired graphics context for printing.

  */

public void

printComponents(Graphics graphics)

{

  super.printComponents(graphics);

}

/*************************************************************************/

/**

  * Returns a debug string for this object.

  *

  * @return A debug string for this object.

  */

public String

paramString()

{

  Insets insets = getInsets();

  return getName() + ","

         + getX() + ","

         + getY() + ","

         + getWidth() + "x" + getHeight() + ","

         + getIsValidString() + ","

         + "ScrollPosition=(" + scrollPosition.x + ","

                              + scrollPosition.y + "),"

         + "Insets=(" + insets.top + ","

                      + insets.left + ","

                      + insets.bottom + ","

                      + insets.right + "),"

         + "ScrollbarDisplayPolicy=" + getScrollbarDisplayPolicyString() + ","

         + "wheelScrollingEnabled=" + isWheelScrollingEnabled();

}

private String

getScrollbarDisplayPolicyString()

{

  if (getScrollbarDisplayPolicy() == 0)

    return "as-needed";

  else if (getScrollbarDisplayPolicy() == 1)

    return "always";

  else

    return "never";

}

private String

getIsValidString()

{

  if (isValid())

    return "valid";

  else

    return "invalid";

}

  /**

   * Tells whether or not an event is enabled.

   *

   * @since 1.4

   */

  protected boolean eventTypeEnabled (int type)

  {

    if (type == MouseEvent.MOUSE_WHEEL)

      return wheelScrollingEnabled;

    return super.eventTypeEnabled (type);

  }

  /**

   * Tells whether or not wheel scrolling is enabled.

   *

   * @since 1.4

   */

  public boolean isWheelScrollingEnabled ()

  {

    return wheelScrollingEnabled;

  }

  /**

   * Enables/disables wheel scrolling.

   *

   * @since 1.4

   */

  public void setWheelScrollingEnabled (boolean enable)

  {

    wheelScrollingEnabled = enable;

  }

  protected class AccessibleAWTScrollPane extends AccessibleAWTContainer

  {

    private static final long serialVersionUID = 6100703663886637L;

    public AccessibleRole getAccessibleRole()

    {

      return AccessibleRole.SCROLL_PANE;

    }

  }

  /**

   * Gets the AccessibleContext associated with this <code>ScrollPane</code>.

   * The context is created, if necessary.

   *

   * @return the associated context

   */

  public AccessibleContext getAccessibleContext()

  {

    /* Create the context if this is the first request */

    if (accessibleContext == null)

      accessibleContext = new AccessibleAWTScrollPane();

    return accessibleContext;

  }

  /**

   * Generate a unique name for this <code>ScrollPane</code>.

   *

   * @return A unique name for this <code>ScrollPane</code>.

   */

  String generateName()

  {

    return "scrollpane" + getUniqueLong();

  }

  private static synchronized long getUniqueLong()

  {

    return next_scrollpane_number++;

  }

} // class ScrollPane