FileDocCategorySizeDatePackage
JScrollPane.javaAPI DocJava SE 6 API51947Tue Jun 10 00:26:38 BST 2008javax.swing

JScrollPane

public class JScrollPane extends JComponent implements ScrollPaneConstants, Accessible
Provides a scrollable view of a lightweight component. A JScrollPane manages a viewport, optional vertical and horizontal scroll bars, and optional row and column heading viewports. You can find task-oriented documentation of JScrollPane in How to Use Scroll Panes, a section in The Java Tutorial. Note that JScrollPane does not support heavyweight components.

The following text describes this image.

The JViewport provides a window, or "viewport" onto a data source -- for example, a text file. That data source is the "scrollable client" (aka data model) displayed by the JViewport view. A JScrollPane basically consists of JScrollBars, a JViewport, and the wiring between them, as shown in the diagram at right.

In addition to the scroll bars and viewport, a JScrollPane can have a column header and a row header. Each of these is a JViewport object that you specify with setRowHeaderView, and setColumnHeaderView. The column header viewport automatically scrolls left and right, tracking the left-right scrolling of the main viewport. (It never scrolls vertically, however.) The row header acts in a similar fashion.

Where two scroll bars meet, the row header meets the column header, or a scroll bar meets one of the headers, both components stop short of the corner, leaving a rectangular space which is, by default, empty. These spaces can potentially exist in any number of the four corners. In the previous diagram, the top right space is present and identified by the label "corner component".

Any number of these empty spaces can be replaced by using the setCorner method to add a component to a particular corner. (Note: The same component cannot be added to multiple corners.) This is useful if there's some extra decoration or function you'd like to add to the scroll pane. The size of each corner component is entirely determined by the size of the headers and/or scroll bars that surround it.

A corner component will only be visible if there is an empty space in that corner for it to exist in. For example, consider a component set into the top right corner of a scroll pane with a column header. If the scroll pane's vertical scrollbar is not present, perhaps because the view component hasn't grown large enough to require it, then the corner component will not be shown (since there is no empty space in that corner created by the meeting of the header and vertical scroll bar). Forcing the scroll bar to always be shown, using setVerticalScrollBarPolicy(VERTICAL_SCROLLBAR_ALWAYS), will ensure that the space for the corner component always exists.

To add a border around the main viewport, you can use setViewportBorder. (Of course, you can also add a border around the whole scroll pane using setBorder.)

A common operation to want to do is to set the background color that will be used if the main viewport view is smaller than the viewport, or is not opaque. This can be accomplished by setting the background color of the viewport, via scrollPane.getViewport().setBackground(). The reason for setting the color of the viewport and not the scrollpane is that by default JViewport is opaque which, among other things, means it will completely fill in its background using its background color. Therefore when JScrollPane draws its background the viewport will usually draw over it.

By default JScrollPane uses ScrollPaneLayout to handle the layout of its child Components. ScrollPaneLayout determines the size to make the viewport view in one of two ways:

  1. If the view implements Scrollable a combination of getPreferredScrollableViewportSize, getScrollableTracksViewportWidth and getScrollableTracksViewportHeightis used, otherwise
  2. getPreferredSize is used.

Warning: Swing is not thread safe. For more information see Swing's Threading Policy.

Warning: Serialized objects of this class will not be compatible with future Swing releases. The current serialization support is appropriate for short term storage or RMI between applications running the same version of Swing. As of 1.4, support for long term storage of all JavaBeansTM has been added to the java.beans package. Please see {@link java.beans.XMLEncoder}.

see
JScrollBar
see
JViewport
see
ScrollPaneLayout
see
Scrollable
see
Component#getPreferredSize
see
#setViewportView
see
#setRowHeaderView
see
#setColumnHeaderView
see
#setCorner
see
#setViewportBorder
beaninfo
attribute: isContainer true attribute: containerDelegate getViewport description: A specialized container that manages a viewport, optional scrollbars and headers
version
1.110 @(#)JScrollPane.java 1.110
author
Hans Muller

Fields Summary
private Border
viewportBorder
private static final String
uiClassID
protected int
verticalScrollBarPolicy
The display policy for the vertical scrollbar. The default is ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED.
protected int
horizontalScrollBarPolicy
The display policy for the horizontal scrollbar. The default is ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED.
protected JViewport
viewport
The scrollpane's viewport child. Default is an empty JViewport.
protected JScrollBar
verticalScrollBar
The scrollpane's vertical scrollbar child. Default is a JScrollBar.
protected JScrollBar
horizontalScrollBar
The scrollpane's horizontal scrollbar child. Default is a JScrollBar.
protected JViewport
rowHeader
The row header child. Default is null.
protected JViewport
columnHeader
The column header child. Default is null.
protected Component
lowerLeft
The component to display in the lower left corner. Default is null.
protected Component
lowerRight
The component to display in the lower right corner. Default is null.
protected Component
upperLeft
The component to display in the upper left corner. Default is null.
protected Component
upperRight
The component to display in the upper right corner. Default is null.
private boolean
wheelScrollState
Constructors Summary
public JScrollPane(Component view, int vsbPolicy, int hsbPolicy)
Creates a JScrollPane that displays the view component in a viewport whose view position can be controlled with a pair of scrollbars. The scrollbar policies specify when the scrollbars are displayed, For example, if vsbPolicy is VERTICAL_SCROLLBAR_AS_NEEDED then the vertical scrollbar only appears if the view doesn't fit vertically. The available policy settings are listed at {@link #setVerticalScrollBarPolicy} and {@link #setHorizontalScrollBarPolicy}.

see
#setViewportView
param
view the component to display in the scrollpanes viewport
param
vsbPolicy an integer that specifies the vertical scrollbar policy
param
hsbPolicy an integer that specifies the horizontal scrollbar policy


                                                                                         		         		      
           
    
	setLayout(new ScrollPaneLayout.UIResource());
        setVerticalScrollBarPolicy(vsbPolicy);
        setHorizontalScrollBarPolicy(hsbPolicy);
	setViewport(createViewport());
	setVerticalScrollBar(createVerticalScrollBar());
	setHorizontalScrollBar(createHorizontalScrollBar());
	if (view != null) {
	    setViewportView(view);
	}
	setOpaque(true);
        updateUI();

	if (!this.getComponentOrientation().isLeftToRight()) {
	    viewport.setViewPosition(new Point(Integer.MAX_VALUE, 0));
	}
    
public JScrollPane(Component view)
Creates a JScrollPane that displays the contents of the specified component, where both horizontal and vertical scrollbars appear whenever the component's contents are larger than the view.

see
#setViewportView
param
view the component to display in the scrollpane's viewport

        this(view, VERTICAL_SCROLLBAR_AS_NEEDED, HORIZONTAL_SCROLLBAR_AS_NEEDED);
    
public JScrollPane(int vsbPolicy, int hsbPolicy)
Creates an empty (no viewport view) JScrollPane with specified scrollbar policies. The available policy settings are listed at {@link #setVerticalScrollBarPolicy} and {@link #setHorizontalScrollBarPolicy}.

see
#setViewportView
param
vsbPolicy an integer that specifies the vertical scrollbar policy
param
hsbPolicy an integer that specifies the horizontal scrollbar policy

        this(null, vsbPolicy, hsbPolicy);
    
public JScrollPane()
Creates an empty (no viewport view) JScrollPane where both horizontal and vertical scrollbars appear when needed.

        this(null, VERTICAL_SCROLLBAR_AS_NEEDED, HORIZONTAL_SCROLLBAR_AS_NEEDED);
    
Methods Summary
public javax.swing.JScrollBarcreateHorizontalScrollBar()
Returns a JScrollPane.ScrollBar by default. Subclasses may override this method to force ScrollPaneUI implementations to use a JScrollBar subclass. Used by ScrollPaneUI implementations to create the horizontal scrollbar.

return
a JScrollBar with a horizontal orientation
see
JScrollBar

        return new ScrollBar(JScrollBar.HORIZONTAL);
    
public javax.swing.JScrollBarcreateVerticalScrollBar()
Returns a JScrollPane.ScrollBar by default. Subclasses may override this method to force ScrollPaneUI implementations to use a JScrollBar subclass. Used by ScrollPaneUI implementations to create the vertical scrollbar.

return
a JScrollBar with a vertical orientation
see
JScrollBar

        return new ScrollBar(JScrollBar.VERTICAL);
    
protected javax.swing.JViewportcreateViewport()
Returns a new JViewport by default. Used to create the viewport (as needed) in setViewportView, setRowHeaderView, and setColumnHeaderView. Subclasses may override this method to return a subclass of JViewport.

return
a new JViewport

        return new JViewport();
    
public javax.accessibility.AccessibleContextgetAccessibleContext()
Gets the AccessibleContext associated with this JScrollPane. For scroll panes, the AccessibleContext takes the form of an AccessibleJScrollPane. A new AccessibleJScrollPane instance is created if necessary.

return
an AccessibleJScrollPane that serves as the AccessibleContext of this JScrollPane

        if (accessibleContext == null) {
            accessibleContext = new AccessibleJScrollPane();
        }
        return accessibleContext;
    
public javax.swing.JViewportgetColumnHeader()
Returns the column header.

return
the columnHeader property
see
#setColumnHeader

        return columnHeader;
    
public java.awt.ComponentgetCorner(java.lang.String key)
Returns the component at the specified corner. The key value specifying the corner is one of:
  • ScrollPaneConstants.LOWER_LEFT_CORNER
  • ScrollPaneConstants.LOWER_RIGHT_CORNER
  • ScrollPaneConstants.UPPER_LEFT_CORNER
  • ScrollPaneConstants.UPPER_RIGHT_CORNER
  • ScrollPaneConstants.LOWER_LEADING_CORNER
  • ScrollPaneConstants.LOWER_TRAILING_CORNER
  • ScrollPaneConstants.UPPER_LEADING_CORNER
  • ScrollPaneConstants.UPPER_TRAILING_CORNER

param
key one of the values as shown above
return
the corner component (which may be null) identified by the given key, or null if the key is invalid
see
#setCorner

	boolean isLeftToRight = getComponentOrientation().isLeftToRight();
	if (key.equals(LOWER_LEADING_CORNER)) {
	    key = isLeftToRight ? LOWER_LEFT_CORNER : LOWER_RIGHT_CORNER;
	} else if (key.equals(LOWER_TRAILING_CORNER)) {
	    key = isLeftToRight ? LOWER_RIGHT_CORNER : LOWER_LEFT_CORNER;
	} else if (key.equals(UPPER_LEADING_CORNER)) {
	    key = isLeftToRight ? UPPER_LEFT_CORNER : UPPER_RIGHT_CORNER;
	} else if (key.equals(UPPER_TRAILING_CORNER)) {
	    key = isLeftToRight ? UPPER_RIGHT_CORNER : UPPER_LEFT_CORNER;
	}
	if (key.equals(LOWER_LEFT_CORNER)) {
	    return lowerLeft;
	}
	else if (key.equals(LOWER_RIGHT_CORNER)) {
	    return lowerRight;
	}
	else if (key.equals(UPPER_LEFT_CORNER)) {
	    return upperLeft;
	}
	else if (key.equals(UPPER_RIGHT_CORNER)) {
	    return upperRight;
	}
	else {
	    return null;
	}
    
public javax.swing.JScrollBargetHorizontalScrollBar()
Returns the horizontal scroll bar that controls the viewport's horizontal view position.

return
the horizontalScrollBar property
see
#setHorizontalScrollBar

        return horizontalScrollBar;
    
public intgetHorizontalScrollBarPolicy()
Returns the horizontal scroll bar policy value.

return
the horizontalScrollBarPolicy property
see
#setHorizontalScrollBarPolicy

	return horizontalScrollBarPolicy;
    
public javax.swing.JViewportgetRowHeader()
Returns the row header.

return
the rowHeader property
see
#setRowHeader

        return rowHeader;
    
public javax.swing.plaf.ScrollPaneUIgetUI()
Returns the look and feel (L&F) object that renders this component.

return
the ScrollPaneUI object that renders this component
see
#setUI
beaninfo
bound: true hidden: true attribute: visualUpdate true description: The UI object that implements the Component's LookAndFeel.

        return (ScrollPaneUI)ui;
    
public java.lang.StringgetUIClassID()
Returns the suffix used to construct the name of the L&F class used to render this component.

return
the string "ScrollPaneUI"
see
JComponent#getUIClassID
see
UIDefaults#getUI
beaninfo
hidden: true

        return uiClassID;
    
public javax.swing.JScrollBargetVerticalScrollBar()
Returns the vertical scroll bar that controls the viewports vertical view position.

return
the verticalScrollBar property
see
#setVerticalScrollBar

	return verticalScrollBar;
    
public intgetVerticalScrollBarPolicy()
Returns the vertical scroll bar policy value.

return
the verticalScrollBarPolicy property
see
#setVerticalScrollBarPolicy

        return verticalScrollBarPolicy;
    
public javax.swing.JViewportgetViewport()
Returns the current JViewport.

see
#setViewport
return
the viewport property

        return viewport;
    
public javax.swing.border.BordergetViewportBorder()
Returns the Border object that surrounds the viewport.

return
the viewportBorder property
see
#setViewportBorder

        return viewportBorder;
    
public java.awt.RectanglegetViewportBorderBounds()
Returns the bounds of the viewport's border.

return
a Rectangle object specifying the viewport border

	Rectangle borderR = new Rectangle(getSize());

	Insets insets = getInsets();
	borderR.x = insets.left;
	borderR.y = insets.top;
	borderR.width -= insets.left + insets.right;
	borderR.height -= insets.top + insets.bottom;

        boolean leftToRight = SwingUtilities.isLeftToRight(this);

	/* If there's a visible column header remove the space it 
	 * needs from the top of borderR.  
	 */

	JViewport colHead = getColumnHeader();
	if ((colHead != null) && (colHead.isVisible())) {
	    int colHeadHeight = colHead.getHeight();
	    borderR.y += colHeadHeight;
	    borderR.height -= colHeadHeight;
	}

	/* If there's a visible row header remove the space it needs
	 * from the left of borderR.  
	 */

	JViewport rowHead = getRowHeader();
	if ((rowHead != null) && (rowHead.isVisible())) {
	    int rowHeadWidth = rowHead.getWidth();
            if ( leftToRight ) {
	        borderR.x += rowHeadWidth;
	    }
	    borderR.width -= rowHeadWidth;
	}

	/* If there's a visible vertical scrollbar remove the space it needs
	 * from the width of borderR.  
	 */
	JScrollBar vsb = getVerticalScrollBar();
	if ((vsb != null) && (vsb.isVisible())) {
            int vsbWidth = vsb.getWidth();
            if ( !leftToRight ) {
                borderR.x += vsbWidth;
	    }
	    borderR.width -= vsbWidth;
	}

	/* If there's a visible horizontal scrollbar remove the space it needs
	 * from the height of borderR.  
	 */
	JScrollBar hsb = getHorizontalScrollBar();
	if ((hsb != null) && (hsb.isVisible())) {
	    borderR.height -= hsb.getHeight();
	}

	return borderR;
    
public booleanisValidateRoot()
Overridden to return true so that any calls to revalidate on any descendants of this JScrollPane will cause the entire tree beginning with this JScrollPane to be validated.

return
true
see
java.awt.Container#validate
see
JComponent#revalidate
see
JComponent#isValidateRoot
beaninfo
hidden: true

        return true;
    
public booleanisWheelScrollingEnabled()
Indicates whether or not scrolling will take place in response to the mouse wheel. Wheel scrolling is enabled by default.

see
#setWheelScrollingEnabled
since
1.4
beaninfo
bound: true description: Flag for enabling/disabling mouse wheel scrolling

return wheelScrollState;
protected java.lang.StringparamString()
Returns a string representation of this JScrollPane. This method is intended to be used only for debugging purposes, and the content and format of the returned string may vary between implementations. The returned string may be empty but may not be null.

return
a string representation of this JScrollPane.

        String viewportBorderString = (viewportBorder != null ?
				       viewportBorder.toString() : "");
        String viewportString = (viewport != null ?
				 viewport.toString() : "");
        String verticalScrollBarPolicyString;
        if (verticalScrollBarPolicy == VERTICAL_SCROLLBAR_AS_NEEDED) {
            verticalScrollBarPolicyString = "VERTICAL_SCROLLBAR_AS_NEEDED";
        } else if (verticalScrollBarPolicy == VERTICAL_SCROLLBAR_NEVER) {
            verticalScrollBarPolicyString = "VERTICAL_SCROLLBAR_NEVER";
        } else if (verticalScrollBarPolicy == VERTICAL_SCROLLBAR_ALWAYS) {
            verticalScrollBarPolicyString = "VERTICAL_SCROLLBAR_ALWAYS";
        } else verticalScrollBarPolicyString = "";
        String horizontalScrollBarPolicyString;
        if (horizontalScrollBarPolicy == HORIZONTAL_SCROLLBAR_AS_NEEDED) {
            horizontalScrollBarPolicyString = "HORIZONTAL_SCROLLBAR_AS_NEEDED";
        } else if (horizontalScrollBarPolicy == HORIZONTAL_SCROLLBAR_NEVER) {
            horizontalScrollBarPolicyString = "HORIZONTAL_SCROLLBAR_NEVER";
        } else if (horizontalScrollBarPolicy == HORIZONTAL_SCROLLBAR_ALWAYS) {
            horizontalScrollBarPolicyString = "HORIZONTAL_SCROLLBAR_ALWAYS";
        } else horizontalScrollBarPolicyString = "";
        String horizontalScrollBarString = (horizontalScrollBar != null ?
					    horizontalScrollBar.toString()
					    : "");
        String verticalScrollBarString = (verticalScrollBar != null ?
					  verticalScrollBar.toString() : "");
        String columnHeaderString = (columnHeader != null ?
				     columnHeader.toString() : "");
        String rowHeaderString = (rowHeader != null ?
				  rowHeader.toString() : "");
        String lowerLeftString = (lowerLeft != null ?
				  lowerLeft.toString() : "");
        String lowerRightString = (lowerRight != null ?
				  lowerRight.toString() : "");
        String upperLeftString = (upperLeft != null ?
				  upperLeft.toString() : "");
        String upperRightString = (upperRight != null ?
				  upperRight.toString() : "");

        return super.paramString() +
        ",columnHeader=" + columnHeaderString +
        ",horizontalScrollBar=" + horizontalScrollBarString +
        ",horizontalScrollBarPolicy=" + horizontalScrollBarPolicyString +
        ",lowerLeft=" + lowerLeftString +
        ",lowerRight=" + lowerRightString +
        ",rowHeader=" + rowHeaderString +
        ",upperLeft=" + upperLeftString +
        ",upperRight=" + upperRightString +
        ",verticalScrollBar=" + verticalScrollBarString +
        ",verticalScrollBarPolicy=" + verticalScrollBarPolicyString +
        ",viewport=" + viewportString +
        ",viewportBorder=" + viewportBorderString;
    
public voidsetColumnHeader(javax.swing.JViewport columnHeader)
Removes the old columnHeader, if it exists; if the new columnHeader isn't null, syncs the x coordinate of its viewPosition with the viewport (if there is one) and then adds it to the scroll pane.

Most applications will find it more convenient to use setColumnHeaderView to add a column header component and its viewport to the scroll pane.

see
#getColumnHeader
see
#setColumnHeaderView
beaninfo
bound: true description: The column header child for this scrollpane attribute: visualUpdate true

	JViewport old = getColumnHeader();
	this.columnHeader = columnHeader;	
	if (columnHeader != null) {
	    add(columnHeader, COLUMN_HEADER);
	}
	else if (old != null) {
	    remove(old);
	}
	firePropertyChange("columnHeader", old, columnHeader);

	revalidate();
	repaint();
    
public voidsetColumnHeaderView(java.awt.Component view)
Creates a column-header viewport if necessary, sets its view, and then adds the column-header viewport to the scrollpane. For example:
JScrollPane scrollpane = new JScrollPane();
scrollpane.setViewportView(myBigComponentToScroll);
scrollpane.setColumnHeaderView(myBigComponentsColumnHeader);

see
#setColumnHeader
see
JViewport#setView
param
view the component to display as the column header

        if (getColumnHeader() == null) {
            setColumnHeader(createViewport());
        }
        getColumnHeader().setView(view);
    
public voidsetComponentOrientation(java.awt.ComponentOrientation co)
Sets the orientation for the vertical and horizontal scrollbars as determined by the ComponentOrientation argument.

param
co one of the following values:
  • java.awt.ComponentOrientation.LEFT_TO_RIGHT
  • java.awt.ComponentOrientation.RIGHT_TO_LEFT
  • java.awt.ComponentOrientation.UNKNOWN
see
java.awt.ComponentOrientation

        super.setComponentOrientation( co );
        if( verticalScrollBar != null )
            verticalScrollBar.setComponentOrientation( co );
        if( horizontalScrollBar != null )
            horizontalScrollBar.setComponentOrientation( co );
    
public voidsetCorner(java.lang.String key, java.awt.Component corner)
Adds a child that will appear in one of the scroll panes corners, if there's room. For example with both scrollbars showing (on the right and bottom edges of the scrollpane) the lower left corner component will be shown in the space between ends of the two scrollbars. Legal values for the key are:
  • ScrollPaneConstants.LOWER_LEFT_CORNER
  • ScrollPaneConstants.LOWER_RIGHT_CORNER
  • ScrollPaneConstants.UPPER_LEFT_CORNER
  • ScrollPaneConstants.UPPER_RIGHT_CORNER
  • ScrollPaneConstants.LOWER_LEADING_CORNER
  • ScrollPaneConstants.LOWER_TRAILING_CORNER
  • ScrollPaneConstants.UPPER_LEADING_CORNER
  • ScrollPaneConstants.UPPER_TRAILING_CORNER

Although "corner" doesn't match any beans property signature, PropertyChange events are generated with the property name set to the corner key.

param
key identifies which corner the component will appear in
param
corner one of the following components:
  • lowerLeft
  • lowerRight
  • upperLeft
  • upperRight
exception
IllegalArgumentException if corner key is invalid

	Component old;
	boolean isLeftToRight = getComponentOrientation().isLeftToRight();
	if (key.equals(LOWER_LEADING_CORNER)) {
	    key = isLeftToRight ? LOWER_LEFT_CORNER : LOWER_RIGHT_CORNER;
	} else if (key.equals(LOWER_TRAILING_CORNER)) {
	    key = isLeftToRight ? LOWER_RIGHT_CORNER : LOWER_LEFT_CORNER;
	} else if (key.equals(UPPER_LEADING_CORNER)) {
	    key = isLeftToRight ? UPPER_LEFT_CORNER : UPPER_RIGHT_CORNER;
	} else if (key.equals(UPPER_TRAILING_CORNER)) {
	    key = isLeftToRight ? UPPER_RIGHT_CORNER : UPPER_LEFT_CORNER;
	}
	if (key.equals(LOWER_LEFT_CORNER)) {
	    old = lowerLeft;
	    lowerLeft = corner;
	}
	else if (key.equals(LOWER_RIGHT_CORNER)) {
	    old = lowerRight;
	    lowerRight = corner;
	}
	else if (key.equals(UPPER_LEFT_CORNER)) {
	    old = upperLeft;
	    upperLeft = corner;
	}
	else if (key.equals(UPPER_RIGHT_CORNER)) {
	    old = upperRight;
	    upperRight = corner;
	}
	else {
	    throw new IllegalArgumentException("invalid corner key");
	}
	if (old != null) {
	    remove(old);
	}
	if (corner != null) {
	    add(corner, key);
	}
	firePropertyChange(key, old, corner);
	revalidate();
	repaint();
    
public voidsetHorizontalScrollBar(javax.swing.JScrollBar horizontalScrollBar)
Adds the scrollbar that controls the viewport's horizontal view position to the scrollpane. This is usually unnecessary, as JScrollPane creates horizontal and vertical scrollbars by default.

param
horizontalScrollBar the horizontal scrollbar to be added
see
#createHorizontalScrollBar
see
#getHorizontalScrollBar
beaninfo
expert: true bound: true description: The horizontal scrollbar.

	JScrollBar old = getHorizontalScrollBar();
	this.horizontalScrollBar = horizontalScrollBar;
        if (horizontalScrollBar != null) {
            add(horizontalScrollBar, HORIZONTAL_SCROLLBAR);
        }
        else if (old != null) {
            remove(old);
        }
	firePropertyChange("horizontalScrollBar", old, horizontalScrollBar);

	revalidate();
	repaint();
    
public voidsetHorizontalScrollBarPolicy(int policy)
Determines when the horizontal scrollbar appears in the scrollpane. The options are:
  • ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED
  • ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER
  • ScrollPaneConstants.HORIZONTAL_SCROLLBAR_ALWAYS

param
policy one of the three values listed above
exception
IllegalArgumentException if policy is not one of the legal values shown above
see
#getHorizontalScrollBarPolicy
beaninfo
preferred: true bound: true description: The scrollpane scrollbar policy enum: HORIZONTAL_SCROLLBAR_AS_NEEDED ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED HORIZONTAL_SCROLLBAR_NEVER ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER HORIZONTAL_SCROLLBAR_ALWAYS ScrollPaneConstants.HORIZONTAL_SCROLLBAR_ALWAYS

	switch (policy) {
	case HORIZONTAL_SCROLLBAR_AS_NEEDED:
	case HORIZONTAL_SCROLLBAR_NEVER:
	case HORIZONTAL_SCROLLBAR_ALWAYS:
		break;
	default:
	    throw new IllegalArgumentException("invalid horizontalScrollBarPolicy");
	}
	int old = horizontalScrollBarPolicy;
	horizontalScrollBarPolicy = policy;
	firePropertyChange("horizontalScrollBarPolicy", old, policy);
	revalidate();
	repaint();
    
public voidsetLayout(java.awt.LayoutManager layout)
Sets the layout manager for this JScrollPane. This method overrides setLayout in java.awt.Container to ensure that only LayoutManagers which are subclasses of ScrollPaneLayout can be used in a JScrollPane. If layout is non-null, this will invoke syncWithScrollPane on it.

param
layout the specified layout manager
exception
ClassCastException if layout is not a ScrollPaneLayout
see
java.awt.Container#getLayout
see
java.awt.Container#setLayout
beaninfo
hidden: true

        if (layout instanceof ScrollPaneLayout) {
            super.setLayout(layout);
            ((ScrollPaneLayout)layout).syncWithScrollPane(this);
        }
        else if (layout == null) {
            super.setLayout(layout);
        }
	else {
	    String s = "layout of JScrollPane must be a ScrollPaneLayout";
	    throw new ClassCastException(s);
	}
    
public voidsetRowHeader(javax.swing.JViewport rowHeader)
Removes the old rowHeader, if it exists; if the new rowHeader isn't null, syncs the y coordinate of its viewPosition with the viewport (if there is one) and then adds it to the scroll pane.

Most applications will find it more convenient to use setRowHeaderView to add a row header component and its viewport to the scroll pane.

param
rowHeader the new row header to be used; if null the old row header is still removed and the new rowHeader is set to null
see
#getRowHeader
see
#setRowHeaderView
beaninfo
bound: true expert: true description: The row header child for this scrollpane

	JViewport old = getRowHeader();
	this.rowHeader = rowHeader;	
	if (rowHeader != null) {
	    add(rowHeader, ROW_HEADER);
	}
	else if (old != null) {
	    remove(old);
	}
	firePropertyChange("rowHeader", old, rowHeader);
	revalidate();
	repaint();
    
public voidsetRowHeaderView(java.awt.Component view)
Creates a row-header viewport if necessary, sets its view and then adds the row-header viewport to the scrollpane. For example:
JScrollPane scrollpane = new JScrollPane();
scrollpane.setViewportView(myBigComponentToScroll);
scrollpane.setRowHeaderView(myBigComponentsRowHeader);

see
#setRowHeader
see
JViewport#setView
param
view the component to display as the row header

        if (getRowHeader() == null) {
            setRowHeader(createViewport());
        }
        getRowHeader().setView(view);
    
public voidsetUI(javax.swing.plaf.ScrollPaneUI ui)
Sets the ScrollPaneUI object that provides the look and feel (L&F) for this component.

param
ui the ScrollPaneUI L&F object
see
#getUI

        super.setUI(ui);
    
public voidsetVerticalScrollBar(javax.swing.JScrollBar verticalScrollBar)
Adds the scrollbar that controls the viewports vertical view position to the scrollpane. This is usually unnecessary, as JScrollPane creates vertical and horizontal scrollbars by default.

param
verticalScrollBar the new vertical scrollbar to be added
see
#createVerticalScrollBar
see
#getVerticalScrollBar
beaninfo
expert: true bound: true description: The vertical scrollbar.

	JScrollBar old = getVerticalScrollBar();
	this.verticalScrollBar = verticalScrollBar;
	add(verticalScrollBar, VERTICAL_SCROLLBAR);
	firePropertyChange("verticalScrollBar", old, verticalScrollBar);

	revalidate();
	repaint();
    
public voidsetVerticalScrollBarPolicy(int policy)
Determines when the vertical scrollbar appears in the scrollpane. Legal values are:
  • ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED
  • ScrollPaneConstants.VERTICAL_SCROLLBAR_NEVER
  • ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS

param
policy one of the three values listed above
exception
IllegalArgumentException if policy is not one of the legal values shown above
see
#getVerticalScrollBarPolicy
beaninfo
preferred: true bound: true description: The scrollpane vertical scrollbar policy enum: VERTICAL_SCROLLBAR_AS_NEEDED ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED VERTICAL_SCROLLBAR_NEVER ScrollPaneConstants.VERTICAL_SCROLLBAR_NEVER VERTICAL_SCROLLBAR_ALWAYS ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS

	switch (policy) {
	case VERTICAL_SCROLLBAR_AS_NEEDED:
	case VERTICAL_SCROLLBAR_NEVER:
	case VERTICAL_SCROLLBAR_ALWAYS:
		break;
	default:
	    throw new IllegalArgumentException("invalid verticalScrollBarPolicy");
	}
	int old = verticalScrollBarPolicy;
	verticalScrollBarPolicy = policy;
	firePropertyChange("verticalScrollBarPolicy", old, policy);
	revalidate();
	repaint();
    
public voidsetViewport(javax.swing.JViewport viewport)
Removes the old viewport (if there is one); forces the viewPosition of the new viewport to be in the +x,+y quadrant; syncs up the row and column headers (if there are any) with the new viewport; and finally syncs the scrollbars and headers with the new viewport.

Most applications will find it more convenient to use setViewportView to add a viewport and a view to the scrollpane.

param
viewport the new viewport to be used; if viewport is null, the old viewport is still removed and the new viewport is set to null
see
#createViewport
see
#getViewport
see
#setViewportView
beaninfo
expert: true bound: true attribute: visualUpdate true description: The viewport child for this scrollpane

	JViewport old = getViewport();
	this.viewport = viewport;
	if (viewport != null) {
	    add(viewport, VIEWPORT);
	}
	else if (old != null) {
	    remove(old);
	}
	firePropertyChange("viewport", old, viewport);

	if (accessibleContext != null) {
	    ((AccessibleJScrollPane)accessibleContext).resetViewPort();
	}

	revalidate();
	repaint();
    
public voidsetViewportBorder(javax.swing.border.Border viewportBorder)
Adds a border around the viewport. Note that the border isn't set on the viewport directly, JViewport doesn't support the JComponent border property. Similarly setting the JScrollPanes viewport doesn't affect the viewportBorder property.

The default value of this property is computed by the look and feel implementation.

param
viewportBorder the border to be added
see
#getViewportBorder
see
#setViewport
beaninfo
preferred: true bound: true description: The border around the viewport.

        Border oldValue = this.viewportBorder;
        this.viewportBorder = viewportBorder;
        firePropertyChange("viewportBorder", oldValue, viewportBorder);
    
public voidsetViewportView(java.awt.Component view)
Creates a viewport if necessary and then sets its view. Applications that don't provide the view directly to the JScrollPane constructor should use this method to specify the scrollable child that's going to be displayed in the scrollpane. For example:
JScrollPane scrollpane = new JScrollPane();
scrollpane.setViewportView(myBigComponentToScroll);
Applications should not add children directly to the scrollpane.

param
view the component to add to the viewport
see
#setViewport
see
JViewport#setView

        if (getViewport() == null) {
            setViewport(createViewport());
        }
        getViewport().setView(view);
    
public voidsetWheelScrollingEnabled(boolean handleWheel)
Enables/disables scrolling in response to movement of the mouse wheel. Wheel scrolling is enabled by default.

param
handleWheel true if scrolling should be done automatically for a MouseWheelEvent, false otherwise.
see
#isWheelScrollingEnabled
see
java.awt.event.MouseWheelEvent
see
java.awt.event.MouseWheelListener
since
1.4
beaninfo
bound: true description: Flag for enabling/disabling mouse wheel scrolling

        boolean old = wheelScrollState;
        wheelScrollState = handleWheel;
        firePropertyChange("wheelScrollingEnabled", old, handleWheel);
    
public voidupdateUI()
Replaces the current ScrollPaneUI object with a version from the current default look and feel. To be called when the default look and feel changes.

see
JComponent#updateUI
see
UIManager#getUI

        setUI((ScrollPaneUI)UIManager.getUI(this));
    
private voidwriteObject(java.io.ObjectOutputStream s)
See readObject and writeObject in JComponent for more information about serialization in Swing.

        s.defaultWriteObject();
        if (getUIClassID().equals(uiClassID)) {
            byte count = JComponent.getWriteObjCounter(this);
            JComponent.setWriteObjCounter(this, --count);
            if (count == 0 && ui != null) {
                ui.installUI(this);
            }
        }