diff options
Diffstat (limited to 'libjava/classpath/javax/swing/JScrollPane.java')
| -rw-r--r-- | libjava/classpath/javax/swing/JScrollPane.java | 712 |
1 files changed, 712 insertions, 0 deletions
diff --git a/libjava/classpath/javax/swing/JScrollPane.java b/libjava/classpath/javax/swing/JScrollPane.java new file mode 100644 index 000000000..6d17857d3 --- /dev/null +++ b/libjava/classpath/javax/swing/JScrollPane.java @@ -0,0 +1,712 @@ +/* JScrollPane.java -- + Copyright (C) 2002, 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; + +import java.awt.Component; +import java.awt.ComponentOrientation; +import java.awt.Insets; +import java.awt.LayoutManager; +import java.awt.Rectangle; +import java.beans.PropertyChangeEvent; +import java.beans.PropertyChangeListener; + +import javax.accessibility.Accessible; +import javax.accessibility.AccessibleContext; +import javax.swing.border.Border; +import javax.swing.event.ChangeEvent; +import javax.swing.event.ChangeListener; +import javax.swing.plaf.ScrollPaneUI; +import javax.swing.plaf.UIResource; + +/** + * A component that embeds another component and enables it to be scrolled + * both in horizontal and vertical direction. + * + * <table> + * <tr><th>Property </th><th>Stored in </th><th>Bound?</th></tr> + * <tr><td>columnHeader </td><td>scrollPane </td><td>yes </td></tr> + * <tr><td>columnHeaderView </td><td>columnHeader </td><td>no </td></tr> + * <tr><td>componentOrientation </td><td>scrollPane </td><td>yes </td></tr> + * <tr><td>horizontalScrollBar </td><td>scrollPane </td><td>yes </td></tr> + * <tr><td>horizontalScrollBarPolicy </td><td>scrollPane </td><td>yes </td></tr> + * <tr><td>layout </td><td>scrollPane </td><td>yes </td></tr> + * <tr><td>rowHeader </td><td>scrollPane </td><td>yes </td></tr> + * <tr><td>rowHeaderView </td><td>rowHeader </td><td>no </td></tr> + * <tr><td>validateRoot </td><td>scrollPane </td><td>no </td></tr> + * <tr><td>verticalScrollBar </td><td>scrollPane </td><td>yes </td></tr> + * <tr><td>verticalScrollBarPolicy </td><td>scrollPane </td><td>yes </td></tr> + * <tr><td>viewport </td><td>scrollPane </td><td>yes </td></tr> + * <tr><td>viewportBorder </td><td>scrollPane </td><td>yes </td></tr> + * <tr><td>viewportBorderBounds </td><td>scrollPane </td><td>no </td></tr> + * <tr><td>viewportView </td><td>viewport </td><td>no </td></tr> + * <tr><td>wheelScrollingEnabled </td><td>scrollPane </td><td>yes </td></tr> + * </table> + */ +public class JScrollPane extends JComponent + implements Accessible, ScrollPaneConstants +{ + /** + * Provides accessibility support for the <code>JScrollPane</code>. + * + * @author Roman Kennke (kennke@aicas.com) + */ + protected class AccessibleJScrollPane extends AccessibleJComponent + implements ChangeListener, PropertyChangeListener + { + + /** + * The viewport of the underlying scrollpane. + */ + protected JViewport viewPort; + + /** + * Creates a new <code>AccessibleJScrollPane</code> object. This + * initializes the <code>viewport</code> field with the current viewport + * from the scrollpane associated with this + * <code>AccessibleJScrollPane</code>. + */ + public AccessibleJScrollPane() + { + viewPort = getViewport(); + viewPort.addChangeListener(this); + viewPort.addPropertyChangeListener(this); + } + + /** + * Receives notification when the state of the viewport changes. + * + * @param event the change event + */ + public void stateChanged(ChangeEvent event) + { + // TODO: Figure out what should be done here, if anything. + } + + /** + * Receives notification if any of the viewport's bound properties changes. + * + * @param e the propery change event + */ + public void propertyChange(PropertyChangeEvent e) + { + // TODO: Figure out what should be done here, if anything. + } + + /** + * Resets the <code>viewPort</code> field when the scrollpane's viewport + * changes. This method is called by + * {@link JScrollPane#setViewport(JViewport)} in order to update the + * <code>viewPort</code> field and set up the listeners on this viewport + * correctly. + */ + public void resetViewPort() + { + viewPort.removeChangeListener(this); + viewPort.removePropertyChangeListener(this); + viewPort = getViewport(); + viewPort.addChangeListener(this); + viewPort.addPropertyChangeListener(this); + } + } + + private static final long serialVersionUID = 5203525440012340014L; + + protected JViewport columnHeader; + protected JViewport rowHeader; + + protected Component lowerLeft; + protected Component lowerRight; + protected Component upperLeft; + protected Component upperRight; + + protected JScrollBar horizontalScrollBar; + protected int horizontalScrollBarPolicy; + protected JScrollBar verticalScrollBar; + protected int verticalScrollBarPolicy; + + protected JViewport viewport; + + private Border viewportBorder; + + private boolean wheelScrollingEnabled; + + public JViewport getColumnHeader() + { + return columnHeader; + } + + public Component getCorner(String key) + { + if (getComponentOrientation() + == ComponentOrientation.LEFT_TO_RIGHT) + { + if (key == LOWER_LEADING_CORNER) + key = LOWER_LEFT_CORNER; + else if (key == LOWER_TRAILING_CORNER) + key = LOWER_RIGHT_CORNER; + else if (key == UPPER_LEADING_CORNER) + key = UPPER_LEFT_CORNER; + else if (key == UPPER_TRAILING_CORNER) + key = UPPER_RIGHT_CORNER; + } + else if (getComponentOrientation() + == ComponentOrientation.RIGHT_TO_LEFT) + { + if (key == LOWER_LEADING_CORNER) + key = LOWER_RIGHT_CORNER; + else if (key == LOWER_TRAILING_CORNER) + key = LOWER_LEFT_CORNER; + else if (key == UPPER_LEADING_CORNER) + key = UPPER_RIGHT_CORNER; + else if (key == UPPER_TRAILING_CORNER) + key = UPPER_LEFT_CORNER; + } + + if (key == LOWER_RIGHT_CORNER) + return lowerRight; + else if (key == UPPER_RIGHT_CORNER) + return upperRight; + else if (key == LOWER_LEFT_CORNER) + return lowerLeft; + else if (key == UPPER_LEFT_CORNER) + return upperLeft; + return null; + } + + public JScrollBar getHorizontalScrollBar() + { + return horizontalScrollBar; + } + + public int getHorizontalScrollBarPolicy() + { + return horizontalScrollBarPolicy; + } + + public JViewport getRowHeader() + { + return rowHeader; + } + + public JScrollBar getVerticalScrollBar() + { + return verticalScrollBar; + } + + public int getVerticalScrollBarPolicy() + { + return verticalScrollBarPolicy; + } + + public JViewport getViewport() + { + return viewport; + } + + public Border getViewportBorder() + { + return viewportBorder; + } + + public Rectangle getViewportBorderBounds() + { + if (viewportBorder == null) + { + if (getViewport() == null) + return new Rectangle(0, 0, 0, 0); + else + return getViewport().getBounds(); + } + else + { + Insets i = viewportBorder.getBorderInsets(getViewport()); + if (getViewport() == null) + return new Rectangle(0, 0, i.left + i.right, i.top + i.bottom); + else + { + Rectangle b = getViewport().getBounds(); + return new Rectangle(b.x - i.left, + b.y - i.top, + b.width + i.left + i.right, + b.height + i.top + i.bottom); + } + } + } + + public boolean isWheelScrollingEnabled() + { + return wheelScrollingEnabled; + } + + + + private void sync() + { + LayoutManager m = super.getLayout(); + if (m != null && m instanceof ScrollPaneLayout) + { + ScrollPaneLayout sl = (ScrollPaneLayout) m; + sl.syncWithScrollPane(this); + } + } + + private void removeNonNull(Component c) + { + if (c != null) + remove(c); + } + + private void addNonNull(Component c, Object constraints) + { + if (c != null) + add(c, constraints); + } + + public void setComponentOrientation(ComponentOrientation co) + { + ComponentOrientation old = super.getComponentOrientation(); + super.setComponentOrientation(co); + firePropertyChange("componentOrientation", old, co); + sync(); + } + + public void setColumnHeader(JViewport h) + { + if (columnHeader == h) + return; + + JViewport old = columnHeader; + removeNonNull(old); + columnHeader = h; + addNonNull(h, JScrollPane.COLUMN_HEADER); + firePropertyChange("columnHeader", old, h); + sync(); + } + + public void setColumnHeaderView(Component c) + { + if (columnHeader == null) + setColumnHeader(createViewport()); + columnHeader.setView(c); + sync(); + } + + public void setCorner(String key, Component c) + { + if (getComponentOrientation() + == ComponentOrientation.LEFT_TO_RIGHT) + { + if (key == LOWER_LEADING_CORNER) + key = LOWER_LEFT_CORNER; + else if (key == LOWER_TRAILING_CORNER) + key = LOWER_RIGHT_CORNER; + else if (key == UPPER_LEADING_CORNER) + key = UPPER_LEFT_CORNER; + else if (key == UPPER_TRAILING_CORNER) + key = UPPER_RIGHT_CORNER; + } + else if (getComponentOrientation() + == ComponentOrientation.RIGHT_TO_LEFT) + { + if (key == LOWER_LEADING_CORNER) + key = LOWER_RIGHT_CORNER; + else if (key == LOWER_TRAILING_CORNER) + key = LOWER_LEFT_CORNER; + else if (key == UPPER_LEADING_CORNER) + key = UPPER_RIGHT_CORNER; + else if (key == UPPER_TRAILING_CORNER) + key = UPPER_LEFT_CORNER; + } + + if (key == LOWER_RIGHT_CORNER) + { + removeNonNull(lowerRight); + lowerRight = c; + addNonNull(c, JScrollPane.LOWER_RIGHT_CORNER); + } + else if (key == UPPER_RIGHT_CORNER) + { + removeNonNull(upperRight); + upperRight = c; + addNonNull(c, JScrollPane.UPPER_RIGHT_CORNER); + } + else if (key == LOWER_LEFT_CORNER) + { + removeNonNull(lowerLeft); + lowerLeft = c; + addNonNull(c, JScrollPane.LOWER_LEFT_CORNER); + } + else if (key == UPPER_LEFT_CORNER) + { + removeNonNull(upperLeft); + upperLeft = c; + addNonNull(c, JScrollPane.UPPER_LEFT_CORNER); + } + else + throw new IllegalArgumentException("unknown corner " + key); + sync(); + } + + public void setHorizontalScrollBar(JScrollBar h) + { + if (horizontalScrollBar == h) + return; + + JScrollBar old = horizontalScrollBar; + removeNonNull(old); + horizontalScrollBar = h; + addNonNull(h, JScrollPane.HORIZONTAL_SCROLLBAR); + firePropertyChange("horizontalScrollBar", old, h); + sync(); + + } + + public void setHorizontalScrollBarPolicy(int h) + { + if (horizontalScrollBarPolicy == h) + return; + + if (h != HORIZONTAL_SCROLLBAR_AS_NEEDED + && h != HORIZONTAL_SCROLLBAR_NEVER + && h != HORIZONTAL_SCROLLBAR_ALWAYS) + throw new IllegalArgumentException("unknown horizontal scrollbar policy"); + + int old = horizontalScrollBarPolicy; + horizontalScrollBarPolicy = h; + firePropertyChange("horizontalScrollBarPolicy", old, h); + sync(); + revalidate(); + } + + public void setLayout(LayoutManager l) + { + LayoutManager old = super.getLayout(); + ScrollPaneLayout tmp = (ScrollPaneLayout) l; + super.setLayout(l); + tmp.syncWithScrollPane(this); + firePropertyChange("layout", old, l); + sync(); + } + + public void setRowHeader(JViewport v) + { + if (rowHeader == v) + return; + + JViewport old = rowHeader; + removeNonNull(old); + rowHeader = v; + addNonNull(v, JScrollPane.ROW_HEADER); + firePropertyChange("rowHeader", old, v); + sync(); + } + + public void setRowHeaderView(Component c) + { + if (rowHeader == null) + setRowHeader(createViewport()); + rowHeader.setView(c); + sync(); + } + + public void setVerticalScrollBar(JScrollBar v) + { + if (verticalScrollBar == v) + return; + + JScrollBar old = verticalScrollBar; + removeNonNull(old); + verticalScrollBar = v; + addNonNull(v, JScrollPane.VERTICAL_SCROLLBAR); + firePropertyChange("verticalScrollBar", old, v); + sync(); + } + + public void setVerticalScrollBarPolicy(int v) + { + if (verticalScrollBarPolicy == v) + return; + + if (v != VERTICAL_SCROLLBAR_AS_NEEDED + && v != VERTICAL_SCROLLBAR_NEVER + && v != VERTICAL_SCROLLBAR_ALWAYS) + throw new IllegalArgumentException("unknown vertical scrollbar policy"); + + int old = verticalScrollBarPolicy; + verticalScrollBarPolicy = v; + firePropertyChange("verticalScrollBarPolicy", old, v); + sync(); + revalidate(); + } + + public void setWheelScrollingEnabled(boolean b) + { + if (wheelScrollingEnabled == b) + return; + + boolean old = wheelScrollingEnabled; + wheelScrollingEnabled = b; + firePropertyChange("wheelScrollingEnabled", old, b); + sync(); + } + + public void setViewport(JViewport v) + { + if (viewport == v) + return; + + JViewport old = viewport; + removeNonNull(old); + viewport = v; + addNonNull(v, JScrollPane.VIEWPORT); + revalidate(); + repaint(); + firePropertyChange("viewport", old, v); + sync(); + if (accessibleContext != null) + { + AccessibleJScrollPane asp = (AccessibleJScrollPane) accessibleContext; + asp.resetViewPort(); + } + } + + public void setViewportBorder(Border b) + { + if (viewportBorder == b) + return; + + Border old = viewportBorder; + viewportBorder = b; + firePropertyChange("viewportBorder", old, b); + sync(); + } + + public void setViewportView(Component view) + { + if (getViewport() == null) + { + setViewport(createViewport()); + } + + if (view != null) + { + getViewport().setView(view); + } + sync(); + } + + public boolean isValidateRoot() + { + return true; + } + + /** + * Creates a new <code>JScrollPane</code> without a view. The scrollbar + * policy is set to {@link #VERTICAL_SCROLLBAR_AS_NEEDED} and + * {@link #HORIZONTAL_SCROLLBAR_AS_NEEDED}. + */ + public JScrollPane() + { + this(null); + } + + /** + * Creates a new <code>JScrollPane</code> that embeds the specified + * <code>view</code> component, displaying vertical and horizontal scrollbars + * as needed. + * + * @param view the component that is embedded inside the JScrollPane + */ + public JScrollPane(Component view) + { + this(view, + VERTICAL_SCROLLBAR_AS_NEEDED, + HORIZONTAL_SCROLLBAR_AS_NEEDED); + } + + /** + * Creates a new <code>JScrollPane</code> without a view; The scrollbar + * policies are set to <code>vsbPolicy</code> and <code>hsbPolicy</code>. + * + * @param vsbPolicy the vertical scrollbar policy to set + * @param hsbPolicy the vertical scrollbar policy to set + * + * @see ScrollPaneConstants#HORIZONTAL_SCROLLBAR_ALWAYS + * @see ScrollPaneConstants#HORIZONTAL_SCROLLBAR_AS_NEEDED + * @see ScrollPaneConstants#HORIZONTAL_SCROLLBAR_NEVER + * @see ScrollPaneConstants#VERTICAL_SCROLLBAR_ALWAYS + * @see ScrollPaneConstants#VERTICAL_SCROLLBAR_AS_NEEDED + * @see ScrollPaneConstants#VERTICAL_SCROLLBAR_NEVER + */ + public JScrollPane(int vsbPolicy, int hsbPolicy) + { + this(null, vsbPolicy, hsbPolicy); + } + + /** + * Creates a new <code>JScrollPane</code> that embeds the specified + * <code>view</code> component; The scrollbar + * policies are set to <code>vsbPolicy</code> and <code>hsbPolicy</code>. + * + * @param vsbPolicy the vertical scrollbar policy to set + * @param hsbPolicy the vertical scrollbar policy to set + * + * @see ScrollPaneConstants#HORIZONTAL_SCROLLBAR_ALWAYS + * @see ScrollPaneConstants#HORIZONTAL_SCROLLBAR_AS_NEEDED + * @see ScrollPaneConstants#HORIZONTAL_SCROLLBAR_NEVER + * @see ScrollPaneConstants#VERTICAL_SCROLLBAR_ALWAYS + * @see ScrollPaneConstants#VERTICAL_SCROLLBAR_AS_NEEDED + * @see ScrollPaneConstants#VERTICAL_SCROLLBAR_NEVER + */ + public JScrollPane(Component view, int vsbPolicy, int hsbPolicy) + { + wheelScrollingEnabled = true; + setVerticalScrollBarPolicy(vsbPolicy); + setVerticalScrollBar(createVerticalScrollBar()); + setHorizontalScrollBarPolicy(hsbPolicy); + setHorizontalScrollBar(createHorizontalScrollBar()); + viewport = createViewport(); + if (view != null) + getViewport().setView(view); + add(viewport,0); + setLayout(new ScrollPaneLayout()); + setOpaque(false); + updateUI(); + } + + + public JScrollBar createHorizontalScrollBar() + { + return new ScrollBar(SwingConstants.HORIZONTAL); + } + + public JScrollBar createVerticalScrollBar() + { + return new ScrollBar(SwingConstants.VERTICAL); + } + + protected JViewport createViewport() + { + return new JViewport(); + } + + public String getUIClassID() + { + return "ScrollPaneUI"; + } + + public void updateUI() + { + setUI((ScrollPaneUI) UIManager.getUI(this)); + } + + /** + * This method returns the scrollpane's UI delegate. + * + * @return The scrollpane's UI delegate. + */ + public ScrollPaneUI getUI() + { + return (ScrollPaneUI) ui; + } + + /** + * This method sets the scrollpane's UI delegate. + * + * @param ui The scrollpane's UI delegate. + */ + public void setUI(ScrollPaneUI ui) + { + super.setUI(ui); + } + + protected class ScrollBar + extends JScrollBar + implements UIResource + { + private static final long serialVersionUID = -42032395320987283L; + + public ScrollBar(int orientation) + { + super(orientation); + } + + public int getBlockIncrement(int direction) + { + Component view = JScrollPane.this.getViewport().getView(); + if (view == null || (! (view instanceof Scrollable))) + return super.getBlockIncrement(direction); + else + { + Scrollable s = (Scrollable) view; + return s.getScrollableBlockIncrement(JScrollPane.this.getViewport().getViewRect(), + this.getOrientation(), + direction); + } + } + + public int getUnitIncrement(int direction) + { + Component view = JScrollPane.this.getViewport().getView(); + if (view == null || (! (view instanceof Scrollable))) + return super.getUnitIncrement(direction); + else + { + Scrollable s = (Scrollable) view; + return s.getScrollableUnitIncrement(JScrollPane.this.getViewport().getViewRect(), + this.getOrientation(), + direction); + } + } + } + + /** + * Returns the accessible context associated with this + * <code>JScrollPane</code>. + * + * @return the accessible context associated with this + * <code>JScrollPane</code> + */ + public AccessibleContext getAccessibleContext() + { + if (accessibleContext == null) + accessibleContext = new AccessibleJScrollPane(); + return accessibleContext; + } +} |