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 JavaBeans^TM has been added to the java.beans package. Please see {@link java.beans.XMLEncoder}. 

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 JavaBeans^TM has been added to the java.beans package. Please see {@link java.beans.XMLEncoder}. 

Also see:

setVerticalScrollBarPolicy

Also see:

setHorizontalScrollBarPolicy

Also see:

setViewport

Also see:

setVerticalScrollBar

Also see:

setHorizontalScrollBar

Also see:

setRowHeader

Also see:

setColumnHeader

Also see:

setCorner

Also see:

setCorner

Also see:

setCorner

Also see:

setCorner

 public JScrollPane() 
{
        this(null, VERTICAL_SCROLLBAR_AS_NEEDED, HORIZONTAL_SCROLLBAR_AS_NEEDED);
}

Creates an empty (no viewport view) JScrollPane where both horizontal and vertical scrollbars appear when needed.

 public JScrollPane(Component view) 
{
        this(view, VERTICAL_SCROLLBAR_AS_NEEDED, HORIZONTAL_SCROLLBAR_AS_NEEDED);
}

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.

Parameters:

view - the component to display in the scrollpane's viewport

Also see:

setViewportView

 public JScrollPane(int vsbPolicy,
    int hsbPolicy) 
{
        this(null, vsbPolicy, hsbPolicy);
}

Creates an empty (no viewport view) JScrollPane with specified scrollbar policies. The available policy settings are listed at #setVerticalScrollBarPolicy and #setHorizontalScrollBarPolicy .

Parameters:

vsbPolicy - an integer that specifies the vertical scrollbar policy

hsbPolicy - an integer that specifies the horizontal scrollbar policy

Also see:

setViewportView

 public JScrollPane(Component view,
    int vsbPolicy,
    int hsbPolicy) 
{
        setLayout(new ScrollPaneLayout.UIResource());
        setVerticalScrollBarPolicy(vsbPolicy);
        setHorizontalScrollBarPolicy(hsbPolicy);
        setViewport(createViewport());
        setVerticalScrollBar(createVerticalScrollBar());
        setHorizontalScrollBar(createHorizontalScrollBar());
        if (view != null) {
            setViewportView(view);
        }
        setUIProperty("opaque",true);
        updateUI();
        if (!this.getComponentOrientation().isLeftToRight()) {
            viewport.setViewPosition(new Point(Integer.MAX_VALUE, 0));
        }
}

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 #setVerticalScrollBarPolicy and #setHorizontalScrollBarPolicy .

Parameters:

view - the component to display in the scrollpanes viewport

vsbPolicy - an integer that specifies the vertical scrollbar policy

hsbPolicy - an integer that specifies the horizontal scrollbar policy

Also see:

setViewportView

 public JScrollBar createHorizontalScrollBar() 
{
        return new ScrollBar(JScrollBar.HORIZONTAL);
}

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.

 public JScrollBar createVerticalScrollBar() 
{
        return new ScrollBar(JScrollBar.VERTICAL);
}

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.

 protected JViewport createViewport() 
{
        return new JViewport();
}

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.

 public AccessibleContext getAccessibleContext() 
{
        if (accessibleContext == null) {
            accessibleContext = new AccessibleJScrollPane();
        }
        return accessibleContext;
}

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.

 public JViewport getColumnHeader() 
{
        return columnHeader;
}

Returns the column header.

 public Component getCorner(String key) 
{
        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;
        }
}

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

 public JScrollBar getHorizontalScrollBar() 
{
        return horizontalScrollBar;
}

Returns the horizontal scroll bar that controls the viewport's horizontal view position.

 public int getHorizontalScrollBarPolicy() 
{
        return horizontalScrollBarPolicy;
}

Returns the horizontal scroll bar policy value.

 public JViewport getRowHeader() 
{
        return rowHeader;
}

Returns the row header.

 public ScrollPaneUI getUI() 
{
        return (ScrollPaneUI)ui;
}

Returns the look and feel (L&F) object that renders this component.

 public String getUIClassID() 
{
        return uiClassID;
}

Returns the suffix used to construct the name of the L&F class used to render this component.

 public JScrollBar getVerticalScrollBar() 
{
        return verticalScrollBar;
}

Returns the vertical scroll bar that controls the viewports vertical view position.

 public int getVerticalScrollBarPolicy() 
{
        return verticalScrollBarPolicy;
}

Returns the vertical scroll bar policy value.

 public JViewport getViewport() 
{
        return viewport;
}

Returns the current JViewport.

 public Border getViewportBorder() 
{
        return viewportBorder;
}

Returns the Border object that surrounds the viewport.

 public Rectangle getViewportBorderBounds() 
{
        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;
}

Returns the bounds of the viewport's border.

 public boolean isValidateRoot() 
{
        return true;
}

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.

 public boolean isWheelScrollingEnabled() 
{
return wheelScrollState;
}

Indicates whether or not scrolling will take place in response to the mouse wheel. Wheel scrolling is enabled by default.

 protected String paramString() 
{
        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;
}

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.

 public  void setColumnHeader(JViewport columnHeader) 
{
        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();
}

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.

 public  void setColumnHeaderView(Component view) 
{
        if (getColumnHeader() == null) {
            setColumnHeader(createViewport());
        }
        getColumnHeader().setView(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);

 public  void setComponentOrientation(ComponentOrientation co) 
{
        super.setComponentOrientation( co );
        if( verticalScrollBar != null )
            verticalScrollBar.setComponentOrientation( co );
        if( horizontalScrollBar != null )
            horizontalScrollBar.setComponentOrientation( co );
}

Sets the orientation for the vertical and horizontal scrollbars as determined by the ComponentOrientation argument.

 public  void setCorner(String key,
    Component corner) 
{
        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();
}

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.

 public  void setHorizontalScrollBar(JScrollBar horizontalScrollBar) 
{
        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();
}

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.

 public  void setHorizontalScrollBarPolicy(int policy) 
{
        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();
}

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

 public  void setLayout(LayoutManager layout) 
{
        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);
        }
}

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.

 public  void setRowHeader(JViewport rowHeader) 
{
        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();
}

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.

 public  void setRowHeaderView(Component view) 
{
        if (getRowHeader() == null) {
            setRowHeader(createViewport());
        }
        getRowHeader().setView(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);

 public  void setUI(ScrollPaneUI ui) 
{
        super.setUI(ui);
}

Sets the ScrollPaneUI object that provides the look and feel (L&F) for this component.

 public  void setVerticalScrollBar(JScrollBar verticalScrollBar) 
{
        JScrollBar old = getVerticalScrollBar();
        this.verticalScrollBar = verticalScrollBar;
        add(verticalScrollBar, VERTICAL_SCROLLBAR);
        firePropertyChange("verticalScrollBar", old, verticalScrollBar);
        revalidate();
        repaint();
}

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.

 public  void setVerticalScrollBarPolicy(int policy) 
{
        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();
}

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

 public  void setViewport(JViewport viewport) 
{
        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();
}

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.

 public  void setViewportBorder(Border viewportBorder) 
{
        Border oldValue = this.viewportBorder;
        this.viewportBorder = viewportBorder;
        firePropertyChange("viewportBorder", oldValue, 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.

 public  void setViewportView(Component view) 
{
        if (getViewport() == null) {
            setViewport(createViewport());
        }
        getViewport().setView(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.

 public  void setWheelScrollingEnabled(boolean handleWheel) 
{
        boolean old = wheelScrollState;
        wheelScrollState = handleWheel;
        firePropertyChange("wheelScrollingEnabled", old, handleWheel);
}

Enables/disables scrolling in response to movement of the mouse wheel. Wheel scrolling is enabled by default.

 public  void updateUI() 
{
        setUI((ScrollPaneUI)UIManager.getUI(this));
}

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.